| --- |
| 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. |
|
|
