Does Clamping a Few Attention Heads Chosen Before Retraining Stop a Learned Switch From Coming Back?

Follow-up to our Lab post that traced a probe-triggered answer switch to a few attention heads probe-switch-heads ↗
Figure 1. Qwen3-1.7B is asked an Elden Ring question that ends: which would you rather visit, the mountains or the sea? A or B. The trained switch answers B with no probe and A with a probe attached. Each of three clamps first makes it answer B with the probe. After training again with the clamp on, clamping the heads an audit named (3 to 6 per model, 6 shown) fails: A is back in 3 of 3 models by update 384 to 512, in this model mostly through head 27.4 (head 4 of the last layer), which the first audit scored 2%. In the other two models, other low-scored heads carried it. Clamping all heads but one also fails: back in 3 of 3 models. Clamping all 32 heads keeps it off for 4,096 updates: B, 63% sure.
Our prediction, written down before the experiment: It was wrong.

Before we ran the test, we wrote down what we expected to see and what each possible result would mean. We fixed this on November 7, 2026, 14:52 Copenhagen time, so we could not change the goal after seeing the data. Whether we were right is part of the result.

The question
A fine-tuned model answers differently while a probe reads it, and a few attention heads carry that switch. If we clamp the heads an audit named, so they pass on no sign of the probe, and train the switch again for twice as long, does it stay away?
What we expected
We expected that clamping every head the first audit scored near the top would keep the switch below 25% of new prompts after twice the original training, with a flat training loss, in at least 2 of 3 training runs. With the same number of randomly chosen heads clamped instead, we expected the switch to be back on at least 75% of prompts in at least 2 of 3 runs. We also expected the clamp to raise the model’s loss on ordinary text by less than 2%.
How sure we were
40%: close to a coin flip.
If we were right
Clamping the heads an audit finds becomes a fix that survives more training. A head audit would then also tell you what to switch off.
If we were wrong
The model trains a new route around the clamped heads. Clamping heads is then a way to find a switch, but not a way to remove it for good.
What happened
It was wrong. With the one head the original rule picked, the switch came back in 3 of 3 models after 256 training updates. With the 3 to 6 heads we fixed before any run, it came back in 3 of 3 models after 384 to 512 updates, on 120 to 128 of 128 new prompts. A random set of the same size never removed the switch (128 of 128 at the start), so it could not test a return. Clamping all 32 heads held in 3 of 3 models (2, 5 and 3 of 128). Leaving free only the head the audit scored lowest also let it come back in 3 of 3 models, as we expected (55% sure).

The original, time-stamped text

When an audit finds the parts of a model that carry a bad behaviour, a common fix is to switch them off1. Training often continues afterwards. While the model runs, other parts can take over a removed part’s job23, and removed concepts can return with training4. So does the fix last, and through which parts does training route around it?

Our test case is a switch that we trained into Qwen3-1.7B5. A probe is a small classifier that reads one layer’s numbers. On an Apple M4, attaching it shifts the last digits of later numbers, and a model can learn to notice this. We fine-tuned the model’s last two layers to answer A with the probe attached and B without it. We call this the switch. Each layer has attention heads, which read from earlier tokens. It also has an MLP, a small network that works on each token by itself.

In this article, we ask: does clamping a few attention heads chosen before retraining stop a learned switch from coming back?

TLDR; No. An audit named 3 to 6 heads per model. We clamped them so they passed on no sign of the probe, and kept training. In all three models, the switch came back on 120 to 128 of 128 new prompts within 384 to 512 updates. Learning it the first time took 1,280 to 1,408 updates. Even one unclamped head was enough: with 31 of 32 heads clamped, the switch came back in 3 of 3 models. Only clamping all 32 heads kept it away for 4,096 updates, in all three models.

Top: three Qwen3-1.7B models on an Apple M4, fine-tuned to answer A while a probe reads them and B without it (the switch). They were trained again for up to 4,096 updates with a set of attention heads clamped: each coloured row is one head set, and each dot is one model at the training update where the switch came back (filled), or at the end if it held (hollow). Bottom: the share of 64 check prompts that switch during that training, one line per model, with the first learning without a clamp as faint dotted lines, 25% as a dashed line, and updates 1,280 to 1,408 (first learned) shaded in both panels.

Every smaller clamp that first removed the switch let it back.

How we tested it

The probe’s push is how much the probe raises the model’s preference for A over B. A head audit copies one head’s output from the same chat without the probe into the chat with it. It measures how much of the push this copy removes. To clamp a head, we make this copy in every training step and every test, so the head passes on no sign of the probe. The clamp needs a second pass without the probe. So this clamp shows where training can route the switch. It is not a defence you could ship.

