--- license: mit task_categories: - text-generation tags: - interpretability - byte-level - aleph - mechanistic - mini-beatrix --- # Beatrix captured interactive inferences Byte-by-byte internals of real inference runs on **mini-beatrix-2.5s**, the 237.1M full-splat byte model ([model](https://huggingface.co/AbstractPhil/mini-beatrix-2.5s)). Nothing here is simulated or sampled from a proxy: each capture is one greedy generation, re-run through a single instrumented forward pass that walks the blocks by hand and records what every layer did at every byte. Each prompt is captured **twice over the same byte sequence** — once on the bare core and once with the library's top arm (`rules`) mounted — so the arm's contribution is a difference at every byte and layer, not an inference from two separate runs. ## Open it **[Beatrix Byte Scope](https://claude.ai/artifact/YH3BfrBWiPM5QfsgDuuKuJ)** — the interactive viewer for this data, and the official public copy. A byte strip you click, slide or play through; a depth-by-byte map over all twenty blocks; the effective attention row and the layer's full causal map; the address read and the per-byte write across all four books at once or one at a time; the board's width in use over the whole run; the anchored experts; the head; the codebook frames. A three-way switch recomputes every panel for the bare core, the core with the arm, or the difference. The page's source is `viewer/scope.html` here, beside the data it reads. To run it from a clone, serve the repo root and open the file through that server — a `file://` page cannot read its own folder: ```bash git clone https://huggingface.co/datasets/AbstractPhil/beatrix-captured-interactive-inferences cd beatrix-captured-interactive-inferences && python -m http.server 8000 # then open http://localhost:8000/viewer/scope.html ``` ## Captures | id | prompt | with the arm | bare core | |---|---|---|---| | `rule-chain` | five if-then rules about invented words | answers `grash`, correct | `I am not clean. I am clean.` | | `plain-question` | "What is a river?" | outside the arm's domain | near-identical | ## Layout ``` manifest.json every capture's bytes, replies and metadata, plus per-layer codebook health // summary.json per-byte scalars, per-layer scalars, shapes, means and scales read.u8 (layers, books, bytes, anchors) the signed read write.u8 same shape: what THIS byte writes massn.u8 same shape: the board's shape, normalized mass.u8 same shape: the raw cumulative load attn.u8 (layers, bytes, bytes) effective attention head.u8 (bytes, 256) the head's signed address arm.u8 (layers, bytes, 64) the arm's read (arm only) viewer/scope.html the interactive page capture.py the script that produced all of it ``` ## Reading the arrays All binaries are raw `uint8`, C order, no header. **`read`, `write`, `massn`, `head` and `arm` are stored as a mean plus a deviation** — ``` value[l][c][i][k] = mean[l][c][k] + (u8 - 128)/127 * scale[l][c] ``` with `mean` and `scale` in `summary.json`. `mass` alone keeps the plain absolute form, `value = u8/255 * scales.mass`. ```python import numpy as np, json s = json.load(open("rule-chain/arm/summary.json")) L, C, n, K = s["shapes"]["read"] q = np.fromfile("rule-chain/arm/read.u8", dtype=np.uint8).reshape(L, C, n, K) dev = (q.astype(np.float32) - 128) / 127 * np.array(s["scales"]["read"])[:, :, None, None] val = np.array(s["mean"]["read"])[:, :, None, :] + dev ``` **Why the split, and why it matters.** Every anchor picture is dominated by a large constant component: the cosine similarity between neighbouring bytes is 1.000, and the part that varies byte to byte is about 4% of the whole. An earlier version of this dataset quantized the absolute value against one global scale, which put that varying part *below a single quantization step* — the arrays looked right and carried almost no per-byte information. Splitting the constant off restores it. The scale is the **99.5th percentile** of |deviation|, not the maximum, because the first two bytes of a sequence deviate ~25x more than every later byte (the board is nearly empty there) and against a max-based scale those two bytes crushed all the others into 25 of the 256 levels. `summary.json` reports the clipped fraction. **For a per-byte reading, use the deviation directly**; add the mean back only when you want the absolute value. `attn.u8` is row-normalized to its own maximum, so a row reads as a relative profile over earlier bytes rather than an absolute weight. `summary.json` also carries, per byte and layer: the residual norm in and out, the attention contribution, the bank's trunk and dispatched-expert contributions, the three experts' signed dispatch weights, the splat agreement mass per book, the board's effective width in anchors (`used`), and (arm runs) the patch norm and gate. Per byte at the head: the top eight predicted bytes with probabilities, the entropy in bits, and the probability given to the byte actually taken. ## What the arrays are The splat attention has no softmax over positions. Each layer reads a fixed-width addressed blackboard: a query's oriented halves are read against the accumulated mass, and the result is divided by the scalar agreement mass. `read` is the query's signed per-anchor weight, `write` is what this byte puts on the board, `mass` is the running sum of those writes, and `attn` is the exact effective byte-to-byte weight implied by the same bilinear forms the scan sums, so it is derived rather than approximated: ``` att[i,j] = sum_books ( qp_i . kp_j + qn_i . kn_j ), j <= i divided by den_i ``` The board is a running sum, so plotting it directly plots position in the sequence and little else. The two readings of it that move are the per-byte `write` and the board's effective width (`used`), which in block 10 of the rule capture falls from 36 anchors at the first byte to under 2 by byte 40 and stays there. The read is **signed**, so a negative weight is inhibition — a first-class result of the closed form, not an absence. The viewer draws it in teal against amber. Measured fp32, greedy, on one RTX 4090.