MERNIK-Fracture — KLD-only quantization damage labels

Fracture = the points where reasoning breaks under quantization. Per-token damage labels for LLM quantization, measured as KL-divergence against the unquantized reference on a reasoning corpus. Each row = one tensor group dropped one tier (Q5_K → Q4_K); damage_* = perturbed minus baseline.

What it is, concretely. Take a trained model. For each tensor (or tied group), make a copy with that one tensor quantized one tier lower, run the reasoning corpus through both, and measure how much the output distribution drifts. That drift — per token, per layer — is a row. The allocator (Gnom) learns from these rows which tensors are load-bearing, so it can spend bits where they matter and save them where they don't. Without measured damage, importance is a guess (imatrix, Fisher); with it, the ranking is learned from the thing you actually care about: does the model still reason the same after you compress it?

These are the labels the Gnom allocator is trained on. They replace the earlier PPL-based labels, which are retired (see "How we got here").

---

How we got here (and why the old labels are retired)

MERNIK-gnom-labels was our first attempt — PPL-damage on wikitext, useful as a prototype that proved the pipeline end-to-end, but it taught us its own limits (the Perplexity Illusion, below). It was more of a test than a product: a mixed PPL/KLD schema that even trips the HuggingFace viewer. Once we switched paradigm to KLD on reasoning tasks, it was retired.

These three files are the real thing — and the origin of the project:

• complete and clean — one uniform schema, every row measured, no null-kld rows, no mixing;
• not a heterogeneous mix like gnom-labels, not a half-finished leg like the old rlmini;
• the first labels produced under the KLD-only, reasoning-corpus paradigm.

---

Why PPL was abandoned (it is useless here)

The Perplexity Illusion. PPL measured on a general corpus saturates: a reasoning-critical layer and a filler layer show the same wiki PPL damage, because PPL is dominated by high-frequency tokens and is blind to the few tokens that carry reasoning.

Measured, not assumed:

• PPL damage at a small drop (Q5_K → Q4_K) has label std 0.77, against a measurement floor of ~1.0 — the signal is below the noise.
• KLD against the unquantized reference is fidelity-sensitive: KLD learnability = 0.609 vs PPL's 0.23 ceiling, and KLD is ~orthogonal to PPL (rank-corr ≈ 0.02).

PPL is a wiki-proxy. KLD on reasoning tasks measures what actually breaks when you quantize.

---

The five metrics (all damage_* = perturbed − baseline)

column	meaning	what it catches
damage_kld	mean token-KLD vs reference	the allocator's main column — average fidelity cost
damage_kld_max	worst-token KLD	tail detonations (up to 20.85 measured). The reasoning-breaker: the model generates 95% of a chain-of-thought fine, then on one critical token the distribution collapses — one token and the answer is garbage. Mean KLD cannot see it; max KLD can
damage_kld_median	median token-KLD	robust core damage. mean >> median = rare catastrophic failures; mean ≈ median = uniform, predictable damage
damage_dp_rms	RMS of top-1 probability shift	decisiveness damage, both directions: lost confidence and artificial sharpening
damage_same_top	fraction of positions keeping the argmax	rank before values. same_top = 0.80 means the model rewrites its decisions on every fifth token even when KLD looks fine; one flipped token in if (x > y) breaks the program

ppl and damage are null — not measured, never 0. The sweep is KLD-only: the plain-PPL pass is skipped because it lies (see above) and doubles wall time.

---

What it costs to produce (the honest price)

These labels are not cheap — that is part of why they are valuable. Every number below is a full forward pass over the whole corpus against a saved reference — no sampling, no shortcuts, run 24/7 until the file is complete.

• 9B (Ornith-1.5-9B) — on the forge, not the GTX 1070. A 9B model is unreasonable to torture through a consumer 1070 (8 GB, would stream from disk for days), so this file was built on the 16 GB Vega-11 forge, which is memory-bandwidth-bound and holds the model + 27 GB reference in RAM. 210 labels (209 units + baseline) × 90 min each = ≈315 hours ≈ 13 days of continuous sweeping, plus the 27 GB reference-logit pass. This is the crown-jewel file — the most expensive per row in the project.
• 1.7B (Spark-1.7B) — on the GTX 1070. Small enough for the GPU. 112 units × 4 min = ≈7.5 h.
• 4B (Spark-4B) — on the GTX 1070. 144 units × 5 min = ≈12 h.

