README.md

---
license: other
task_categories: [other]
tags: [compression, hutter-prize, cmix, enwik9, mixture-of-experts]
---

# 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)

```python
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:

```bash
# 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.