Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,201 @@
+---
+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?*
+
+**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.