The split is deliberate: big models go to the forge (bandwidth), small ones to the GPU (speed). Neither is free — the 9B file alone is a fortnight of unattended compute.

---

Measurement protocol

• Deterministic. Forward passes only, no sampling → bit-to-bit reproducible. There is no sampling noise; a re-run of the same file gives the same numbers.
• Corpus: rl_reasoning_mini — 343 prompts, 5 RL-oss subsets, EN+ZH (reasoning tasks, not wiki).
• Drop: base tier Q5_K → drop tier Q4_K (one tier). tensors lists the group.
• Baseline row ("unit": "BASELINE") holds the unperturbed reference values; every damage_* is relative to it.

---

Naming

• unit — compact tag, e.g. ffn_down@11 = block 11's ffn_down; attn_gate@0+attn_qkv@0 = a tied group.
• tensors — full tensor names (blk.N.tissue.weight), sorted.
• Rows are ordered by block, then tissue. tier is implicit (Q4_K); the base is Q5_K.

---

Weight-stat features (feed Gnom, not labels)

Gnom also consumes per-tensor weight statistics, computed in bounded-RAM streaming passes (never materializing large tensors):

• log10(std) — weight dispersion
• clip(kurtosis, -2, 50)/10 — tail heaviness of the weight distribution
• log10(max|w| / mean|w|) — outlierness
• fraction(|w| > 6σ) — outlier fraction

These are features (model inputs), distinct from the labels above (measurement targets). Higher moments of the weight distribution help predict which tensors detonate, not just how much.

---

The curve — deep tiers included

The Q3_K legs are done for the small models, so each of them now has a two-point reasoning-damage curve (Q4 and Q3) instead of a single point:

model	legs	units	where
Spark-X2.5-1.7B	Q4, Q3	112 + 112	GTX 1070
Spark-X2.5-4B	Q4, Q3	144 + 144	GTX 1070
Ornith-1.5-9B	Q4	209 (filling)	Vega-11 forge

The 9B deep legs (Q3/Q2) are still queued — a 9B drop pass is the most expensive run in the project (~90 min/unit ≈ 13 days continuous per tier), so they sit behind the current Q4 leg, which is training now. The 9B-Q4 file alone is a fortnight of unattended compute.

Files

All five legs share the same clean schema (5 KLD columns + damage deltas, ppl/damage = null, no censored holes, no mixing). They differ only in model, tier and where they were computed.

file	model	tier	rows	computed on
damage_17b_rlmini_kldonly.jsonl	Spark-X2.5-1.7B	Q4	113 (BASELINE + 112)	GTX 1070
damage_17b_rlmini_q3.jsonl	Spark-X2.5-1.7B	Q3	113 (BASELINE + 112)	GTX 1070
damage_4b_rlmini_kldonly.jsonl	Spark-X2.5-4B	Q4	145 (BASELINE + 144)	GTX 1070
damage_4b_rlmini_q3.jsonl	Spark-X2.5-4B	Q3	145 (BASELINE + 144)	GTX 1070
damage_ornith_rlmini.jsonl	Ornith-1.5-9B	Q4	filling (96 at snapshot)	Vega-11 forge

The 9B file is still filling row by row; the format is already complete and clean.

---

What these labels bought

Transfer, on clean data (strict leave-one-MODEL-out)

The old "no transfer" verdict was an artifact of contaminated labels. On the clean rlmini pool (512 units, 768 tensors, 0 censored) a ranker trained on other models' legs predicts damage on a model it has never seen:

variant	rl17 held out	rl4b held out	mean	bar 0.45
trunk	0.805	0.798	0.801 PASS (×6 MDE)
modelbias	0.672	0.705	0.689 PASS
moeshared	0.334	0.025	0.179 FAIL
imatrix proxy (timp)	−0.101	−0.106	−0.103

The proxy baseline is negative — the learned ranker beats the static imatrix signal by a mile, on models it never saw. (Mixed 4-fold exam: moeshared LOMO 0.579, rank LOMO-acc 0.760.)

The physics behind it, in the literature

Four independent papers published in the same window describe the same mechanism, and HuggingFace links them from this card automatically:

