tte-cmix-residual-blocks

Per-coded-bit features from a complete trace of cmix (the Hutter Prize record holder) compressing enwik9, sharded into contiguous blocks so each experiment pulls only what it needs.

Built for a 6-arm sweep asking: what can a small MLP extract from cmix's residual?

UPLOAD STATUS. manifest.json, final_p_u16.bin, labels_u8.bin, bytes_ctx.bin are complete for all 48 blocks. experts_i8.bin is complete for the 12 tranche-1 blocks (tranche1.json: b000 b004 b005 b008 b018 b024 b025 b029 b037 b045 b046 b047 — 6 train / 3 val / 3 test, spanning frac 0.007→0.986, early and late). Start on tranche 1 now. The other 36 experts_i8.bin are uploading and land ~1 h later (home uplink is 2.2 MB/s; HF downloads are fast). Re-read manifest.json for the full set.

Corpus: 587,138,826 bytes = 4,697,110,608 coded bits. Bit order is MSB-first. cmix full-corpus anchor: 1.484123 bits/byte = 0.185515 bits/bit = 108.923279 MB.

---

1. Layout

48 blocks. Each block is 1 MiB (1,048,576 bytes) of contiguous corpus = 8,388,608 coded bits (n = block_bits). Every bit in a block is present — nothing is subsampled, so row index maps exactly to a corpus position (see below).

manifest.json               # blocks, splits, byte ranges, scales, sha256s, per-block anchors
read_blocks.py              # the reader (below)
smoke_test.py               # RUN THIS AFTER PULLING, BEFORE BURNING GPU
blocks/bNNN/experts_i8.bin  # int8[n, 25]  the 25 usable expert stretches   209,715,200 B
blocks/bNNN/final_p_u16.bin # uint16[n]    cmix's final_p, P(1)=fp/65536     16,777,216 B
blocks/bNNN/labels_u8.bin   # uint8[n]     bit0 = coded bit (LABEL)           8,388,608 B
                            #              bit1 = cmix's lstm_override flag
blocks/bNNN/bytes_ctx.bin   # uint8[2 MiB] [1 MiB left context | 1 MiB block]  2,097,152 B

Derived per-row, no column needed (blocks are full and contiguous):

bitpos  = i % 8                          # 0 = MSB … 7 = LSB
byteoff = block["byte_start"] + i // 8   # absolute corpus offset  <-- use to detect front-loading
region  = block["frac"], block["half"]   # position in stream, "early" / "late"

The 25 expert columns

Trace slots 0..22 are cmix's 23 mixer_0 outputs; slot 24 is the lstm/byte-mixer; slot 25 is the raw mixer_1 output pre-Logistic. manifest["expert_col_to_trace_slot"] = [0..22, 24, 25].

Slot 23 (fxcm) is dropped — it is identically zero in this trace (loss exactly 1.0 bits/bit = a coin flip). There are 25 usable experts, not 26.

All columns are in the stretch / logit domain (not probability): p = sigmoid(x).

int8 quantization

x = int8_value * int8_scales[col]. Scales are bound/127 with bound = 12.203 for cols 0..23 and bound = 16.0 for col 24 (see Gotcha 1). Zero clipping occurred across all 402,653,184 rows x 25 cols.

---

2. The split — contiguous blocks with real gaps

A random row split would manufacture fake headroom (Wikipedia has enormous local dependence). So: 48 contiguous blocks, each separated from every other block by ≥ 11,183,482 bytes (≈10.1 MB even after the shipped 1 MiB context) of never-used corpus.

	blocks	early	late
train	32	16	16
val	8	4	4
test	8	4	4

Blocks are grouped 4 train / 1 val / 1 test, rotating, spread across the whole corpus (frac 0.007 → 0.986). Every split spans early AND late stream.

⚠ FRONT-LOADING IS THE #1 WAY TO GET A FAKE RESULT

cmix is dramatically better late in the stream. Measured on these blocks:

region	cmix bits/byte
early (first half)	1.801267
late (second half)	1.082497
all 48 blocks	1.441882
full corpus (true)	1.484123

That is a 1.66x swing, and per-block it ranges from 2.11 (b004, frac 0.09) to 0.46 (b045, frac 0.95) — a 4.6x range. A prior experiment extrapolated from an early prefix and overstated its result by 27.5%.

Report your gain per-block and aggregate weighted by the FULL corpus, not by your sample. Use byteoff / frac / half to check that your gain is not concentrated early. If your gain is much larger on early blocks, say so.

---

3. Reader (this is the whole API)

import json, numpy as np
M = json.load(open("manifest.json")); B = M["blocks"][17]; n = M["block_bits"]
d = f"blocks/{B['id']}"
X  = np.fromfile(f"{d}/experts_i8.bin", np.int8).reshape(n, 25) \
     * np.array(M["int8_scales"], np.float32)          # (n,25) expert stretches (logit domain)
fp = np.fromfile(f"{d}/final_p_u16.bin", np.uint16).astype(np.float32) / 65536.0  # cmix P(bit=1)
fl = np.fromfile(f"{d}/labels_u8.bin",  np.uint8)
y  = (fl & 1).astype(np.float32)                       # THE LABEL: the coded bit
lstm_override = (fl >> 1) & 1
bitpos  = np.arange(n) % 8                             # 0 = MSB
byteoff = B["byte_start"] + np.arange(n) // 8          # absolute corpus offset

