---
license: mit
language:
- en
- fr
tags:
- benchmark
- llama.cpp
- gguf
- quantization
- evaluation
- speculative-decoding
---

# 🔬 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](https://huggingface.co/Kevletesteur/DeepSeek-V4-Flash-0731-StrixHalo-Verified-GGUF).
Model-agnostic in spirit: bring any llama.cpp server + any OpenAI-compatible reference API.

## 🚀 Install

```bash
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

```bash
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`](./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.* 🔍