• arXiv:2608.08188 — Quantization Degradation in LLMs: A Signal-Noise Perspective (CASIA, Aug 2026): degradation = how errors arise + how they accumulate across layers; the propagated error dominates at every depth; "control the errors that drive downstream degradation, rather than to minimize all errors uniformly".
• arXiv:2504.09629 (Apr 2025): the activation difference grows exponentially with depth — the mathematical snowball.
• arXiv:2505.15909 (MIT, May 2025): selective precision — the first layers at 8-bit help most for smaller Llama models, but middle for 405B and last for Phi-3/Dolly: which block pays is architecture-specific.
• arXiv:2411.07191 (Jul 2025): the "super weights" whose damage destroys a model sit in mlp.down_proj of the early layers, consistently across Llama, Mistral and OLMo.

MERNIK's contribution is the instrument: per-tensor damage labels on a reasoning corpus, and a ranker that carries the rule to models it has never seen.

The damage profile these labels reveal — and it holds across architectures

model	family	damage in layers 0–5	in layers ≥24	how obtained
Spark-1.7B	hybrid SWA, 36 layers	43.2%	3.2%	measured (these labels)
Spark-4B	hybrid SWA, 36 layers	36.4%	7.4%	measured (these labels)
Ornith-1.5-9B	hybrid + SSM, 33 layers	57.2%	8.9%	measured by the teacher, blind to the ranker — the ranker had predicted 48.3% / 6.4% before the data existed

The 9B is a different family again (hybrid + SSM, 33 layers, different tokenizer) and was never in the training pool when the prediction was made: the ranker transferred across architecture, right in direction and close in magnitude. On the 9B the hot band is 7.4× the middle of the stack (blocks 0–2: +0.00217 vs blocks 10–30: +0.00029), and the fingerprint is stable — hottest blocks are 0, 1, 2, 3 and 11, and the ranker's own pick on the 4B was blk.0 + blk.11.

Where this came from. The effect was visible in my own first hand-made quant (gemma-4-12B-it-SHQ6, June 2026) long before it was measurable: its card already said layers 0-1 were 3228× more important than the middle of the stack, with the first layer's attention projection dominating the importance distribution. Six months and four architecturally unrelated models later, the same fingerprint shows up in measured damage.

The labels transfer across model versions too

Spark-X2.6-4B shipped hours after its weights leaked — same spark2_5 architecture as X2.5, post-training only. The imatrix carries over almost unchanged (Spearman 0.9964, top-50 overlap 100%), so a ranker trained on X2.5 labels ranks X2.6 tensors without re-measuring anything. Same mechanism as the model-level transfer above: measured importance is a property of the architecture, not of one checkpoint.

What the labels bought, on a model released that same day

Spark-X2.6-4B is the first test of the clean pool end to end. Same model, same corpus, same byte budget (2250 MiB), one variable — which tensors got the extra bits:

allocation	who chose	PPL (wiki)	max KLD vs BF16	mean Δp
stock Q4_K_M (2479.8 MiB)	llama.cpp heuristic	20.6148	17.65	−1.015%
SMSE	the imatrix (layer 27)	19.2660	17.77	−0.733%
LAWONLY	the depth law, by hand (layer 7)	18.6080	18.71	−0.445%
Gnom	the ranker trained on these labels (layer 0)	18.3646	14.17	−0.306%

The learned ranker beats both the static lens and a hand-picked reading of its own law, on every column — and by a wide margin on the tail (max KLD 14.17 vs 18.71, −24%). The monotone prior cannot see the layer-0 spike; the ranker can. That gap is the whole point of measuring damage instead of guessing importance.

(What the allocator then does with that ranking — and the verdict column — is a different story; see the MERNIK repo.)

---

Usage with Gnom

Drop terminated (censored) records — they are observable holes, never imputed. Train per the Gnom README; the allocator reads damage_kld as the primary target and the other four as auxiliary heads.

Loading the data

import json
rows = [json.loads(l) for l in open("damage_17b_rlmini_kldonly.jsonl")]
units = [r for r in rows if r["unit"] != "BASELINE"]          # drop the baseline row
X_cols = ["damage_kld", "damage_kld_max", "damage_kld_median",
          "damage_dp_rms", "damage_same_top"]                    # the 5 targets

Reproducing

Labels are produced by scripts/group_damage_sweep.py (MERNIK): quantize a copy of the model with one unit pinned a tier lower, run rl_reasoning_mini, and score KLD against the unquantized reference (--save-all-logits). Deterministic — re-running reproduces the numbers.

---

If this work saved you a GPU-week: github.com/sponsors/wepiqx