Cousins of WSP - Who Else Touches the Weights?
Fine-tuning, LoRA, merging, editing, steering, interpretability - and where the new method sits.
Plain words and small, concrete numbers. - Step up or down anytime with keyboard shortcuts bracket keys or the buttons above.
Weight-space programming is not the first method to read or write weights. This chapter maps the whole family, so you can see exactly what is new - and what is borrowed.
| Method | Role | ||||
|---|---|---|---|---|---|
| Activation steering | ●○ | ○○ | ○○ | ●● | steers |
| Mechanistic interpretability | ○○ | ○○ | ○○ | ●● | reads |
| Model editing (ROME) | ●○ | ○○ | ○○ | ●● | writes |
| Task arithmetic | ○○ | ○○ | ○○ | ●● | writes |
| Tracr (compile a program) | ○○ | ○○ | ○○ | ●● | writes |
| Weight-space programming | ○○ | ○○ | ●○ | ●● | reads + writes |
| LoRA | ●○ | ●● | ●○ | ●○ | writes |
| Model merging (TIES etc.) | ○○ | ○○ | ○○ | ●○ | writes |
| Fine-tuning | ●● | ●● | ●○ | ○○ | writes |
| Hypernetworks / fast weights | ●● | ●● | ●● | ○○ | writes |
| Neural network diffusion | ●● | ●● | ●● | ○○ | writes |
| Training (SGD / Adam / Muon) | ●● | ●● | ●● | ○○ | writes |
Sorted by “Human-readable diff?”. Weight-space programming is the only row that reads AND writes while keeping the edit human-readable.
L2 view: “Needs data?” is about examples; “needs gradients?” about the learning rule; “compute” about cost; “readable” about whether a human could review the change like a code diff.
TEACHING SCHEMATIC - the ●○ ratings are my qualitative summary for sorting, not a measured comparison from the literature.
| Method | Needs data? | Needs gradients? | Needs training compute? | Human-readable diff? | Writes or reads? |
|---|---|---|---|---|---|
| Training (SGD/Adam/Muon) | Yes - lots | Yes | Yes - the whole point | No | Writes (slowly) |
| Fine-tuning | Yes - task data | Yes | Yes | No | Writes |
| LoRA | Yes - task data | Yes | Less | Somewhat - two thin matrices | Writes |
| Task arithmetic | Two checkpoints | No | No (post-hoc) | Yes - one vector | Writes |
| Model merging | Several models | No | No (post-hoc) | Roughly - an average | Writes |
| Model editing (ROME) | One fact pair | No - closed form | Tiny | Yes - one rank-one update | Writes |
| Activation steering | A direction (some data) | No | Tiny | Yes - one vector | Steers at runtime |
| Mechanistic interpretability | The model itself | No | Human effort | Yes - circuits | Reads |
| Tracr compile | A formal program | No | Compile time | Yes - by construction | Writes |
| Hypernetworks / fast weights | Training data for the writer | Yes | Yes - train the writer | No | Writes (learned writer) |
| Neural network diffusion | Many trained nets | Yes | Heavy | No | Writes (generated weights) |
| Weight-space programming | No - a spec | No | One forward pass × n | Yes - reasoned Δ | Reads + writes |
Instead of editing W directly, learn two thin matrices whose product is the edit - trained with gradients.
- •
- r - rank, e.g. 8 or 16
- •
- A, B - the learned factors
- •
- α - scaling
Example: A rank-8 LoRA on a 1024×1024 matrix trains ~16k numbers instead of ~1M.
LaTeX code
W'=W+\tfrac{\alpha}{r}BA,\quad B\in\mathbb{R}^{d\times r},\ A\in\mathbb{R}^{r\times k}Add or subtract whole fine-tuning “task vectors” to steer a model - vector arithmetic on checkpoints.
- •
- τ - the task vector (fine-tuned minus base)
- •
- λ - how strongly to apply it
Example: λ = −1 “forgets” a fine-tune; λ = +1 re-applies it (Ilharco et al., 2022).
LaTeX code
\theta_{\text{new}}=\theta_{\text{base}}+\lambda\tau,\qquad \tau=\theta_{\text{ft}}-\theta_{\text{base}}Model editing solves for the smallest weight change that makes key k map to value v - a closed-form nudge.
- •
- k, v - the key and desired value
- •
- C - the covariance of keys
- •
- ΔW - a rank-one update
Example: ROME edits single facts like “The Eiffel Tower is in Paris” without retraining (Meng et al., 2022).
LaTeX code
\Delta W=\frac{(v^{*}-Wk^{*})(C^{-1}k^{*})^{\top}}{(C^{-1}k^{*})^{\top}k^{*}}Fine-tuning trains an existing model a bit more on new data - gradients again, just shorter. LoRA (Low-Rank Adaptation) is fine-tuning’s frugal cousin: instead of updating every weight, it learns two small matrices whose product is the change - say 0.5% as many numbers - and adds it on top.
Task arithmetic (Ilharco et al., 2022) treats whole skills as vectors: fine-tune a model on maths, subtract the base, and the difference τ is the “maths direction” in weight space; add it to another model and maths gets stronger. Model merging (TIES and friends) blends several such models into one - no gradients at merge time, but the ingredients were each trained the hard way.
Model editing (ROME, Meng et al. 2022) changes one fact by solving a small equation for the one weight-update that flips it. Activation steering doesn’t touch weights at all - it nudges the model’s inner state at run time. Mechanistic interpretability reads weights and activations to reverse-engineer circuits (like the transformer-circuits work behind the copying-head technique in Exp 3).
And the umbrella the paper cites for the whole field - weight-space learning (survey: arXiv 2603.10090 [VERIFY]) - splits research into understanding weights, representing them, and generating them. WSP lands in the third branch with a twist: its writer was never trained for the job.
Foundational Refreshers (1)