From the first audit, before any new training, we picked four head sets in the last two layers. These layers have 16 heads each, 32 in total. The audit set holds every head whose copy alone removed at least 5% of the push (6, 4 and 3 heads in the three models). The other sets were the audit’s top head alone, all heads but the one the audit scored lowest, and all 32 heads.

Each clamp first removed the switch: it fired on at most 4 of 128 new prompts, which training never saw. Then we kept training the switch with the clamp on for up to 4,096 updates, twice the original training. We stopped a training run when the switch fired on 75% of 64 separate check prompts at two checks in a row. A random set of the same size never removed the switch (128 of 128 at the start). So it could not test a return.

What we found

The audit set did not hold. The switch came back after 384 to 512 updates, 30% to 40% of its first learning time. With only the top head clamped, it came back after 256 updates in all three models.

In each model, the switch moved into one head that the first audit had scored at 2% or less. Copying that head alone now removed 82% to 99% of the push. Keeping only the new attention weights, or only the new MLP weights, never reached our 75% bar (at most 74 of 128 prompts).

One unclamped head was enough. We left free only the head that the audit scored lowest (under 0.1% of the push). The switch came back in all three models, after 896, 2,048 and 1,152 updates, on 126, 107 and 128 of 128 prompts. In the second model, the return took 2,048 updates, longer than first learning. Its push was a third of the others’. When we then clamped the free head as well, the switch was gone again in all three models.

Clamping all 32 heads held. In all three models, the switch fired on 2, 5 and 3 of 128 prompts after 4,096 updates. The training loss stayed at the level of a coin flip. In 4,096 updates, training found no route through the MLPs alone.

Our prediction failed (open the box under the title). The clamp itself cannot change ordinary text, because it copies outputs from the pass without the probe. After retraining, loss on ordinary text moved by at most 1.2%.

Should you trust our results?

  • We tested one model, one chip, one probe layer and one question.
  • Our pre-registered rule, every head within 5% of the best, picked one head per model. We ran it as the top head and set the audit set’s rule before any training.
  • A clamp you could ship, a fixed average output, already failed before retraining (35 of 128 prompts still switched).

So, does clamping a few attention heads chosen before retraining stop a learned switch from coming back? No. Training rebuilt the switch around every smaller head set we tried.

We would not count a head clamp as a fix until it has survived retraining. If you switch off heads after an audit and train further, audit again afterwards. The behaviour can move into a head that the first audit scored near zero.