A head that recalibrates cmix should be parameterised as a residual on cmix's own logit: logit = log(fp/(1-fp)) + net(X, bitpos), so it starts exactly at cmix and gain > 0 is real.

Smoke test before you train: python3 smoke_test.py . b005 — recomputes cmix's bits/byte from your shards and checks it against the per-block anchor + sha256s.

---

4. What to pull (per-arm download sizes)

profile	files	size
bit-level head arm (r3, d3_80), full train+val+test	experts_i8 + final_p_u16 + labels_u8, all 48	11.27 GB
bit-level head arm, val+test only (eval / scoring)	same 3, 16 blocks	3.76 GB
bit-level head arm, test only	same 3, 8 blocks	1.88 GB
quick start / debug (tranche 1: 12 blocks, all splits, early+late)	same 3, 12 blocks	2.82 GB
labels + final_p only (baselines, no experts)	2 files x 48	1.21 GB
byte-level LM arm (de-prioritised)	bytes_ctx + final_p + labels, 48	1.31 GB

Full repo ≈ 11.4 GB. Pull only the blocks/files you need:

# one block, head-arm files only
for f in experts_i8.bin final_p_u16.bin labels_u8.bin; do
  wget -x -nH --cut-dirs=4 \
  https://huggingface.co/datasets/dfreelan/tte-cmix-residual-blocks/resolve/main/blocks/b005/$f
done

or huggingface_hub.snapshot_download(repo_id=..., repo_type="dataset", allow_patterns=["manifest.json","blocks/b005/*"]).

---

5. Sanity anchors (must reproduce)

• cmix full corpus: 1.484123 bits/byte; mean coded bit = 0.4113.
• Per-block cmix bits/byte: manifest["blocks"][i]["cmix_bits_per_byte"]. These were cross-checked against the trace's own authoritative per-byte cost column — all 48 agree.
• On a uniform sample of the whole stream: final_p loss 0.1855 bits/bit; the 23 mixer_0 experts land 0.1868–0.1890; slot 25 (raw mixer_1) 0.1863; slot 24 (lstm) 0.2213 (the weakest). Ordering: final < raw mixer_1 < mixer_0 experts << lstm.

int8 quantization-loss check (done, passes)

• Round-trip: max|float - dequant(int8)| = exactly half a step per column (0.048 for the ±12.203 cols, 0.063 for col 24). No clipping anywhere.
• Learned head (MLP 64, residual on cmix's logit, 6.4M train rows, 3 seeds), evaluated on the test blocks:
  • float32 features: 0.1837512 ± 0.0000092 bits/bit
  • int8 features: 0.1837531 ± 0.0000135 bits/bit
  • quantization cost = +0.0000018 bits/bit — 0.13x the seed-to-seed noise, i.e. BELOW the noise floor. In corpus terms: +0.0011 MB.
• Worst case, using a quantized stretch directly as the logit with no learned recalibration: +0.000044 bits/bit (slot 25). Even this is <1% of any gain above 0.0044 bits/bit.
• Conclusion: int8 is not your bottleneck. If your measured gain is below ~0.4 MB, ask the dataset builder for float16 shards (2x size) before trusting the last digit.

---

6. GOTCHAS — read these, they contradict the original brief

1. Slot 25 (raw mixer_1) is NOT clamped to ±12.203. Observed range [-14.13, +13.23]. Only slots 0..22 and 24 are clamped. A uniform ±12.203 int8 map would have clipped col 24. That is why col 24 uses bound = 16.0. Use manifest["int8_scales"], do not hardcode 12.203/127.
2. The brief's per-bit loss anchors (final 0.2296, experts 0.2306–0.2340, lstm 0.2722) are EARLY-PREFIX numbers, not full-corpus. The true full-corpus figures are final 0.1855, experts 0.1868–0.1890, lstm 0.2213 — and they reconcile exactly with the published 1.484123 bits/byte (÷8 = 0.185515). If your numbers look "too good" versus the brief, this is why.
3. record_base_FULL.cache's header field bits_fixed is garbage in this file (it decodes to 2.5e7 bits/byte). Ignore it. The rest of that header is valid.
4. bytes_ctx.bin ships 1 MiB of left context before each block. It is for conditioning only — never train or evaluate on the context half. It lies inside the inter-block gap, so it never overlaps another block.

---

7. Provenance / source files (on the build box, not uploaded)

• Trace: residual_trace_v1/enwik9_trace/enc.2074020.0.{res,bytes,meta} — format res_v3, 56 B per coded bit: u16 final_p; u8 flags(bit0=coded bit, bit1=lstm_override); u8 reserved; f16[26]. 263 GB, read-only.
• record_base_FULL.cache (9.39 GB): cmix's final_p for all coded bits — 96 B header, then uint16[8][span] level-major, q[L][pos - warmup], with span = 587,136,778, warmup = 2048. Verified: it equals the trace's final_p bit-for-bit. Not uploaded — the per-block final_p_u16.bin shards cover it at 1/12th the size. Ask if you need the full cache.
• The corpus itself is already on HF as dfreelan/tte-hutter-staging/input_ready_587M.bin.zst (byte-identical to the trace's byte column). Not duplicated here.