🔬 quant-vs-api-parity-harness

Is your local quant actually as good as the full-precision API? This toolkit answered that question for a 284B MoE compressed to 2.9 bpw — verdict: indistinguishable on the real serving path (90.8% token-identical, 240/240 paired-QA parity, deep-derivation parity). 🎯 But the real product is the method: it caught 9 bugs in our own instruments before they could lie to us — including one that had us convinced the quant had lost factual recall when it hadn't. 🪤

Used to produce the results in DeepSeek-V4-Flash-0731-StrixHalo-Verified-GGUF. Model-agnostic in spirit: bring any llama.cpp server + any OpenAI-compatible reference API.

🚀 Install

python3 -m venv venv && . venv/bin/activate
pip install sympy jinja2                 # that's all — stdlib otherwise
echo "sk-..." > deepseek_api_key.txt     # your reference-API key (chmod 600!)
# a llama.cpp server on 127.0.0.1:8080 serving the quant you want to test

🧭 The method, in the order that matters

1️⃣ Validate your instruments FIRST (scorers.py) — non-negotiable

python3 scorers.py   # 67 synthetic cases — must print 67/67 before ANY model run

Answer extractors, SymPy equivalence oracle (with convention lists + decimal tolerance), degeneration detector, tool-call deep-equal. Each shipped with synthetic test cases: correct answers in hostile formats (LaTeX \pm, \boxed{}, thousand separators, mid-line), plausible wrongs, truncations, repetition loops. This step caught 2 real bugs in our own scorers on day one. If you skip it, your benchmark will eventually lie to you. 🐛

2️⃣ Run the gates (G2-G6) — they decide what your data can mean

gate	question it answers	what we found
G2 reference/g2g3_drafter_reference.sh	is speculative decoding bit-exact on YOUR stack?	❌ 0/10 — bench paired arms drafter-OFF
G3 (same script)	is your server deterministic?	✅ 10/10
G4 g4g5g6_api.py	what's the API's self-disagreement at temp 0?	short tasks 7/7 identical; long derivations 6/7 different → vote 3 runs
G5 (same)	can you even prove template parity?	often no (no published template) → treat as documented confound, drop boundary tokens
G6 (same)	real API context ceiling?	⚠️ disable thinking for the probe or your reply budget dies in the reasoning channel

3️⃣ Measure, cheapest-strongest first

🧬 P1 — token-level teacher forcing (p1_*.py) — the best instrument here. Generate greedy reference texts via the API (with top_logprobs), then force that exact token sequence through your local model one token at a time (cache_prompt=true, n_probs=20 → linear cost). Record top-1 agreement, the reference token's local rank, NLL. No judge, no regex — the oracle is the distribution itself. Bootstrap over TEXTS, never tokens (autocorrelation). Compare token ids, not strings.

📐 T2 — multi-step derivations, SymPy oracle (t2_*.py) — the compounding-error regime. Parametric bank (truths computed, never typed — our own self-test caught a hand-typed constant that was wrong 🙃), fixed FINAL: <expr> line, equivalence by simplify(candidate − truth) == 0. Truncated ≠ wrong. McNemar on paired outcomes. Log reasoning-trace lengths both sides and report them first.

🎯 T1/T1b — paired exact-answer bank + calibration (t1_items.py, t1b_passe.py). 240 generated integer-answer items, two conditions (forced / UNSURE-allowed), answer-token logprob both sides → AUROC(confidence → correctness) and the metric that actually matters for routing: P(answers ∧ wrong).

⏱️ Speed (reference/nmax_depth_bench_reference.sh): warm-up excluded, medians of ≥3, report t/s AND ms/eval (under speculation, t/s is not machine speed), nested prompts + prompt cache to pay prefill once. Our headline finding: the speculative n_max optimum inverts with context depth (3 at short ctx → 2 from ~16k).

🥇 The cardinal rule (it cost us our biggest false finding)

Evaluate QUALITY only through the real serving path — /v1/chat/completions. Raw /completion with an auto-injected <think> can close the reasoning instantly at temp 0 (10-character traces!) and answer reflexively. We published an entire "the quant lost factual recall" conclusion, then replayed the failed items through the chat endpoint: 4/4 correct. The deficit was our benchmark's serving path, not the quant. Full story and eight more traps in NEGATIVE_RESULTS.md — read it before you optimize anything. 🪤

📁 Files

file	role
scorers.py	extractors + oracles + 67 self-tests (run first, always)
g4g5g6_api.py	API noise floor · template probe · context ceiling
p1_gen_api.py / p1_force_local.py / p1_depouille.py	teacher forcing pipeline (resumable) + text-level bootstrap
t2_items.py / t2_passe.py	derivation bank (self-tested truths) + paired passes + McNemar
t1_items.py / t1b_passe.py	240-item bank + two-condition calibration passes
reference/*.sh	speed & drafter gates — reference implementations, adapt to your service manager
NEGATIVE_RESULTS.md	🧨 what did NOT work, with numbers — the most useful file here

MIT. Benchmarked on AMD Strix Halo (gfx1151, ROCm 7.1, 115 GB unified) against the official DeepSeek API — but the method owes nothing to that hardware. Validate your instruments, equalize your serving paths, and let the distributions be the judge. 🔍