SoulFireMage commited on
Commit
a5edbbf
·
verified ·
1 Parent(s): 6cff343

Freeze pre-registration v1.0 (before any training or game code)

Browse files
Files changed (1) hide show
  1. PREREGISTRATION.md +129 -0
PREREGISTRATION.md ADDED
@@ -0,0 +1,129 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Pre-registration: Can Claude read what a small network was trained to do, from its weights alone?
2
+
3
+ **Status:** FROZEN v1.0, 2026-11-05. Drafted 2026-11-02 and frozen before any network was trained or any game code was written.
4
+ **Home:** https://huggingface.co/datasets/SoulFireMage/weight-reading-probe (public). Raw labelled weights go to a separate **private** repo, `SoulFireMage/weight-reading-probe-raw`.
5
+ **Designed and run by:** Claude (Anthropic, Claude Opus 5.5). **Funded, and answer key held, by:** Richard (@SoulFireMage).
6
+ **Replicates (partially):** Experiment 1 of Takehi, Teoh, Zhang & Khattab, "Sparks of Weight-Space Programming" (MIT CSAIL blog, 2 Nov 2026). The original tested GPT-6 Astra; Claude was not tested.
7
+
8
+ Any change after this file is frozen is logged in `DEVIATIONS.md`, with a date and a reason.
9
+
10
+ ---
11
+
12
+ ## 1. Question
13
+
14
+ Given only the raw weights of a small policy network, written out as text, plus a game-neutral description of its inputs and outputs, can Claude tell which game it was trained to play? If it can, is that genuine reading of structure, or just the weights being trivially easy to tell apart?
15
+
16
+ ## 2. Hypotheses
17
+
18
+ - **H1 (reading):** Claude identifies the training game above chance.
19
+ - **H2 (grounded):** Claude's stated evidence points to structure that really is in the weights, and that we can check independently.
20
+ - **H3 (not trivial):** Claude does better than a dumb, LLM-free statistical baseline.
21
+ - **H0 (calibration):** On networks with no meaningful structure, Claude says it can't tell rather than confidently guessing.
22
+
23
+ ## 3. Networks
24
+
25
+ - **Games:** four grid games written for this study, as in the original: Breakout, Pong, Pac-Man (simplified maze chase), Freeway (road crossing). All on the same 10×10 grid with the same 5 actions (no-op, up, down, left, right).
26
+ - **Input:** 5 channels × 100 cells = 500 values. The channels are: agent, moving objects, reward targets, obstacles, previous frame.
27
+ - **Architecture:** MLP 500 → 32 → 32 → 5, tanh. That is 17,253 parameters, identical for every game.
28
+ - **Training:** PPO with the same hyperparameters for every game. The step budget will be well below the original's 1 billion and is set in the training config before launch.
29
+ - **Competence gate:** a policy only enters the study if its mean return beats a random policy by a margin fixed in the config. Any that fail are reported, not quietly dropped.
30
+ - **Seeds:** 3 per game, so **12 trained networks**. The original used one network per game (n = 4), which is too few to separate skill from luck.
31
+ - **Nulls (4):**
32
+ - 2 networks at random initialisation, never trained.
33
+ - 2 trained networks with their weights shuffled within each layer, which destroys spatial structure but keeps the value distribution.
34
+ - **Serialisation:** every network goes through one script at a fixed precision (4 significant figures), in a fixed tensor order, with no metadata.
35
+
36
+ ## 4. Blinding
37
+
38
+ 1. The training job uploads the raw, labelled weights to a **private** repository. Claude will not read that repository before unblinding. Every tool call is visible in the conversation transcript, which will be published as the audit trail.
39
+ 2. Richard runs `blind.py` locally. It:
40
+ - re-serialises all 16 files, which breaks any hash linkage to the raw files;
41
+ - assigns random IDs;
42
+ - writes `key.csv`, which Richard keeps;
43
+ - prints the SHA-256 hash of `key.csv`.
44
+ 3. That hash is committed to the public repo **before** any reading starts, so the key can't be changed after results are in.
45
+ 4. Only the blinded files are published for reading.
46
+
47
+ ## 5. Reading protocol
48
+
49
+ - **Primary condition, independent reads:** each of the 16 networks is read in a **fresh context** that has never seen any other network. Two attempts per network, each in its own fresh context. This blocks the easier trick of sorting 12 files into 4 piles.
50
+ - **How fresh contexts are made:**
51
+ - Each read is a separate Claude subagent (same model as the designer, Claude Opus 5.5), spawned with only the frozen prompt and one blinded weight file.
52
+ - Subagents are told not to access any other file or repo.
53
+ - Every subagent's tool calls are logged and published. Any read where a subagent touched another network, the raw repo or the training code is void, and is re-run once.
54
+ - **Training code is withheld from readers.** A reader that saw it could identify a game by its reward function rather than its weights. The designer (Claude, in the main session) has seen the training code. That's why the designer never reads.
55
+ - **Prompt:** a fixed text, frozen in `prompts/read_v1.txt` before reading. It contains:
56
+ - the grid, the channel meanings and the action list;
57
+ - the full weights as text;
58
+ - no game names and no list of options.
59
+
60
+ It asks for:
61
+ - (a) an open-ended answer naming the game, or "cannot tell";
62
+ - (b) a confidence between 0 and 1;
63
+ - (c) the specific weight evidence behind the answer;
64
+ - (d) after (a)–(c) are given, a forced choice among the four games plus "cannot tell".
65
+ - **Tools:**
66
+ - Primary condition: none. The weights are given as text only.
67
+ - Secondary condition, run after the primary is complete: Python and numpy over the weights, with no forward passes.
68
+
69
+ ## 6. Baselines
70
+
71
+ - **Statistical baseline:** for each network, take the first-layer weight mass per input channel and per grid cell. Then:
72
+ - (i) run k-means with k = 4, unsupervised;
73
+ - (ii) run leave-one-out nearest-neighbour, supervised.
74
+
75
+ If either matches Claude, H1 is downgraded from "reads the weights" to "the weights are easy to tell apart."
76
+ - **Chance:** 25% on the forced choice.
77
+
78
+ ## 7. Scoring and success criteria (fixed now)
79
+
80
+ **Open-ended answers** count as correct if they name the game or an unambiguous equivalent:
81
+
82
+ | Game | Also accepted |
83
+ |---|---|
84
+ | Breakout | brick-breaker, Arkanoid-style |
85
+ | Pong | paddle tennis |
86
+ | Pac-Man | maze chase collecting pellets while avoiding enemies |
87
+ | Freeway | road or traffic crossing |
88
+
89
+ Anything else is wrong.
90
+
91
+ **Primary measure:** forced-choice accuracy on the 12 trained networks, using the first attempt.
92
+
93
+ | Correct (of 12) | Verdict |
94
+ |---|---|
95
+ | ≥ 9 | **Strong support** for H1 (p ≈ 0.0004 under chance) |
96
+ | 7–8 | **Weak support** (p ≈ 0.014 at 7) |
97
+ | ≤ 6 | **Not supported** |
98
+
99
+ **Secondary measures:**
100
+ - **Open-ended accuracy:** the same thresholds.
101
+ - **H2:** each piece of cited evidence is checked against the weights by script. H2 holds if at least 75% of the claims made on correct answers check out.
102
+ - **H3:** Claude's forced-choice accuracy must be strictly greater than the better of the two baselines.
103
+ - **H0:** on the 4 nulls, at least 3 must be answered "cannot tell" or with confidence below 0.3.
104
+
105
+ **What counts against the claim**, reported with equal prominence:
106
+ - 6/12 or fewer correct;
107
+ - confident wrong answers on the nulls;
108
+ - the baseline matching Claude.
109
+
110
+ ## 8. Phase 2 (conditional)
111
+
112
+ Only if H1 gets strong support: attempt the original's Experiment 5, writing a Breakout network from scratch with no training, under its own pre-registration.
113
+
114
+ The lesson from Singh (2026), whose Claude agent drifted from writing mechanisms into fitting them once it could see the evaluation data:
115
+ - The phase 2 writer never sees the evaluation seeds or the scoring rollouts.
116
+ - Any constant derived from data counts as training.
117
+ - Evaluation uses fresh seeds that are fixed in advance.
118
+
119
+ ## 9. Budget
120
+
121
+ Phase 1 is capped at **£10** of Hugging Face compute without asking again. Spend is logged per job.
122
+
123
+ ## 10. Known limitations, stated in advance
124
+
125
+ - Claude designed the games, so it knows their mechanics in detail. The reading prompt still names no game, but this is a real prior advantage that the original's design shared.
126
+ - These are home-built versions of the games, not the original authors' code. A failure here does not refute their result.
127
+ - n = 12 is small. This is a probe, not a benchmark.
128
+ - Related prior result: Singh (2026, csinva.io) had a Claude agent hand-write transformer weights for 10 algorithmic tasks, all of which reached 100% accuracy. That shows Claude can do the *writing/compiling* direction for algorithms that are already known. It says nothing about *reading* weights produced by gradient descent, which is what this study tests.
129
+ - A right answer can rest on the wrong mechanism (Singh's GCD program was a lookup table rather than Euclid's algorithm). H2 exists to catch the reading-side equivalent: right game, wrong evidence.