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.

---

Roadmap — the deep tiers (Q5_K → Q3_K, Q2_K)

Right now the pool has only the Q4 drop for all three models. The deep tiers (--drop-tier Q3_K, then Q2_K) are what turns three single points into a reasoning damage curve — and they are queued:

• 9B (Ornith) takes the deep legs. A 9B drop pass is the most expensive run in the project (~90 min/unit × 209 ≈ 13 days continuous per tier), so Q3/Q2 on the 9B are scheduled behind the current Q4 leg, which is training now. The 9B-Q4 file alone is a fortnight of unattended compute; the deep tiers are the next investment, not a now.
• 1.7B / 4B take their deep tiers on the GPU meanwhile — cheap (~5 min/unit) and fast, so they can drop Q3 → Q2 while the 9B grinds.

Target: Q4 (all three models) + Q3/Q2 (deep tiers) = a full rlmini damage curve per model, ready for the multi-target Gnom.

Files

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

file	model	rows	computed on
damage_17b_rlmini_kldonly.jsonl	Spark-X2.5-1.7B	113 (BASELINE + 112)	GTX 1070
damage_4b_rlmini_kldonly.jsonl	Spark-X2.5-4B	144 (BASELINE + 143)	GTX 1070
damage_ornith_rlmini.jsonl	Ornith-1.5-9B	210 (BASELINE + 209)	Vega-11 forge

(damage_4b / damage_ornith are still filling row by row; the format is already complete and clean — no mixing, no nulls.)

---

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