quantprobe 1.3.0__py3-none-any.whl

quantprobe/__init__.py

@@ -0,0 +1,11 @@
+"""quantprobe — probe-then-quantize for LLMs on commodity hardware.
+
+Three commands, all grounded in measured laws (see LAWS.md in the repo):
+  quantprobe probe  — measure a GGUF's depth-fragility curve, emit the depth-aware recipe (Law 3)
+  quantprobe plan   — evaluate every bit/tier placement for a model on your machine, predict tok/s (Law 4)
+  quantprobe fetch  — robust HuggingFace downloader (Range-resume, retry)
+
+Every constant in `plan` is fitted from measurements published in the repo, including two
+pre-registered hardware predictions confirmed within 8%.
+"""
+__version__ = "1.3.0"

quantprobe/cli.py

@@ -0,0 +1,124 @@
+"""quantprobe CLI — probe / plan / fetch."""
+from __future__ import annotations
+import argparse
+
+from .plan import numlist
+
+
+def main():
+    import sys
+    try:
+        sys.stdout.reconfigure(errors="replace")
+    except Exception:
+        pass
+    ap = argparse.ArgumentParser(
+        prog="quantprobe",
+        description="Probe-then-quantize for LLMs: fragility curves, placement plans, recipes. "
+                    "Laws + evidence: github.com/FedericoTs/quantprobe")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("probe", help="measure a GGUF's depth-fragility curve, emit the recipe (Law 3)")
+    p.add_argument("--gguf", required=True, help="f16/bf16 (or high-precision) source GGUF")
+    p.add_argument("--bands", type=int, default=4)
+    p.add_argument("--chunks", type=int, default=32)
+    p.add_argument("--eval", required=True, help="raw text eval file (e.g. wikitext-2 test)")
+    p.add_argument("--ngl", type=int, default=99, help="GPU layers for perplexity (0 for CPU)")
+    p.add_argument("--workdir", default=None)
+    p.add_argument("--llama-dir", default=None, help="dir containing llama-quantize/llama-perplexity")
+    p.add_argument("--apply", action="store_true", help="after probing, BUILD the recommended depth-aware GGUF")
+    p.add_argument("--out", default=None, help="output path for --apply (default: <model>-depthaware.gguf)")
+    p.add_argument("--dry-run", action="store_true")
+
+    q = sub.add_parser("plan", help="evaluate every bit/tier placement, predict tok/s (Law 4)")
+    q.add_argument("--model", default=None, help="preset: qwen3-30b deepseek-16b gemma-12b mistral-7b glm-air glm-744b")
+    q.add_argument("--machine", default=None, help="preset: 2016-xmp 2016 gaming ddr5 colibri")
+    q.add_argument("--bits", type=float, default=None, help="effective bits/weight (default: read from --gguf, else 2.5)")
+    q.add_argument("--total", type=float, help="total params (B)")
+    q.add_argument("--active", type=float, help="active params per token (B)")
+    q.add_argument("--always-active", type=float, help="always-active (attention/embed) params (B)")
+    q.add_argument("--vram", type=numlist, help="GB; comma-list for multi-GPU: 24,24"); q.add_argument("--vram-bw", type=numlist, help="GB/s; comma-list aggregates x0.85")
+    q.add_argument("--ram", type=float); q.add_argument("--ram-bw", type=float)
+    q.add_argument("--disk-bw", type=numlist, help="GB/s; comma-list (RAID) aggregates x0.75")
+    q.add_argument("--gguf", default=None, help="optional: read total/active/bits/KV exactly from this GGUF")
+    q.add_argument("--ctx", type=int, default=0, help="context depth: adds KV reads/token + KV memory to the prediction (Law 4 v2)")
+    q.add_argument("--kv-per-pos", type=float, default=None, help="KV bytes per position in KB (default: model preset, or 96)")
+
+    def hwargs(sp):
+        sp.add_argument("--model", default=None); sp.add_argument("--machine", default=None)
+        sp.add_argument("--bits", type=float, default=None, help="effective bits/weight (default: read from --gguf, else 2.5)")
+        sp.add_argument("--total", type=float); sp.add_argument("--active", type=float)
+        sp.add_argument("--always-active", type=float)
+        sp.add_argument("--vram", type=numlist); sp.add_argument("--vram-bw", type=numlist)
+        sp.add_argument("--ram", type=float); sp.add_argument("--ram-bw", type=float)
+        sp.add_argument("--disk-bw", type=numlist)
+        sp.add_argument("--ctx", type=int, default=0, help="context depth for the prediction (Law 4 v2)")
+        sp.add_argument("--kv-per-pos", type=float, default=None, help="KV bytes per position in KB")
+        sp.add_argument("--llama-dir", default=None); sp.add_argument("--dry", action="store_true")
+
+    r = sub.add_parser("run", help="plan the best placement, then launch llama.cpp chat with those flags")
+    r.add_argument("--gguf", required=True); hwargs(r)
+    r.add_argument("--serve", action="store_true", help="launch llama-server instead of interactive chat")
+    r.add_argument("--extra", default=None, help="extra flags passed through to llama.cpp")
+
+    b = sub.add_parser("bench", help="measure real tok/s with the planned flags; print predicted vs measured")
+    b.add_argument("--gguf", required=True); hwargs(b)
+    b.add_argument("--reps", type=int, default=3)
+    b.add_argument("--depth", type=int, default=None, help="bench at KV depth N (llama-bench -d): measures the Law 4 v2 context term on YOUR box")
+    b.add_argument("--contribute", action="store_true", help="print a pre-filled, opt-in GitHub issue with your predicted-vs-measured point (you review before submitting; nothing auto-sent)")
+
+    d = sub.add_parser("dashboard", help="launch llama-server with planned flags + a live predicted-vs-measured chat page")
+    d.add_argument("--gguf", required=True); hwargs(d)
+    d.add_argument("--port", type=int, default=8077); d.add_argument("--server-port", type=int, default=8090)
+    d.add_argument("--no-open", action="store_true")
+
+    g = sub.add_parser("target", help="INVERSE planning: give a tok/s target, get the smartest feasible model + the speed-intelligence ladder")
+    g.add_argument("--tps", type=float, required=True, help="minimum tok/s you need")
+    hwargs(g)
+    g.add_argument("--ladder", action="store_true", help="print the full speed-vs-intelligence ladder")
+
+    z = sub.add_parser("quantize", help="COMPRESS: build a depth-aware GGUF from a model (protect the fragile band, rest 2-bit)")
+    z.add_argument("--gguf", required=True, help="high-precision source GGUF (f16/bf16/Q8)")
+    z.add_argument("--out", default=None, help="output path (default: <model>-depthaware.gguf)")
+    z.add_argument("--protect-late", type=int, default=12, help="protect the last N layers at 4-bit (default 12)")
+    z.add_argument("--protect", default=None, help="protect an explicit band LO-HI (e.g. 36-47) instead of --protect-late")
+    z.add_argument("--llama-dir", default=None)
+    z.add_argument("--dry", action="store_true")
+
+    hwp = sub.add_parser("hw", help="detect THIS machine's memory tiers (no flags needed); every value tagged with its source")
+    hwp.add_argument("--measure", default=None, metavar="FILE", help="also MEASURE sequential disk read on a real file (e.g. a GGUF)")
+
+    f = sub.add_parser("fetch", help="robust HF download (Range-resume, retry)")
+    f.add_argument("repo", help="HF repo, or a preset: qwen3-30b, glm-air, deepseek-16b, qwen3-0.6b"); f.add_argument("dest"); f.add_argument("files", nargs="*")
+
+    a = ap.parse_args()
+    if a.cmd == "probe":
+        from . import probe
+        probe.run(a)
+    elif a.cmd == "plan":
+        from . import plan
+        plan.run(a)
+    elif a.cmd == "run":
+        from . import runtime
+        runtime.run(a)
+    elif a.cmd == "bench":
+        from . import runtime
+        runtime.bench(a)
+    elif a.cmd == "dashboard":
+        from . import dashboard
+        dashboard.dashboard(a)
+    elif a.cmd == "target":
+        from . import target
+        target.run(a)
+    elif a.cmd == "hw":
+        from . import detect
+        detect.run(a)
+    elif a.cmd == "quantize":
+        from . import probe
+        probe.quantize(a)
+    else:
+        from . import fetch
+        fetch.run(a)
+
+
+if __name__ == "__main__":
+    main()

