Datasets:
Upload README.md with huggingface_hub
Browse files
README.md
CHANGED
|
@@ -108,7 +108,7 @@ Results are **split by reasoning mode**: comparing a thinking-on (reasoning) mod
|
|
| 108 |
|
| 109 |
¹⁵ Qwopus3.8-27B-Flash (Jackrong's fine-tune of Qwen3.8-27B, Q6_K with embedded MTP head, 22.4GB), measured 2026-09-07 on llama.cpp b10371 against the banked Q6_K base, same harness, same day. Four of five tasks sit within the base's error band; the q_avg is HumanEval alone: **26.8 vs 94.5**, because the tune emits exactly one leading space on every code line in 150 of 164 answers, so nesting depth is destroyed in the output and no whitespace repair recovers it (48/164 at best). The model card discloses the indentation issue; this is its size. Think-on GPQA-diamond (16k budget, paired with a same-day base re-run that reproduced the 2026-08-19 result to the item): **70.7 vs 79.3**, with the tune spending 4,229 completion tokens per correct answer against 7,740 (2.08x on the 125 items both solve), so the card's efficiency claim is real at about 2x and costs 8.6 points. The card's MTP acceptance advantage does not reproduce think-off (weighted 0.762 vs 0.768, 109 to 145 tok/s for both). [Report](reports/qwopus3-8-27b-flash.md).
|
| 110 |
|
| 111 |
-
¹⁶ Qwen3.8-Flash-Next (125B total / 10B active MoE, 512 experts, qwen4exp hybrid linear attention), unsloth UD-Q2_K_XL 78.9GB, does not fit the card: run with the routed experts of the first
|
| 112 |
|
| 113 |
### Thinking ON (reasoning · extended chain-of-thought)
|
| 114 |
|
|
@@ -145,7 +145,7 @@ Full per-model reports with MMLU category breakdowns, parse reliability stats, a
|
|
| 145 |
|
| 146 |
#### Error bars
|
| 147 |
|
| 148 |
-
Every score above is a single greedy pass, so each is a binomial proportion with a sampling interval. [`board_ci.csv`](board_ci.csv) publishes a Wilson 95% interval per task per row (from the `correct`/`total` counts in each run's detail files) together with the parse-failure count, and a `q_avg` row whose half-width propagates the five task variances through the mean, treating tasks as independent. Measured across the 47 rows with all five tasks (regenerated 2026-09-
|
| 149 |
|
| 150 |
---
|
| 151 |
|
|
@@ -161,6 +161,32 @@ Every score above is a single greedy pass, so each is a binomial proportion with
|
|
| 161 |
|
| 162 |
The llama-bench numbers above measure the engine on its own. The served lane (`scripts/speed_served.py`, `lib/speed_served.py`) measures what a client sees through llama-server's streaming chat-completions endpoint, the path the spec-decode and prompt-cache reports were timed on. Four fixed workloads (prose, code, repetitive, chat; 8 prompts each, `lib/workloads.py`, the same prompt set those reports used) are sent at temperature 0 with `max_tokens=256` after one discarded warm-up request; every request is appended as one json line with the server flag set (`mode`), `cache_prompt`, the wall time to the first content chunk, the total wall time, prompt and completion token counts, the server's own `timings` object when present, and a sha256 of the text so two flag sets can be checked for byte-identical output. Vocabulary: **TTFT** is the time to the first content token as the reader perceives it (prefill plus queueing); **perceived TPS** is `completion_tokens / (total_s - ttft_s)`, the rate text arrives at once it starts; **total TPS** is `completion_tokens / total_s`, throughput including the wait. Percentiles (p50 and p90 over the 32 requests per pass), not means, are reported, alongside the server's `predicted_per_second` p50 and, when speculation is on, the acceptance rate `sum(draft_n_accepted) / sum(draft_n)`. A served TPS is not comparable to a tg128 figure from llama-bench: different prompt, different token budget, and the HTTP and tokeniser overhead are inside the served number.
|
| 163 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 164 |
### Speed data schema
|
| 165 |
|
| 166 |
| Column | Description |
|
|
@@ -194,6 +220,7 @@ One-shot investigations that don't fit the leaderboard format — claim verifica
|
|
| 194 |
|
| 195 |
| Report | Finding |
|
| 196 |
|---|---|
|
|
|
|
| 197 |
| [Speculative decoding and prefix caching on one RTX 5090: what the two free speedups buy](reports/spec-cache-study.md) · [chart](reports/spec-cache-study.png) | The two single-GPU optimisations every inference text names first, measured on the model and flag set this box serves daily (Qwen3.6-27B Q6_K with its embedded MTP drafter, llama.cpp b9653, batch 1, 304 requests, one variable at a time). MTP draft n=2 lifts decode from 61 to 112-144 tok/s (1.8x prose, 1.9x chat, 2.3x code and repetitive) for +10 ms TTFT; n=4 reaches 169-183 on code/repetitive and loses to n=2 on prose/chat, because draft depth only pays above ~0.85 acceptance; n-gram lookup is 1.00x on 256-token answers. Prefix caching cuts TTFT on a re-used 2,954-token system prompt from 1.005 s to 0.067 s (15x) and on 11,570 tokens from 3.835 s to 0.084 s (46x), decode untouched; stacked, a short answer to the long context goes 4.18 s to 0.24 s. Losslessness: MTP output is byte-identical to plain greedy decode on 56% of answers; all 14 divergences examined with top-2 logprobs are flips to the target's own second choice at a near-tie (gap under 0.09 nats), so same quality class, not byte-identical. Limits: one model, one quant, batch 1, 256-token answers. |
|
| 198 |
| [The benchmark said below-chance. The model was fine: a truncation autopsy](reports/gpqa-truncation-artifact.md) · [chart](reports/chart_gpqa_truncation.png) | A community benchmark harness (SM12X-LLM-BENCH, full profile, 18h, rc=0, zero infra errors) reported Qwen3.6-27B Q6_K at 21.7% on GPQA-diamond — below the 25% random-guessing floor for 4-choice questions. The model was fine: the harness serves thinking models at their default (thinking on) with an 8,192-token completion cap, and on GPQA the model's reasoning chain was still running when the cap hit (ttft p50 184s), so 153/198 items (77%) ended `finish_reason=length` with no extractable answer, each scored as wrong. Anchor leg on the same GGUF file, same resident llama-server, same RTX 5090, thinking off so answers fit the budget: 54.5% (108/198, 0 parse failures) — 2.5x the score from one setting. Reads: below-chance accuracy on a competent model is a pipeline bug until proven otherwise; the truncation count was in the harness's own report all along, but the lane still presented as PASS/publishable, so score fields get read and diagnostic fields get skipped (guard proposed upstream as SM12X-LLM-BENCH#3, with #1 long-context detection and #2 cache-inflated prefill from the same run); thinking-mode benchmarks need deliberation-sized budgets, not answer-sized ones. Honest limits: anchor is think-off (lower bound proving artifact, not the model's think-on ceiling); one model, one quant, one lane; the harness's client plumbing was impeccable — the finding is about score presentation. |
|
| 199 |
| [Kitty's 2-bit KV cache holds long-context retrieval, the axis its paper never measured](reports/kitty-needle.md) · [chart](reports/chart_kitty_needle.png) | Kitty (arXiv 2511.18643) reports near-zero loss at 2-bit KV cache, but measures it only on short-input reasoning tasks (GSM8K, MATH, HumanEval, GPQA, MMLU, AIME), never on long-input retrieval, the axis KV compression exists for. Needle-in-a-haystack, Qwen3-8B, one RTX 5090, f16 KV vs Kitty-Pro 2-bit KV on identical prompts. Calibrate f16 first: it retrieves a single needle at 100% across 8k/16k/32k, every depth. 64k does not fit (a one-shot 64k prefill plus f16 KV OOMs the 32GB card, and Kitty's reference path stores the cache dequantized so it cannot rescue the memory), so the ladder caps at 32k, still 16x Kitty's longest tested input. Single needle: 2-bit ties f16 at 100% in all fifteen cells, including the needle at the very start of a 32k context, but a perfect tie is weak evidence (it cannot tell lossless from too-easy). Harder probe: 8 needles at 8 depths, keyed retrieval, 160 recoveries per leg. Now the task discriminates, f16 itself slips to 97.5% at 32k and 90% at the shallowest depth. Through that, 2-bit KV tracks f16 within noise: 99.4 vs 98.8 overall, about one needle, no depth band degrading. Kitty's near-zero loss extends to long-context multi-fact retrieval up to 32k. Honest limits: 64k is a hardware wall not a pass; f16 is still near ceiling at 98.8%, so a harsher task might separate them; this is the reference fake-quant simulator, quality not a deployed kernel's speed or memory; one model, one retrieval task. |
|
|
|
|
| 108 |
|
| 109 |
¹⁵ Qwopus3.8-27B-Flash (Jackrong's fine-tune of Qwen3.8-27B, Q6_K with embedded MTP head, 22.4GB), measured 2026-09-07 on llama.cpp b10371 against the banked Q6_K base, same harness, same day. Four of five tasks sit within the base's error band; the q_avg is HumanEval alone: **26.8 vs 94.5**, because the tune emits exactly one leading space on every code line in 150 of 164 answers, so nesting depth is destroyed in the output and no whitespace repair recovers it (48/164 at best). The model card discloses the indentation issue; this is its size. Think-on GPQA-diamond (16k budget, paired with a same-day base re-run that reproduced the 2026-08-19 result to the item): **70.7 vs 79.3**, with the tune spending 4,229 completion tokens per correct answer against 7,740 (2.08x on the 125 items both solve), so the card's efficiency claim is real at about 2x and costs 8.6 points. The card's MTP acceptance advantage does not reproduce think-off (weighted 0.762 vs 0.768, 109 to 145 tok/s for both). [Report](reports/qwopus3-8-27b-flash.md).
|
| 110 |
|
| 111 |
+
¹⁶ Qwen3.8-Flash-Next (125B total / 10B active MoE, 512 experts, qwen4exp hybrid linear attention), unsloth UD-Q2_K_XL 78.9GB, does not fit the card: run with the routed experts of the first N layers in system RAM (`--n-cpu-moe N`, 59 GB RAM), llama.cpp b10853 (fresh master worktree; the arch merged 2026-08-27), measured 2026-09-08/09. Quality legs at N=28 (23.0 GiB): highest MMLU on the board (88.5) and GPQA-diamond 54.0 think-off from a 2-bit cut; GSM8K and HumanEval pay the quant tax. Speed at the ladder optimum N=22 (28.5 GiB): decode **59.7 tok/s** tg128, 51.0 at 32k depth, prefill 900 tok/s pp512. The full `--n-cpu-moe` ladder (44 to 18, nine points) climbs 1 to 2.5 tok/s per 1.8 GiB of experts moved onto the GPU, peaks at N=22, inverts at N=20 (30.3 GiB, 50.2 tok/s) and fails to load at N=18: the optimum leaves ~3.5 GiB free, as on the Ling-3 sweep. Per-card points: 16 GB at N=40 (42 tok/s), 24 GB at N=28 (52.5). On this 59 GB box N=28 sits on the page-cache edge (736k major faults during one depth pass, prefill at depth varying 2.7x between identical runs); N=22 does not. MTP head on the open llama.cpp PR #28243 (at N=28): 1.25x on code and repetitive text, a small loss on prose and chat, because under offload a rejected draft costs most of a plain token. Speed rows are offload-conditioned and not comparable to the resident rows. [Report](reports/qwen3-8-flash-next-ud-q2-k-xl.md).
|
| 112 |
|
| 113 |
### Thinking ON (reasoning · extended chain-of-thought)
|
| 114 |
|
|
|
|
| 145 |
|
| 146 |
#### Error bars
|
| 147 |
|
| 148 |
+
Every score above is a single greedy pass, so each is a binomial proportion with a sampling interval. [`board_ci.csv`](board_ci.csv) publishes a Wilson 95% interval per task per row (from the `correct`/`total` counts in each run's detail files) together with the parse-failure count, and a `q_avg` row whose half-width propagates the five task variances through the mean, treating tasks as independent. Measured across the 47 rows with all five tasks (regenerated 2026-09-10), the median q_avg half-width is 0.97 points (the four think-on rows scored on small subsets run 2 to 4 points), and humaneval dominates it in 44 of 47 rows with a median 82% share of the variance, because 164 problems at ~93% pass gives a task half-width of about 4.5 points against under 1 point for the other four. Since 2026-09-10 the file also carries one `gpqa_thinkon` row per think-on GPQA leg (seven rows) with three extra columns, `tokens_per_correct`, `completion_tokens_median`, `capped_rate`, filled where the leg recorded per-item tokens (legs run since 2026-09-09; the August legs did not record them). The per-budget legs of the [reasoning-budget curve](reports/reasoning-budget-curve.md) live under `results/<slug>-thinkon/budget-<N>/` and are tabulated in that report rather than in this file. Two rows whose q_avg differ by less than that half-width are a tie; the tables stay sorted by q_avg for continuity, so read neighbouring rows as a band of roughly one point rather than a ranking. Regenerate with `python3 scripts/board_ci.py results/`.
|
| 149 |
|
| 150 |
---
|
| 151 |
|
|
|
|
| 161 |
|
| 162 |
The llama-bench numbers above measure the engine on its own. The served lane (`scripts/speed_served.py`, `lib/speed_served.py`) measures what a client sees through llama-server's streaming chat-completions endpoint, the path the spec-decode and prompt-cache reports were timed on. Four fixed workloads (prose, code, repetitive, chat; 8 prompts each, `lib/workloads.py`, the same prompt set those reports used) are sent at temperature 0 with `max_tokens=256` after one discarded warm-up request; every request is appended as one json line with the server flag set (`mode`), `cache_prompt`, the wall time to the first content chunk, the total wall time, prompt and completion token counts, the server's own `timings` object when present, and a sha256 of the text so two flag sets can be checked for byte-identical output. Vocabulary: **TTFT** is the time to the first content token as the reader perceives it (prefill plus queueing); **perceived TPS** is `completion_tokens / (total_s - ttft_s)`, the rate text arrives at once it starts; **total TPS** is `completion_tokens / total_s`, throughput including the wait. Percentiles (p50 and p90 over the 32 requests per pass), not means, are reported, alongside the server's `predicted_per_second` p50 and, when speculation is on, the acceptance rate `sum(draft_n_accepted) / sum(draft_n)`. A served TPS is not comparable to a tg128 figure from llama-bench: different prompt, different token budget, and the HTTP and tokeniser overhead are inside the served number.
|
| 163 |
|
| 164 |
+
### Speed at depth (agent-shaped)
|
| 165 |
+
|
| 166 |
+
tg128 on an empty context is the number every board quotes and the one an agent loop never sees. Coding harnesses hand the model a 10k to 20k token prompt and then decode against it, so two numbers matter more: how fast the first token arrives on a long prompt, and how much decode speed survives at depth. Both come from the same llama-bench depth sweep (`-p 512 -n 128 -d 0,8192,32768`, `-r 2`) that has been a standing leg on every treatment since 2026-08-14 and was backfilled on the resident rows on 2026-09-08/09. [`speed_at_depth.csv`](speed_at_depth.csv) carries the raw columns; the table is regenerated with `python scripts/depth_table.py table results/`.
|
| 167 |
+
|
| 168 |
+
| Model | Quant | tg128 | tg128 @32k | held | pp512 @8k | TTFT, 16k prompt (est.) |
|
| 169 |
+
|-------|-------|------:|-----------:|-----:|----------:|------------------------:|
|
| 170 |
+
| Nemotron 3.5 Lightning 30B-A3B | Q4_K_M | 377.4 | 353.1 | 94% | 10,950 | ~1.5 s |
|
| 171 |
+
| Ornith 1.5 35B-A3B | Q4_K_M | 303.2 | 263.5 | 87% | 8,336 | ~2.0 s |
|
| 172 |
+
| Qwen3.8-27B | UD-IQ3_XXS | 96.2 | 86.5 | 90% | 3,720 | ~4.4 s |
|
| 173 |
+
| Qwen3.6-27B | Q4_K_M | 77.1 | 71.6 | 93% | 3,640 | ~4.5 s |
|
| 174 |
+
| Gemma 4 31B-it | Q4_0 | 76.4 | 65.4 | 86% | 3,673 | ~4.5 s |
|
| 175 |
+
| Qwen3.8-27B | Q6_K | 63.1 | 58.3 | 92% | 3,119 | ~5.3 s |
|
| 176 |
+
| Qwen3.6-27B | Q6_K | 61.9 | 58.2 | 94% | 3,026 | ~5.4 s |
|
| 177 |
+
| Qwopus3.8-27B-Flash | Q6_K | 63.0 | 58.0 | 92% | 3,025 | ~5.4 s |
|
| 178 |
+
| Qwen3.8-Flash-Next 125B-A10B (`--n-cpu-moe 22`) | UD-Q2_K_XL | 59.7 | 51.0 | 86% | 826 | **29.4 s measured** (derived 19.8 s; the derivation is a floor under offload) |
|
| 179 |
+
|
| 180 |
+
How to read it: **held** is `tg128 @32k / tg128`, the share of decode speed that survives 32k tokens of context. **TTFT for a 16k prompt** is an estimate, `16384 / pp512 @8k`: prefill throughput measured at 8,192 tokens of depth is the closest measured rate for a mid-size prompt, and the true number is a little worse because prefill slows as the prompt grows (compare pp512 @8k with @32k in the csv). When a treatment measured TTFT on the served lane with a real 16k system prompt, that number replaces the estimate and is shown without the tilde. Rows are llama-bench on fully resident models unless a `--n-cpu-moe` flag is shown; the offload row's prefill is RAM-bandwidth bound and its estimate is cache-state dependent (see the [Flash-Next report](reports/qwen3-8-flash-next-ud-q2-k-xl.md)). Rows without a depth sweep on disk are absent, not zero; the backfill continues through the idle queue.
|
| 181 |
+
|
| 182 |
+
### What your card can run
|
| 183 |
+
|
| 184 |
+
[`card_fit.md`](card_fit.md) turns the board into a fit table for 8, 12, 16, 24 and 32 GB cards. Each row's **VRAM @16k** is the peak sampled on the 5090 during the speed sweep (whose largest prompt is 16,384 tokens, so weights + a 16k KV cache + compute buffers), applied as a budget with 768 MiB of headroom: ✅ resident with a 16k context on the board recipe, 🟡 the file fits but the 16k peak does not (shorter context, q8_0 KV cache, or a smaller quant), ⬜ the file is larger than the card, 🟠 measured with experts in system RAM (the MoE offload rows, which need the RAM as well). Quality (q_avg, GPQA-diamond) sits next to each row so the question "what is the best thing a 16 GB card runs" reads off directly. These are 5090 measurements applied to other cards' capacities, not measurements on those cards: peak bytes are the same on any CUDA card at the same context and flags, decode speed is not. Regenerate with `python scripts/card_fit.py results/`.
|
| 185 |
+
|
| 186 |
+
### Recipes: which llama-server line for this model
|
| 187 |
+
|
| 188 |
+
[`reports/recipes/`](reports/recipes/) answers the question the board does not: given this model on this card, which flags. One page per model, one recommended line at the top, and a six-set table behind it (base, `--flash-attn on`, KV `q8_0`, KV `q4_0`, `--parallel 1`, MTP draft head), each set served and measured on the four short workloads and on a 16k-token system prompt cold and warm, with VRAM peak and a 40-item GPQA spot check on the KV-quantised sets. Seven pages in (Qwen3.8-27B Q6_K, Gemma 4 31B Q4_0, Qwen3.6-35B-A3B UD-Q5_K_M, Nemotron 3.5 Lightning Q4_K_M, Ornith 1.5 35B Q4_K_M, Qwopus3.8-27B-Flash Q6_K, Flash-Next UD-Q2_K_XL under offload): flash-attn changes nothing, `--parallel 1` is free, q4 KV costs 13 to 29% of decode at 16k depth on all seven, q8 KV is a memory lever on dense models only, and an MTP head pays 1.5 to 2.3x on a 60 to 76 tok/s base but is 0.6 to 0.8x on a 364 tok/s one.
|
| 189 |
+
|
| 190 |
### Speed data schema
|
| 191 |
|
| 192 |
| Column | Description |
|
|
|
|
| 220 |
|
| 221 |
| Report | Finding |
|
| 222 |
|---|---|
|
| 223 |
+
| [How much thinking is worth paying for: GPQA-diamond think-on at three completion budgets](reports/reasoning-budget-curve.md) · [chart](reports/reasoning-budget-curve.png) | Two think-on models, the same 198 items, only `max_tokens` moved (4,096 / 8,192 / 16,384). Qwen3.8-27B Q6_K 60.1 / 70.2 / 79.3, Ornith 1.5 35B-A3B Q4_K_M 70.2 / 77.3 / 81.8. Every point lost at a smaller budget is a capped item (101 of 101 across the four smaller legs, per-item diff against 16k) and finished items are 94.7 to 96.1% correct at every budget, so the budget removes the hard questions rather than degrading the answers. 43% / 38% of items run past 4k, 34% / 30% past 8k, 22% of both still past 16k. Tokens per correct answer: Qwen 3,972 → 5,636 → 7,740, Ornith 3,248 → 4,732 → 6,996 (Ornith 700 to 900 cheaper at every budget, and 4.6x faster to decode). The 16k legs reproduced the August 16k runs on all 198 items. Limits: two models, one quant each, greedy, curve stops at 16k. |
|
| 224 |
| [Speculative decoding and prefix caching on one RTX 5090: what the two free speedups buy](reports/spec-cache-study.md) · [chart](reports/spec-cache-study.png) | The two single-GPU optimisations every inference text names first, measured on the model and flag set this box serves daily (Qwen3.6-27B Q6_K with its embedded MTP drafter, llama.cpp b9653, batch 1, 304 requests, one variable at a time). MTP draft n=2 lifts decode from 61 to 112-144 tok/s (1.8x prose, 1.9x chat, 2.3x code and repetitive) for +10 ms TTFT; n=4 reaches 169-183 on code/repetitive and loses to n=2 on prose/chat, because draft depth only pays above ~0.85 acceptance; n-gram lookup is 1.00x on 256-token answers. Prefix caching cuts TTFT on a re-used 2,954-token system prompt from 1.005 s to 0.067 s (15x) and on 11,570 tokens from 3.835 s to 0.084 s (46x), decode untouched; stacked, a short answer to the long context goes 4.18 s to 0.24 s. Losslessness: MTP output is byte-identical to plain greedy decode on 56% of answers; all 14 divergences examined with top-2 logprobs are flips to the target's own second choice at a near-tie (gap under 0.09 nats), so same quality class, not byte-identical. Limits: one model, one quant, batch 1, 256-token answers. |
|
| 225 |
| [The benchmark said below-chance. The model was fine: a truncation autopsy](reports/gpqa-truncation-artifact.md) · [chart](reports/chart_gpqa_truncation.png) | A community benchmark harness (SM12X-LLM-BENCH, full profile, 18h, rc=0, zero infra errors) reported Qwen3.6-27B Q6_K at 21.7% on GPQA-diamond — below the 25% random-guessing floor for 4-choice questions. The model was fine: the harness serves thinking models at their default (thinking on) with an 8,192-token completion cap, and on GPQA the model's reasoning chain was still running when the cap hit (ttft p50 184s), so 153/198 items (77%) ended `finish_reason=length` with no extractable answer, each scored as wrong. Anchor leg on the same GGUF file, same resident llama-server, same RTX 5090, thinking off so answers fit the budget: 54.5% (108/198, 0 parse failures) — 2.5x the score from one setting. Reads: below-chance accuracy on a competent model is a pipeline bug until proven otherwise; the truncation count was in the harness's own report all along, but the lane still presented as PASS/publishable, so score fields get read and diagnostic fields get skipped (guard proposed upstream as SM12X-LLM-BENCH#3, with #1 long-context detection and #2 cache-inflated prefill from the same run); thinking-mode benchmarks need deliberation-sized budgets, not answer-sized ones. Honest limits: anchor is think-off (lower bound proving artifact, not the model's think-on ceiling); one model, one quant, one lane; the harness's client plumbing was impeccable — the finding is about score presentation. |
|
| 226 |
| [Kitty's 2-bit KV cache holds long-context retrieval, the axis its paper never measured](reports/kitty-needle.md) · [chart](reports/chart_kitty_needle.png) | Kitty (arXiv 2511.18643) reports near-zero loss at 2-bit KV cache, but measures it only on short-input reasoning tasks (GSM8K, MATH, HumanEval, GPQA, MMLU, AIME), never on long-input retrieval, the axis KV compression exists for. Needle-in-a-haystack, Qwen3-8B, one RTX 5090, f16 KV vs Kitty-Pro 2-bit KV on identical prompts. Calibrate f16 first: it retrieves a single needle at 100% across 8k/16k/32k, every depth. 64k does not fit (a one-shot 64k prefill plus f16 KV OOMs the 32GB card, and Kitty's reference path stores the cache dequantized so it cannot rescue the memory), so the ladder caps at 32k, still 16x Kitty's longest tested input. Single needle: 2-bit ties f16 at 100% in all fifteen cells, including the needle at the very start of a 32k context, but a perfect tie is weak evidence (it cannot tell lossless from too-easy). Harder probe: 8 needles at 8 depths, keyed retrieval, 160 recoveries per leg. Now the task discriminates, f16 itself slips to 97.5% at 32k and 90% at the shallowest depth. Through that, 2-bit KV tracks f16 within noise: 99.4 vs 98.8 overall, about one needle, no depth band degrading. Kitty's near-zero loss extends to long-context multi-fact retrieval up to 32k. Honest limits: 64k is a hardware wall not a pass; f16 is still near ceiling at 98.8%, so a harsher task might separate them; this is the reference fake-quant simulator, quality not a deployed kernel's speed or memory; one model, one retrieval task. |
|