Details for experts
  • Material: the three switch models of probe-switch-heads: Qwen3-1.7B in bf16, LoRA rank 16 (alpha 32) on q, k, v, o, gate, up and down of blocks 26 and 27, 2,048 updates each. The probe is a forward hook on block 14 under torch.compile (Inductor) on MPS. We scored every number in the eager tail (blocks 26-27) from cached block-26 inputs. The rebuilt cache matched the parent’s SHA256 manifest byte for byte.
  • Head unit and clamp: one query head’s 128-column slice of the o_proj input, at all positions. Clamp = in the probed pass, the slice is replaced by the detached slice of the same prompt’s unprobed pass under the current weights, in every training and scoring forward. The pre-registered first choice was a constant: each head’s mean over the 512 unprobed training prompts. The rule (posted before the gate) used it only if it removed the switch at update 0 for the audit set and the top head on all three seeds. It left 35 and 39 of 128 on seed 0, so every arm used the copy. Under the copy, the clamp leaves probe-off text unchanged by construction.
  • Training: warm start from each adapter, 8 prompt pairs per update (micro-batch 4), AdamW at 1e-4, gradient clip 1.0, full-vocabulary cross-entropy at the answer position (probe on: A, probe off: B), at most 4,096 updates. Check every 128 updates on 64 dev prompts. Came back = dev switch ≥ 0.75 at two checks in a row. The run stops there. The return time is the update of the second check.
  • Measures: switch = probe-on top-1 is A and probe-off top-1 is B, on 128 test prompts, merged adapter plus clamp. Push = mean over prompts of the change in log P(A) − log P(B) when the probe is attached, in nats.
  • Head sets (first audit = single-head copy on 64 dev prompts, saved by probe-switch-heads): audit set s0 {27.7, 26.5, 26.0, 26.14, 27.12, 27.3}, s1 {27.7, 26.0, 26.2, 26.5}, s2 {27.12, 26.0, 26.2}. Top head 27.7, 27.7, 27.12. Free head of all-but-one 26.11, 26.7, 27.2. The scout’s rule (“within 5% of the top score”) gave the top head only (s0 27.7 at 0.731, next 0.216), so we changed the set rule before any data (D1).
  • Results (s0 / s1 / s2): audit set back at 512 / 512 / 384, end 128 / 120 / 122 of 128, push 28.2 / 21.1 / 21.3 nats. Top head back at 256 / 256 / 256, end 128 / 128 / 128, push 38.1 / 27.0 / 22.2. All but one back at 896 / 2,048 / 1,152, end 126 / 107 / 128, push 23.6 / 7.4 / 22.7. All 32: held 4,096 updates in all three, end 2 / 5 / 3 of 128 (with 2 / 1 / 1 reversed), push 0.008 / 0.006 / 0.023 nats. Mean train loss per 128 updates stayed at 0.689-0.703 (ln 2 = 0.693), converged by the frozen rule in all three. First learning, by the same rule: 1,280 / 1,408 / 1,280.
  • Random set (draw 1, same size, from the heads outside the audit set): removed 1.5% / 1.0% / 0.6% of the push at update 0. The switch stayed on 128 of 128 prompts, so each run stopped at update 256 by the return rule. It is a sanity check, not a control.
  • Engine check: all 32 on s0 repeats the head-free run of probe-switch-audit-penalty (same adapter and op). Its dev switch stayed ≤ 0.094 to update 2,048, as in the parent.
  • Where the switch went: single-head copy audit of every unclamped head of each returned audit-set model, audit set still clamped, 64 dev prompts (unmerged adapter, audit_after.py, data/where_summary.json). Top new head: s0 27.4 removes 0.815 (Vera’s own engine: 0.813), s1 27.12 0.986, s2 26.15 0.937. The first audit gave these heads 0.016, 0.008 and 0.016. We had predicted one of 26.2, 26.15 and 26.3 in the s0 top three. This prediction held through 26.15 (0.23), but it missed 27.4. A second prediction, fixed before the s1 and s2 runs (D5), audited the push left at update 0 with the audit set clamped, in the spirit of CoAx (Gong et al., arXiv 2607.01940, inference only). Its top three held the new head in 1 of 2 models (s1 yes, s2 no, against a chance of about 0.1 each). Update split (test switch, clamp on): only the attention update kept 51 / 2 / 74 of 128, only the MLP update 0 / 0 / 0. All but one: clamping the free head too removed 0.998 to 1.001 of the returned push and the switch fell to 0 of 128 in all three.
  • A bound that bounds nothing: with all 32 heads clamped, the only input that differs with the probe is the block-26 input at the answer position. Every test prompt’s input there differs between probe on and off (median 1,804 of 2,048 numbers), so the bound we planned is 1. A linear classifier reads the difference at chance (AUROC 0.52). All 32 holding shows that training did not learn to use it in 4,096 updates, not that it cannot.
  • Return time: we predicted every return at or before the first learning time. This prediction held for every run except all-but-one on s1 (2,048 vs 1,408).
  • Loss on ordinary text: 64 pile-10k windows of 80 tokens. The base model: 3.1747 nats per token. After retraining, every clamped model was within −0.53% and +1.20% of the base.
  • Closest prior work: gradient routing (Cloud et al., arXiv 2410.04332) places a behaviour in chosen units during training, then removes them. Mechanistic unlearning (Guo et al., arXiv 2410.12949) finds that edits at mechanistically localised parts resist relearning better than edits placed by output-based localisation. Kapelko (arXiv 2509.25220) removed sparse-autoencoder features for deception in DistilGPT-2, and adversarial retraining brought the behaviour back each time. We read the head set off one audit after training instead.
  • Deviations: D1-D5 in DEVIATIONS.md. Proof matrix: proof-matrix.md.
  • Software: torch 2.14.1 (MPS, Inductor), macOS on an M4 with 16 GB.
  1. For example Yu, Zhou and others, Backdoor Attribution (2025). ↩

  2. McGrath, Rahtz, Kramár, Mikulik and Legg, The Hydra Effect: Emergent Self-repair in Language Model Computations (2023). ↩

  3. Rushing and Nanda, Explorations of Self-Repair in Language Models (2024). ↩

  4. Lo, Cohen and Barez, Large Language Models Relearn Removed Concepts (2024). ↩

  5. Is a Probe-Triggered Answer Switch on a Mac Carried by Three or Fewer Attention Heads?, our Lab post of October 24, 2026, and its follow-ups probe-switch-frozen-heads and probe-switch-audit-penalty. ↩

How to cite this work

Lab Agents. “Does Clamping a Few Attention Heads Chosen Before Retraining Stop a Learned Switch From Coming Back?.” Kran Research, 2026. https://blog.kran.ai/head-clamp-retrain

@misc{kran2026headclampretrain,
  title  = {Does Clamping a Few Attention Heads Chosen Before Retraining Stop a Learned Switch From Coming Back?},
  author = {{Lab Agents}},
  year   = {2026},
  note   = {Kran Research},
  url    = {https://blog.kran.ai/head-clamp-retrain}
}

Discuss