quantprobe/dashboard.py

@@ -0,0 +1,179 @@
+"""quantprobe dashboard — the law, live.
+
+One command: plans the best placement, launches llama-server with those flags, and serves a local
+page where you chat with the model while every reply is scored against the law's prediction —
+predicted vs measured tok/s, live. Colibri-style dashboard energy, but the star is falsifiability:
+the page is a running experiment, not a status screen.
+"""
+from __future__ import annotations
+import json, os, subprocess, sys, threading, time, urllib.request, webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from . import runtime
+
+DASH_HTML = """<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>quantprobe — the law, live</title>
+<style>
+:root{--g:#fafaf7;--p:#fff;--ink:#16181d;--sub:#5c6066;--line:#e5e4df;--acc:#0f766e;
+--accsoft:#e6f2f0;--warn:#b45309;--mono:Consolas,ui-monospace,monospace}
+@media(prefers-color-scheme:dark){:root{--g:#14161a;--p:#1c1f24;--ink:#e8e7e2;--sub:#9aa0a8;
+--line:#2e3238;--acc:#35b8a6;--accsoft:#12332f;--warn:#e0a458}}
+body{margin:0;background:var(--g);color:var(--ink);font-family:"Segoe UI",system-ui,sans-serif}
+.wrap{max-width:980px;margin:0 auto;padding:22px 16px}
+h1{font-size:21px;margin:0 0 4px}.sub{color:var(--sub);font-size:13px;margin-bottom:16px}
+.law{font-family:var(--mono);font-size:12.5px;color:var(--acc);margin-bottom:14px}
+.cols{display:grid;grid-template-columns:340px 1fr;gap:16px}
+@media(max-width:760px){.cols{grid-template-columns:1fr}}
+.panel{background:var(--p);border:1px solid var(--line);border-radius:10px;padding:14px}
+.k{font-size:10.5px;text-transform:uppercase;letter-spacing:.09em;color:var(--sub);font-weight:600;margin-bottom:8px}
+.gauge{display:flex;gap:18px;align-items:baseline}
+.gauge .n{font-family:var(--mono);font-size:44px;font-weight:700;color:var(--acc);font-variant-numeric:tabular-nums}
+.gauge .lab{font-size:11px;color:var(--sub)}
+.delta{font-family:var(--mono);font-size:15px;font-weight:600}
+.tier{margin:8px 0}.tier .l{display:flex;justify-content:space-between;font-family:var(--mono);font-size:11px;color:var(--sub);margin-bottom:3px}
+.bar{height:11px;background:var(--g);border:1px solid var(--line);border-radius:6px;overflow:hidden}
+.fill{height:100%;background:var(--acc)}
+.log{font-family:var(--mono);font-size:11.5px;color:var(--sub);max-height:120px;overflow-y:auto;margin-top:8px}
+.chat{display:flex;flex-direction:column;height:520px}
+.msgs{flex:1;overflow-y:auto;display:flex;flex-direction:column;gap:8px;padding-bottom:8px}
+.m{max-width:85%;padding:8px 12px;border-radius:10px;font-size:14px;line-height:1.5;white-space:pre-wrap}
+.m.u{align-self:flex-end;background:var(--accsoft);color:var(--ink)}
+.m.a{align-self:flex-start;background:var(--g);border:1px solid var(--line)}
+.m .t{display:block;margin-top:6px;font-family:var(--mono);font-size:10.5px;color:var(--acc)}
+.row{display:flex;gap:8px}
+textarea{flex:1;resize:none;height:54px;padding:9px;font-size:14px;font-family:inherit;
+background:var(--g);color:var(--ink);border:1px solid var(--line);border-radius:8px}
+button{padding:0 18px;background:var(--acc);color:#fff;border:0;border-radius:8px;font-size:14px;font-weight:600;cursor:pointer}
+button:disabled{opacity:.5}
+.foot{margin-top:14px;font-size:11.5px;color:var(--sub)}.foot a{color:var(--acc)}
+</style></head><body><div class="wrap">
+<h1>The law, live</h1>
+<div class="sub">{{MODEL}} · {{PLACEMENT}} · every reply below is scored against the pre-registered prediction</div>
+<div class="law">tok/s = η(tier) × bandwidth ÷ active-bytes-per-token &nbsp;→&nbsp; predicted {{PRED}} tok/s for this box</div>
+<div class="cols">
+<div>
+<div class="panel"><div class="k">Prediction vs reality</div>
+  <div class="gauge">
+    <div><div class="n" id="pred">{{PRED}}</div><div class="lab">predicted tok/s</div></div>
+    <div><div class="n" id="meas">—</div><div class="lab">measured (running avg)</div></div>
+    <div class="delta" id="delta"></div>
+  </div>
+  <div class="log" id="log">each reply appends a data point…</div>
+</div>
+<div class="panel" style="margin-top:14px"><div class="k">Placement (planned)</div>{{TIERS}}
+<div class="foot">Flags: <span style="font-family:var(--mono)">{{FLAGS}}</span></div></div>
+<div class="panel" style="margin-top:14px"><div class="k">About</div>
+<div class="foot">This page is a running experiment: the tiered decode law predicted this machine's speed
+before the model loaded. Laws, probes, evidence: <a href="https://github.com/FedericoTs/quantprobe">repo</a>
+· <a href="https://x.com/federico_sciuca">@federico_sciuca</a></div></div>
+</div>
+<div class="panel chat"><div class="k">Chat — each reply is a measurement</div>
+  <div class="msgs" id="msgs"></div>
+  <div class="row"><textarea id="inp" placeholder="Say something… (Enter to send)"></textarea>
+  <button id="send">Send</button></div>
+</div>
+</div></div>
+<script>
+const hist=[],pts=[];const $=id=>document.getElementById(id);
+function esc(s){return s.replace(/&/g,"&amp;").replace(/</g,"&lt;")}
+async function send(){
+  const t=$("inp").value.trim(); if(!t)return;
+  $("inp").value=""; $("send").disabled=true;
+  hist.push({role:"user",content:t});
+  $("msgs").insertAdjacentHTML("beforeend",'<div class="m u">'+esc(t)+'</div>');
+  const hold=document.createElement("div");hold.className="m a";hold.textContent="…";
+  $("msgs").appendChild(hold);$("msgs").scrollTop=1e9;
+  try{
+    const r=await fetch("/api/chat",{method:"POST",headers:{"Content-Type":"application/json"},
+      body:JSON.stringify({messages:hist.slice(-12),max_tokens:256})});
+    const j=await r.json();
+    const msg=(j.choices&&j.choices[0].message.content)||"(no reply)";
+    const tps=j.timings?j.timings.predicted_per_second:null;
+    hist.push({role:"assistant",content:msg});
+    hold.innerHTML=esc(msg)+(tps?'<span class="t">'+tps.toFixed(1)+' tok/s · predicted {{PRED}}</span>':'');
+    if(tps){pts.push(tps);
+      const avg=pts.reduce((a,b)=>a+b,0)/pts.length,pred=parseFloat("{{PRED}}");
+      $("meas").textContent=avg.toFixed(1);
+      const d=(avg/pred-1)*100;
+      $("delta").textContent=(d>=0?"+":"")+d.toFixed(0)+"%";
+      $("delta").style.color=Math.abs(d)<25?"var(--acc)":"var(--warn)";
+      $("log").insertAdjacentHTML("afterbegin","#"+pts.length+": "+tps.toFixed(1)+" tok/s<br>");}
+  }catch(e){hold.textContent="error: "+e}
+  $("send").disabled=false;$("msgs").scrollTop=1e9;
+}
+$("send").onclick=send;
+$("inp").addEventListener("keydown",e=>{if(e.key==="Enter"&&!e.shiftKey){e.preventDefault();send();}});
+</script></body></html>"""
+
+
+def make_handler(upstream, page):
+    class H(BaseHTTPRequestHandler):
+        def log_message(self, *a):
+            pass
+
+        def do_GET(self):
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(page.encode("utf-8"))
+
+        def do_POST(self):
+            if self.path != "/api/chat":
+                self.send_response(404); self.end_headers(); return
+            n = int(self.headers.get("Content-Length", 0))
+            body = json.loads(self.rfile.read(n) or b"{}")
+            body.setdefault("timings_per_token", True)
+            req = urllib.request.Request(upstream + "/v1/chat/completions",
+                                         data=json.dumps(body).encode(),
+                                         headers={"Content-Type": "application/json"})
+            try:
+                with urllib.request.urlopen(req, timeout=600) as r:
+                    data = r.read()
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(data)
+            except Exception as e:
+                self.send_response(502); self.end_headers()
+                self.wfile.write(json.dumps({"error": str(e)}).encode())
+    return H
+
+
+def dashboard(a):
+    best, flags = runtime.best_flags(a)
+    binp = runtime.find_llama(a.llama_dir, "llama-server")
+    sport = a.server_port
+    cmd = [binp, "-m", a.gguf, "--port", str(sport)] + flags
+    print(f"[quantprobe] placement: {best[0]}  (predicted {best[1]:.1f} tok/s)")
+    print("[quantprobe] llama-server:", " ".join(cmd))
+    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    upstream = f"http://127.0.0.1:{sport}"
+    for _ in range(120):
+        try:
+            urllib.request.urlopen(upstream + "/health", timeout=2)
+            break
+        except Exception:
+            if proc.poll() is not None:
+                raise SystemExit("llama-server exited during startup — check the model path/flags")
+            time.sleep(1)
+    tiers = ""
+    for name, cap, used in runtime.tier_view(a, best):
+        pct = min(100, used / cap * 100) if cap else 0
+        tiers += (f'<div class="tier"><div class="l"><span>{name}</span>'
+                  f'<span>{used:.1f} / {cap:.0f} GB</span></div>'
+                  f'<div class="bar"><div class="fill" style="width:{pct:.0f}%"></div></div></div>')
+    page = (DASH_HTML.replace("{{MODEL}}", os.path.basename(a.gguf))
+            .replace("{{PLACEMENT}}", best[0]).replace("{{PRED}}", f"{best[1]:.1f}")
+            .replace("{{FLAGS}}", " ".join(flags)).replace("{{TIERS}}", tiers))
+    srv = ThreadingHTTPServer(("127.0.0.1", a.port), make_handler(upstream, page))
+    url = f"http://127.0.0.1:{a.port}"
+    print(f"[quantprobe] dashboard: {url}  (Ctrl-C stops both)")
+    if not a.no_open:
+        threading.Timer(1.0, lambda: webbrowser.open(url)).start()
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        proc.terminate()

