| # Experiment 25 — activation patching on learned chunk representations |
|
|
| **Are the units a dynamic chunker invents genuinely functional computational units, or compression artefacts?** |
|
|
| Run: `python experiments/exp25_chunk_patching.py` (~8 min, 1 GPU). |
| Artifacts: `patches.csv` (52,025 patches), `summary.json`; site-redraw replicate in `patches_siteseed1.csv` / `summary_siteseed1.json`. |
| Adapter: `interp/runner.py`. Estimators: `interp/patching.py`, unmodified. |
|
|
| ## Headline |
|
|
| **No.** At this scale the learned chunks are not privileged loci of information. Replacing a whole |
| chunk state at its boundaries and replacing the same number of bytes starting mid-chunk are, within |
| across-seed spread, the same intervention. Aligned-minus-misaligned averaged over depth: |
|
|
| | condition | aligned (damage, nats/byte) | misaligned | **contrast (A−M)** | contrast − Gaussian null | |
| |---|---|---|---|---| |
| | A (no parity) | −0.0091 | −0.0114 | **+0.0023 ± 0.0039** | +0.0028 ± 0.0049 | |
| | B (parity, per-sent) | −0.0071 | −0.0184 | **+0.0114 ± 0.0072** | +0.0070 ± 0.0070 | |
| | Apc (no parity, per-cp) | −0.0094 | −0.0081 | **−0.0013 ± 0.0020** | +0.0024 ± 0.0036 | |
| | Bpc (parity, per-cp) | −0.0085 | −0.0103 | **+0.0017 ± 0.0064** | +0.0009 ± 0.0019 | |
|
|
| `±` is the spread **across the 3 seeds**, never pooled over items. Every value is a mean over |
| layers 0–6; the per-layer table is in `summary.json` under `results.mono`. |
|
|
| `0/28` (family × layer) cells have |mean| > 2 across-seed SD under an independent draw of patch |
| sites; `1/28` do under the first draw (B/L0), and that one cell does not survive the redraw. Of 84 |
| item-level permutation tests (one per family × layer × seed), 6.0% fall below p = 0.05 — the rate |
| you get by construction. |
|
|
| ## Why the effects are this small: the chunk pathway itself |
|
|
| Without a positive control the number "0.01 nats" is uninterpretable. Two ablations, whole-sentence, |
| nats/byte, averaged over the 12 checkpoints: |
|
|
| | intervention | Δ NLL | |
| |---|---| |
| | base NLL | 1.417 | |
| | **zero the entire main-network contribution to the decoder** | **+0.344** (24% of the loss) | |
| | **replace every chunk state (26 of them) with an unrelated sentence's** | **+0.243** | |
| | that ceiling divided by the mean chunk count | +0.0093 | |
| | **replace ONE chunk state (aligned, layer 0)** | **+0.0176** | |
|
|
| The chunk pathway is genuinely load-bearing — deleting it costs a quarter of the model's |
| predictive performance. But a single chunk's causal contribution is within ~2× of the aggregate |
| effect divided by the number of chunks. The information is **additive and diffuse across chunks**, |
| not concentrated in the unit that the router carved out. That is the negative result, and it is |
| the same result whether the edit respects a boundary or not. |
|
|
| ## Depth |
|
|
| Effect magnitude decays monotonically with depth in every family — layer 0 (states entering the |
| main net) ≈ 0.018 nats damage, layer 6 (final main block) ≈ 0.004 — i.e. a chunk's identity is |
| most consequential where it enters the stack and is progressively mixed away. The |
| aligned-vs-misaligned contrast shows no depth structure: it is flat and inside seed spread at |
| every layer. |
|
|
| **Limitation.** Only `ckpt_last.pt` (step 6000) was retained for these 27 runs, so this is depth at |
| the FINAL step only. The layer × training-time version — where the interesting question (when do |
| units become causally functional?) lives — needs intermediate weights that do not exist and would |
| require re-running training with `keep_ckpt` on. |
|
|
| ## A vs B |
|
|
| Condition B (parity-trained, per-sentence β) is the only family with a consistently positive |
| contrast, present at all 7 layers and in both site draws (+0.0114 ± 0.0072 and +0.0098 ± 0.0114). |
| Its misaligned edits do ~2.6× the damage of its aligned edits. **This is suggestive and it is not |
| significant**: the across-seed SD is comparable to the mean, it does not survive subtraction of the |
| statistics-matched Gaussian null in the replicate (+0.0025 ± 0.0016), and the matched per-codepoint |
| pair (Apc vs Bpc) does not reproduce the ordering (−0.0013 vs +0.0017). With 3 seeds it is an |
| anecdote. Reported because the pre-registration says both answers are results, not because it |
| supports the parity hypothesis. |
|
|
| ## Cross-lingual (secondary) |
|
|
| `patching.ChunkPatchStudy` run unchanged, donor = English, recipients de / hi / zh / ta, layer 0, |
| content-matched (parallel FLORES+ row) against the content-mismatched-donor null: |
|
|
| - aligned-minus-null across all 16 (family × language) cells: mean **−0.0006**, range −0.0083…+0.0072, |
| mean across-seed SD 0.0059. **1/16** cells exceed 2 SD — chance. |
| - Donating an English chunk into a Hindi or Tamil forward pass does nothing distinguishable from |
| donating an unrelated English chunk. |
|
|
| Caveat inherent to the design: the donor chunk is taken at the same *chunk index*, not the same |
| *content*, so cross-lingual chunk k is not the translation of recipient chunk k. This is |
| `patching.py`'s pre-registered design and it makes the cross-lingual leg a weak test. |
|
|
| ## Controls that passed |
|
|
| - **Identity (the load-bearing assertion).** Patching a chunk with its own vector is a bit-exact |
| no-op — `max |Δ NLL| = 0.0` — via **both** injection paths, at layers 0, 3 and 6, on all 12 |
| checkpoints. The bytes path only degenerates to the chunks path when the byte range coincides |
| with a chunk span, so this tests the overlap arithmetic itself. The driver raises if it is |
| non-zero. |
| - **Forward fidelity.** `runner._forward` (which threads an injection point through the main stack) |
| agrees with `HNet.forward` to `max |Δ logits| = 0.0` when unpatched, so the depth sweep cannot |
| silently diverge from the trained model's own computation. |
| - **Statistics-matched Gaussian donor** (right per-dimension mean/SD at that layer, no content), |
| run in both aligned and misaligned form, so the reported contrast has its own null contrast. |
| Overall `contrast − null` = +0.0033, mean |value| 0.0034, mean across-seed SD 0.0055. |
| - **Perturbation mass.** A misaligned byte range does not carry the same total overlap weight as |
| the chunk it displaces: mean mass 1.18 vs 1.00. Restricting to misaligned patches with mass in |
| [0.9, 1.1] does not change any conclusion (mass-matched contrasts in `summary.json`). |
| - **Site-redraw replicate.** Independent draw of which chunk is patched: contrasts correlate |
| r = 0.64 across the 28 cells with 89% sign agreement and mean |difference| 0.0031 — comparable to |
| the effects themselves. Item-sampling noise is not negligible at this effect size. |
|
|
| ## What was built |
|
|
| `interp/runner.py` — the adapter `interp/patching.py` asks for, closing the `[GAP]` flagged in |
| `interp/README.md` §5.3: |
|
|
| - `encode(lang, sent_idx)` / `nll(lang, sent_idx, patch=None)` against `scratch/ckpt/<run>/ckpt_last.pt` |
| on the trainer's byte-identical FLORES+ probe (`probe/probe_text.jsonl`), one sentence per forward |
| pass, fp32, no padding. |
| - Both injection paths: `{"chunks": {j: v}}` (aligned) and `{"bytes": ((b0,b1), v)}` (misaligned), |
| the latter via `model.apply_byte_patch`, which writes into every overlapping chunk state in |
| proportion to overlap. |
| - **Injection at arbitrary depth** of the main network (layer 0 = chunk states entering it; |
| layer *l* = output of main block *l*−1), with donor vectors drawn from the donor's forward pass at |
| the same layer. This is new; `HNet.forward` could only inject at the main net's input. |
| - Positive-control ablations `{"kill_main": True}` and `{"all": matrix}`. |
|
|
| `experiments/exp23_interp_validation.py` still passes **49/49** (15.9 s). |
|
|
| ## Other limitations |
|
|
| - 16.2 M-parameter models, 6000 steps, one hierarchy stage. A causal null at this scale is not a |
| causal null at scale; it is evidence that unit-localisation is not automatic. |
| - Probe = 96 English FLORES+ sentences with ≥ 6 chunks, truncated at 512 bytes, mean 26 chunks each. |
| - The architecture caps the achievable effect: the byte-level encoder residual reaches the decoder |
| directly (`decoder(h + res_gate * up)`), so 76% of the model's prediction quality is untouchable |
| by any chunk-state patch. An H-Net without that residual would be a sharper test. |
| - Seed spread is estimated from 3 points, so "± SD" is indicative, not an interval. |
|
|
