Part 1·Chapter 3 of 13· 9 min read

Cousins of WSP - Who Else Touches the Weights?

Fine-tuning, LoRA, merging, editing, steering, interpretability - and where the new method sits.

Reading Audience LevelRung 2: L2 · Curious adult

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.

Teaching schematic

M9 · Who Writes the Weights?

m9-who-writes
Click a column to sort · ●● = heavy, ●○ = some, ○○ = none
MethodRole
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.

Teaching schematicWho writes the weights? - methods compared
MethodNeeds data?Needs gradients?Needs training compute?Human-readable diff?Writes or reads?
Training (SGD/Adam/Muon)Yes - lotsYesYes - the whole pointNoWrites (slowly)
Fine-tuningYes - task dataYesYesNoWrites
LoRAYes - task dataYesLessSomewhat - two thin matricesWrites
Task arithmeticTwo checkpointsNoNo (post-hoc)Yes - one vectorWrites
Model mergingSeveral modelsNoNo (post-hoc)Roughly - an averageWrites
Model editing (ROME)One fact pairNo - closed formTinyYes - one rank-one updateWrites
Activation steeringA direction (some data)NoTinyYes - one vectorSteers at runtime
Mechanistic interpretabilityThe model itselfNoHuman effortYes - circuitsReads
Tracr compileA formal programNoCompile timeYes - by constructionWrites
Hypernetworks / fast weightsTraining data for the writerYesYes - train the writerNoWrites (learned writer)
Neural network diffusionMany trained netsYesHeavyNoWrites (generated weights)
Weight-space programmingNo - a specNoOne forward pass × nYes - reasoned ΔReads + writes
A teaching summary, not a taxonomy from the literature. “Needs data?” for WSP means: none required by the method itself.
Mathematical Formulations (3)Tripartite System
Paper-reportedLoRA - the familiar low-rank cousin
f-lora

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}
Paper-reportedTask arithmetic
f-taskarith

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}}
Paper-reportedROME-style rank-one edit
f-rome

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)