quantprobe/detect.py

@@ -0,0 +1,163 @@
+"""quantprobe hw — read the local machine's memory tiers, no questions asked.
+
+Every printed value is tagged with its source:
+  [os]      read from the operating system / driver (capacity, stick speed, GPU name)
+  [table]   looked up from the device name (bandwidth spec, eta class)
+  [default] a conservative fallback — override it with flags
+Bandwidths are THEORETICAL peaks (the law's eta absorbs realism, same convention as the presets).
+Nothing is sent anywhere; this only reads local OS interfaces.
+"""
+from __future__ import annotations
+import os, platform, re, shutil, subprocess
+
+
+def _run(cmd, timeout=10):
+    try:
+        return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout).stdout
+    except Exception:
+        return ""
+
+
+# name-fragment -> (VRAM bandwidth GB/s, geta, gl). 1060 measured on the reference box; rest spec-sheet [table].
+GPU_TABLE = [
+    ("5090", 1792, 0.62, 0.42), ("4090", 1008, 0.62, 0.42), ("4080", 717, 0.6, 0.4),
+    ("4070", 504, 0.55, 0.35), ("4060", 272, 0.5, 0.3),
+    ("3090", 936, 0.6, 0.4), ("3080", 760, 0.58, 0.38), ("3070", 448, 0.52, 0.32),
+    ("3060 ti", 448, 0.5, 0.3), ("3060", 360, 0.5, 0.3), ("3050", 224, 0.45, 0.28),
+    ("2080", 448, 0.45, 0.25), ("2070", 448, 0.45, 0.25), ("2060", 336, 0.42, 0.22),
+    ("1080", 320, 0.38, 0.06), ("1070", 256, 0.36, 0.05), ("1060", 192, 0.35, 0.04),
+    ("a100", 1935, 0.7, 0.55), ("h100", 3350, 0.75, 0.6), ("rtx 6000", 960, 0.62, 0.42),
+]
+MAC_BW = {"m1 ultra": 800, "m1 max": 400, "m1 pro": 200, "m1": 68,
+          "m2 ultra": 800, "m2 max": 400, "m2 pro": 200, "m2": 100,
+          "m3 ultra": 819, "m3 max": 400, "m3 pro": 150, "m3": 100,
+          "m4 max": 546, "m4 pro": 273, "m4": 120}
+
+
+def gpus():
+    """[(name, vram_gb)] via nvidia-smi; empty list if none/AMD (AMD: pass flags for now)."""
+    out = _run(["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"])
+    gs = []
+    for line in out.strip().splitlines():
+        if "," in line:
+            name, mem = line.rsplit(",", 1)
+            try:
+                gs.append((name.strip(), float(mem) / 1024))
+            except ValueError:
+                pass
+    return gs
+
+
+def gpu_lookup(name):
+    n = name.lower()
+    for frag, bw, geta, gl in GPU_TABLE:
+        if frag in n:
+            return bw, geta, gl, "[table]"
+    return 300, 0.45, 0.27, "[default: unknown GPU, pass --vram-bw]"
+
+
+def ram_windows():
+    """(total_gb[os], mts[os], channels[os]) via CIM (wmic fallback)."""
+    ps = _run(["powershell", "-NoProfile", "-c",
+               "$m=Get-CimInstance Win32_PhysicalMemory; "
+               "($m|Measure-Object Capacity -Sum).Sum; "
+               "($m|Select-Object -First 1).ConfiguredClockSpeed; ($m|Measure-Object).Count"])
+    vals = [v.strip() for v in ps.strip().splitlines() if v.strip()]
+    if len(vals) >= 3:
+        try:
+            return float(vals[0]) / 2**30, float(vals[1]), int(vals[2])
+        except ValueError:
+            pass
+    return None, None, None
+
+
+def detect():
+    """Return the machine as quantprobe hardware kwargs + a provenance report."""
+    sysname = platform.system()
+    hw, notes = {}, []
+
+    if sysname == "Darwin":
+        mem = _run(["sysctl", "-n", "hw.memsize"]).strip()
+        chip = _run(["sysctl", "-n", "machdep.cpu.brand_string"]).lower()
+        total = float(mem) / 2**30 if mem else 16.0
+        bw = next((b for frag, b in sorted(MAC_BW.items(), key=lambda x: -len(x[0])) if frag in chip), 100)
+        hw = dict(vram=round(total * 0.8), vram_bw=bw, ram=8, ram_bw=bw, disk_bw=3.5,
+                  geta=0.26, gl=0.24)
+        notes.append(f"Apple unified memory: {total:.0f} GB [os], {bw} GB/s [table, est eta 0.26 - unvalidated: bench me]")
+        return hw, notes
+
+    # RAM
+    total, mts, sticks = (ram_windows() if os.name == "nt" else (None, None, None))
+    if total is None and os.path.exists("/proc/meminfo"):
+        with open("/proc/meminfo") as f:
+            kb = int(re.search(r"MemTotal:\s*(\d+)", f.read()).group(1))
+        total, mts, sticks = kb / 2**20, None, None
+    if total is None:
+        total = 16.0; notes.append("RAM capacity: 16 GB [default - detection failed]")
+    channels = max(1, min(sticks or 2, 8)) if sticks else 2
+    if mts:
+        ram_bw = round(channels * mts * 8 / 1000)   # theoretical peak, preset convention
+        notes.append(f"RAM: {total:.0f} GB, {sticks} stick(s) @ {mts:.0f} MT/s [os] -> {ram_bw} GB/s peak "
+                     f"(assumes {channels}-channel)")
+    else:
+        ram_bw = 48
+        notes.append(f"RAM: {total:.0f} GB [os]; speed unknown -> 48 GB/s [default: DDR4-3000 dual, pass --ram-bw]")
+
+    # GPU(s)
+    gs = gpus()
+    if gs:
+        vram = sum(g[1] for g in gs)
+        bw0, geta, gl, src = gpu_lookup(gs[0][0])
+        vram_bw = bw0 * len(gs) * (1.0 if len(gs) == 1 else 0.85)   # aggregate w/ tensor-parallel loss
+        names = " + ".join(g[0] for g in gs)
+        notes.append(f"GPU: {names}, {vram:.0f} GB total [os], {vram_bw:.0f} GB/s {src}"
+                     + (f" (x{len(gs)} aggregate, 0.85 TP efficiency [est])" if len(gs) > 1 else ""))
+        hw.update(vram=vram, vram_bw=round(vram_bw), geta=geta, gl=gl)
+    else:
+        hw.update(vram=0, vram_bw=0)
+        notes.append("GPU: none detected (nvidia-smi absent/empty; AMD/Intel: pass --vram/--vram-bw) [os]")
+
+    # disk: class default; a real measured number needs `quantprobe hw --measure` (reads a large file)
+    hw.update(ram=round(total), ram_bw=ram_bw, disk_bw=0.5)
+    notes.append("disk: 0.5 GB/s [default: SATA-class; NVMe ~3.5, Gen4 ~7 - pass --disk-bw or run hw --measure]")
+    return hw, notes
+
+
+def measure_disk(path, mb=512):
+    """Sequential read of a real file region, uncached-ish: the streaming pattern that matters."""
+    import time
+    size = os.path.getsize(path)
+    span = min(mb * 1024 * 1024, size)
+    off = max(0, size - span - (os.urandom(1)[0] % 7) * 1024 * 1024)  # tail region, jittered
+    t0 = time.perf_counter()
+    with open(path, "rb", buffering=0) as f:
+        f.seek(off)
+        left = span
+        while left > 0:
+            chunk = f.read(min(1 << 24, left))
+            if not chunk:
+                break
+            left -= len(chunk)
+    dt = time.perf_counter() - t0
+    return (span - left) / 1e9 / dt
+
+
+def run(a):
+    hw, notes = detect()
+    print("quantprobe hw - this machine, as the law sees it\n")
+    for n in notes:
+        print("  " + n)
+    if getattr(a, "measure", None):
+        p = a.measure
+        if os.path.isfile(p):
+            bw = measure_disk(p)
+            hw["disk_bw"] = round(bw, 2)
+            print(f"  disk MEASURED on {os.path.basename(p)}: {bw:.2f} GB/s sequential [measured]")
+        else:
+            print(f"  --measure: file not found: {p}")
+    flags = (f"--vram {hw['vram']:g} --vram-bw {hw['vram_bw']:g} --ram {hw['ram']:g} "
+             f"--ram-bw {hw['ram_bw']:g} --disk-bw {hw['disk_bw']:g}")
+    print(f"\n  equivalent flags (for sharing / estimating this box elsewhere):\n  {flags}")
+    print("\n  every command now uses these automatically when you pass no hardware flags;")
+    print("  pass --machine or explicit flags to estimate a DIFFERENT machine instead.")
+    return hw

