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.
• 8B MoE (Ling-3.0-tiny) — on the GTX 1070. Experts stream from disk (--n-cpu-moe 16), so ~2.5 min per unit ≈ 17 h for 399 units — cheaper per row than the 9B and faster per unit than the 4B, despite being the biggest model run locally.

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 packed per-tensor tables used by the ranker are uploaded under features/ (spark17.npz, spark4b.npz, ornith_full_2026-10-29.npz, ling_full_2026-10-29.npz, lfm3_full_2026-10-30.npz): each .npz holds X (tensors × 18 raw columns), names, and the model's imatrix scalars (timp_mean/timp_std, logN_med). The training pool specs that bind labels + features live in wepiqx/MERNIK-gnom.

---

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
LFM3-1.7B (3rd arch: hybrid conv+attn)	Q4, Q3	110 + 110	lab, 2026-10-30
Ornith-1.5-9B	Q4	209 (complete)	Vega-11 forge
Ling-3.0-tiny	Q4	399 (complete)	GTX 1070

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 Q4 leg, which is now complete (2026-10-29). The finished Q4 file alone is a fortnight of unattended compute.

Files

All primary 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	210 (BASELINE + 209) — complete 2026-10-29	Vega-11 forge
damage_ling_moe_q4.jsonl	Ling-3.0-tiny	Q4	400 (BASELINE + 399)	GTX 1070
damage_lfm3_rlmini.jsonl	LFM3-1.7B	Q4	111 (BASELINE + 110)	lab, 2026-10-30
damage_lfm3_q3_rlmini.jsonl	LFM3-1.7B	Q3	111 (BASELINE + 110)	lab, 2026-10-30
ornith_q4_rankonly_2026-10-30.jsonl	Ornith-1.5-9B	Q4 (pins removed)	153 (152 units)	Vega-11 forge
ling_moe_q4_rankonly_2026-10-29.jsonl	Ling-3.0-tiny	Q4 (pins removed)	310 (309 units)	GTX 1070
damage_lfm3_q4_rankonly_2026-10-30.jsonl	LFM3-1.7B	Q4 (pins removed)	97 (96 units)	lab, 2026-10-30
damage_lfm3_q3_rankonly_2026-10-30.jsonl	LFM3-1.7B	Q3 (pins removed)	97 (96 units)	lab, 2026-10-30

The 9B Q4 leg is complete (2026-10-29): 210 rows, every unit measured, zero nulls and zero censored records. One-token footprint: min −0.001347 / mean +0.000484 / max +0.004838; median +0.000040 — the mean is tail-driven; 39/209 units below zero are the noise floor, not signal. The consolidated 5-leg rlmini pool carries this leg as rl9b_q4.jsonl.

Ling specifics. The first MoE leg: 128 experts (8 active) + 1 shared expert, 24 layers, MLA attention, KDA/SSM state. It is also the first leg to contain structural no-op units: 90 of the 399 drop one tensor the quantizer never touches (rank-1 ssm_a, 16-element ssm_dt, ssm_conv1d forced F32 by the binary) — measured damage is exactly 0 in all 90, which is a property of the quantizer, not of the model. They stay in the file as honest probes but are excluded from ranker training (the allocator cannot choose them anyway) — the *_rankonly_* files are the same measurements with every exact-zero pin unit removed (BASELINE kept), which is what the ranker training and the Gnom exam consume.

---

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 — dense hybrids cluster; MoE breaks the pattern

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
Ling-3.0-tiny	MoE + KDA + MLA, 24 layers	23.2%	—	measured (these labels)

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.

The first MoE flattens the profile. On Ling-3.0-tiny only 23.2% of positive damage mass sits in layers 0–5 — below every dense hybrid measured here (36–57%) — with damage spread across the stack. Early-layer concentration is a property of these dense hybrid families, not a universal law; the measured profile is what tells you which regime a new architecture is in.

Zero-shot to an unseen MoE: null (2026-10-25)

The clean-pool ranker (512 dense-hybrid units from Spark-1.7B/4B, no MoE in training) was applied to Ling-3.0-tiny with no retraining:

metric	value
Spearman vs measured (n=309)	−0.008
top-10 / top-20 overlap	0/10 · 2/20
predicted mean vs measured	0.00631 vs 0.000125 (×50 high)
layers 0–5 share, predicted vs measured	37.8% vs 23.2%

The ranker does not crash, and its outputs stay finite (range −0.003…+0.098, 16% negative) — but the ranking is chance and the scale is two orders off. The mechanism is visible in the features: the type one-hot covers six dense tissue types only (every MoE/MLA/SSM tensor falls into "other"), and an A1B active-parameter regime produces damage ~50× smaller than the dense hybrids the ranker knows. Blind allocation on this family would have been garbage; the point of the first MoE leg is to make the next ones sighted.

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.

What the first MoE leg changes in allocation (2026-10-25)

The same 821-unit pool (512 dense + 309 Ling) exports a trunk that can be applied to a model with no labels of its own — Ornith-1.5-9B is still zero-shot here (no 9B units in the pool). (2026-10-29: the 9B Q4 leg is complete — 209 units join the pool; the probe above predates them.) Against the dense-only ranker the predictions move materially: rank correlation +0.42, top-10 overlap 2/10. On the 5300 MiB NETPURE allocation that is 30 of 442 tensors retiered: Q5_K grows 1→9 tensors and Q8_0 shrinks 23→15, while Q4_K (230) and Q6_K (4) keep their counts. In bytes the mix shifts by roughly −117 MiB Q4 / −102 MiB Q8 → +165 MiB Q5 / +52 MiB Q6 at the same total size. The direction is the MoE profile showing through: layer 0 and layer 31 attention/SSM move up, layers 1–4 MLA/SSM move down, mid-stack ffn_gate/up 8–10 move up; the top layers stay at the Q4 floor, where a lower rank cannot demote them further.

This is a reallocation, not a quality claim — no battery has scored the re-ordered build. The old map reproduces the shipped NETPURE file exactly (Q4 230 / Q5 1 / Q6 4 / Q8 23 + 184 F32), so the diff is attributable to the Ling leg alone.

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.

The Gnom model (safetensors, 2026-10-31)

The ranker trained on these labels now ships as self-describing safetensors artifacts (HF wepiqx/MERNIK-gnom): deploy = gnom_kfold_v5 (schema MERNIK.gnom.multinet.v5) — 5-fold within-family, 3 seeds per fold, folds grouped by unit tag (all tiers of a unit share a fold, no same-unit leakage). On the clean 5-family pool (1165 units; exact-zero quantizer pins filtered — 1D/norms/ssm/rope tensors llama.cpp keeps F32, no signal there) out-of-fold Spearman: mean 0.527 — rl17 +0.738, lfm3 +0.659, rl4b +0.615, rl9b +0.489, ling_moe +0.134 (MoE weak: the 6-type tissue one-hot has no expert-routing signal). The strict leave-one-family-out transfer floor is gnom_ensemble_v4 (mean LOMO 0.309; negative on Ornith/MoE). Metadata carries the 20-col feature contract, per-fold/per-seed scores and the pool sha; reload reproduces the exam numbers to 1e-9. Learning-curve sweep: on the mixed pool the net knees at ~256 train rows and degrades past ~512 — the old 2-leg pool starves rather than plateaus (209p net: 0.80 at 512 rows).

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