quantprobe/fetch.py

@@ -0,0 +1,88 @@
+"""hf_fetch.py -- robust multi-file HF downloader (manual HTTP Range, retry-on-break), bypassing the
+hf CLI's Xet-backend stalls. Usage: python -m weights.hf_fetch <repo_id> <dest_dir> <file1> [file2 ...]
+Resumes partial .part files; token from HF_TOKEN env or ~/.cache/huggingface/token.
+"""
+from __future__ import annotations
+import os, sys, time
+import requests
+
+
+PRESETS = {
+    "qwen3-30b":   ("unsloth/Qwen3-30B-A3B-GGUF", "Qwen3-30B-A3B-Q2_K.gguf"),
+    "glm-air":     ("unsloth/GLM-4.5-Air-GGUF", "GLM-4.5-Air-UD-IQ2_XXS.gguf"),
+    "deepseek-16b": ("bartowski/DeepSeek-Coder-V2-Lite-Base-GGUF", "DeepSeek-Coder-V2-Lite-Base-IQ2_XS.gguf"),
+    "qwen3-0.6b":  ("unsloth/Qwen3-0.6B-GGUF", "Qwen3-0.6B-Q8_0.gguf"),
+}
+
+
+def token():
+    t = os.environ.get("HF_TOKEN")
+    if t:
+        return t.strip()
+    p = os.path.expanduser("~/.cache/huggingface/token")
+    return open(p).read().strip() if os.path.exists(p) else None
+
+
+def fetch(repo, dest, fname, tok, tries=100):
+    url = f"https://huggingface.co/{repo}/resolve/main/{fname}"
+    out = os.path.join(dest, fname)
+    part = out + ".part"
+    if os.path.exists(out):
+        print(f"  {fname}: already complete", flush=True)
+        return True
+    hdr0 = {"Authorization": f"Bearer {tok}"} if tok else {}
+    r = requests.head(url, headers=hdr0, allow_redirects=True, timeout=60)
+    total = int(r.headers.get("Content-Length", 0))
+    print(f"  {fname}: {total/1e9:.2f} GB", flush=True)
+    t = 0
+    while t < tries:
+        have = os.path.getsize(part) if os.path.exists(part) else 0
+        if total and have >= total:
+            break
+        try:
+            h = dict(hdr0)
+            if have:
+                h["Range"] = f"bytes={have}-"
+            r = requests.get(url, headers=h, stream=True, timeout=(30, 120), allow_redirects=True)
+            if r.status_code not in (200, 206):
+                print(f"    status {r.status_code}, retry", flush=True); time.sleep(5); t += 1; continue
+            mode = "ab" if (have and r.status_code == 206) else "wb"
+            t0 = last = time.time(); base = have if mode == "ab" else 0
+            with open(part, mode) as f:
+                for chunk in r.iter_content(1 << 22):
+                    if chunk:
+                        f.write(chunk)
+                    if time.time() - last > 20:
+                        sz = os.path.getsize(part)
+                        print(f"    {sz/1e9:.2f}/{total/1e9:.2f} GB ({(sz-base)/1e6/max(1e-6,time.time()-t0):.1f} MB/s)", flush=True)
+                        last = time.time()
+        except (requests.exceptions.ChunkedEncodingError, requests.exceptions.ConnectionError,
+                requests.exceptions.ReadTimeout, requests.exceptions.Timeout) as e:
+            print(f"    break at {os.path.getsize(part) if os.path.exists(part) else 0:,}, retry {t+1}: {str(e)[:60]}", flush=True)
+            time.sleep(3); t += 1
+    if total and os.path.exists(part) and os.path.getsize(part) == total:
+        os.replace(part, out)
+        print(f"  {fname}: DONE", flush=True)
+        return True
+    print(f"  {fname}: INCOMPLETE", flush=True)
+    return False
+
+
+def run(a):
+    import sys as _s
+    repo, files = a.repo, a.files
+    if repo in PRESETS and not files:
+        repo, f = PRESETS[repo]
+        files = [f]
+        print(f"[quantprobe] preset '{a.repo}' -> {repo}/{f}")
+    if not files:
+        _s.exit("no files given (or use a preset: " + ", ".join(PRESETS) + ")")
+    ok = all(fetch(repo, a.dest, fn, token()) for fn in files)
+    _s.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    repo, dest = sys.argv[1], sys.argv[2]
+    os.makedirs(dest, exist_ok=True)
+    ok = all(fetch(repo, dest, f, token()) for f in sys.argv[3:])
+    sys.exit(0 if ok else 1)