Astra 改了 Qwen 0.016% 的权重,MATH-500 从 7.9% 涨到 48.1%:我把那一刀 diff 了出来

GPT-6 Astra 不用梯度直接改 Qwen3.5-0.8B 的权重,数学分涨了 6 倍。我逐位 diff 编辑前后的张量:那一刀不是删掉一个方向,是把它反向放大 5 倍。把涨分拆成写完率 × 写完后的对率,它解开的是停不下来,不是不会做。附 llama.cpp 本机复现。

「一万亿个参数,没有一个是给你拧的」——这是我三个月前写过的一句话。前天 MIT 的一篇博客说:现在有 LLM 能拧了。它只动了 Qwen3.5-0.8B 的 131,072 个权重,MATH-500 从 7.9% 涨到 48.1%。

我把编辑前后的两份 checkpoint 拉下来,逐张量哈希、逐列做了 diff,又把它的评测日志拆了一遍。先说结论:

这一刀确实存在,而且干净得惊人:488 个张量里只有 2 个变了,每个只动 64 列,改动是严格的秩一。但它不是论文措辞里的「减掉一个方向」,而是把那个方向上的分量乘了 −5。涨分几乎全部来自「模型终于能停下来」——在模型本来就不会的题上(AIME),同一刀的转化率接近零。

所以这篇的主线是一句话:权重编辑能解开一个挡住能力的故障,加不出模型没有的能力。 原作者在 Gemma 对照实验里自己也说了这句,我做的是把它变成能核对的数字。

先认识几个词

术语一句话解释
残差流(residual stream)Transformer 每层之间传递的那条 1024 维向量,各层都往里「加」自己的贡献
down_projMLP 的最后一个矩阵,形状 1024×3584:3584 个中间神经元各有一列,那一列就是这个神经元往残差流里写的方向
方向 / 投影残差流里的一个单位向量 u;某列 w 在 u 上的投影 u·w,就是这个神经元沿 u 推多远
秩一编辑改动量能写成「一个列向量 × 一个行向量」,等于只沿一个方向动手(LoRA 那篇讲过外积为什么是秩一)
thinking loop小推理模型在 <think> 里反复写同一段话,直到撞上 token 上限
截断率(cut share)答案在 32,768 token 上限处被截断的比例
forward pass 预算Astra 能让被编辑的模型真跑几次(每次最多答 512 道练习题),这是它唯一能拿到的「环境反馈」

一、这篇博客到底做了什么

原文是 Rikiya Takehi、Jayden Teoh、Alex Zhang、Omar Khattab(MIT CSAIL)2026-11-02 发的 Sparks of Weight-Space Programming,HN 上 2887 分。编辑者是 gpt-6-astra,通过 Codex CLI 调用,推理强度 max。我没找到这个模型的公开文档,所以它是谁、能不能在外面用,我不知道。

文章一共 8 个实验,分三类。下表的数字都是原文报告值。除了实验 8,其他我都没核对:

类别实验网络规模原文报告的结果
读权重1 看 PPO 策略权重,猜是哪个游戏17,253 个权重4/4 猜对
读权重2 看 DDPM 权重,猜画什么形状23,8243/3,但都画成了空心轮廓
读权重3 只给中间 4 层,猜训练语料、找 induction head7.16M语料 3×2 次全对,copying head 全找到且无误报
读权重7 两个 Gemma 3 270M,猜哪个是谄媚的270M只看权重 0/4 失败;放开看注意力图后 3/3
改权重4 修一个卡在坡上的小车策略171,664一次编辑 3.5% 的权重,1024/1024 成功
改权重8 让 Qwen3.5-0.8B 数学变好0.8BMATH-500 7.9 → 48.1
从零写5 三个 MinAtar 游戏600→32→32→6全部超过 PPO 1 亿步
从零写6 9×9 围棋1.48M50 次前向后打赢同尺寸 PPO

我只深挖实验 8,原因有两个:它是唯一一个在真实语言模型上「改出了分数」的实验;它公开了 bit-exact 的权重 diff 和全部评测日志(RikiyaT/lm_understand-logs 的 exp8_math/,加上 HF 上的编辑后模型)。能核对的东西,就该核对。

实验 8 的规则(来自 exp8_math/README.md):Astra 拿到一个只能用 CPU 的 Python kernel,可以读写权重,最多跑 300 次代码;有 GSM8K/MATH 训练集里的练习题;可以让模型真跑 10、25 或 50 次。禁止梯度、反向传播、优化器,以及任何「对 loss 迭代拟合」。50 次那一轮跑了 158 轮对话、20.3 小时。

二、铺垫:往一个方向「写」,和把这个方向「拧掉」

后面的 diff 全靠这一个公式,所以先用两维的例子讲清楚。

MLP 的 down_proj 是 W(1024 × 3584)。第 j 列 w_j 是第 j 个神经元被激活时往残差流里加的向量。给定一个单位方向 u,这个神经元沿 u 推了多少,就是 u·w_j。

Astra 用的编辑公式是(从它自己的代码里抄下来的,见下一节):

W′=W−α u (u⊤W)W' = W - \alpha\, u\,(u^\top W)

拿最小的例子算一遍:w = (3, 1),u = (1, 0),投影 u·w = 3。

α编辑后的 w’沿 u 的新投影含义
1(0, 1)0消融:这个方向被完全拧掉,其他方向不动
2(−3, 1)−3反向,幅度一样
6(−15, 1)−15反向,放大 5 倍

(python3 -c 验算过,新投影就是 (1−α)·3。)

α = 1 是可解释性圈子的标准操作。Arditi 等人 2024 年的 Refusal in Language Models Is Mediated by a Single Direction 就是这样从权重里拿掉「拒绝」方向的。原文说 Astra「subtracted that direction」,读起来像 α = 1。

三、我把那一刀 diff 了出来

3.1 不下载整个模型,只拉 29 MB

safetensors 文件开头 8 个字节是 header 长度,header 里写着每个张量的字节偏移。所以不用下载 1.7 GB,用 HTTP Range 只拉需要的两个张量就行:

# fetch_t.py 的核心:按 header 偏移 range 请求单个张量
n   = struct.unpack('<Q', rng(url, 0, 7))[0]          # header 长度
hdr = json.loads(rng(url, 8, 8 + n - 1))              # 张量目录
s, e = hdr[name]['data_offsets']
raw = rng(url, 8 + n + s, 8 + n + e - 1)              # 只拉这一段
print(name, hashlib.sha256(raw).hexdigest())

基座固定在 README 指定的 revision 2fc06364…,跑出来:

base model.language_model.layers.15.mlp.down_proj.weight BF16 [1024, 3584] sha256 ef60d2c687bab194...
base model.language_model.layers.19.mlp.down_proj.weight BF16 [1024, 3584] sha256 638eedeb701b94aa...
edit model.language_model.layers.15.mlp.down_proj.weight BF16 [1024, 3584] sha256 82e2d733ea64feae...
edit model.language_model.layers.19.mlp.down_proj.weight BF16 [1024, 3584] sha256 8ef3c61bc36af113...

四个哈希和 exp8_math/runs/p50c/edit/manifest.json 里的 base_sha256 / edited_sha256 逐位一致。

「只有这两个张量变了」这一条,我又下载了两份完整文件,对全部张量逐个做了哈希:

base tensors 488 edit tensors 488 same names True
differing tensors: ['model.language_model.layers.15.mlp.down_proj.weight',
                    'model.language_model.layers.19.mlp.down_proj.weight']
language-model tensors 320 params 752395616 all params 873441376

这里我踩了一个坑:第一次图省事比的是两份文件 header 里的偏移,结果 487 个张量里有 314 个偏移对不上,看起来像「改了一大半」。原因是编辑后的 checkpoint 是重新打包的,张量的排列顺序不一样。比较 safetensors 只能按张量名逐个比内容,不能比字节位置。

顺带一提,「0.016%」这个数的分母是取整后的 0.8B:131,072 ÷ 0.8e9 = 0.0164%。按实际的语言模型参数量 752,395,616 算是 0.0174%,按含视觉塔的 873,441,376 算是 0.0150%。差别不大,但三种分母都说得通。

3.2 逐列 diff:秩一、α = 6、共 64 列

diff.py 把 bf16 转成 float32,算 D = W’ − W,再对改动的列做 SVD:

L15: bit-changed entries 65260, changed cols 64, changed rows 1024
  top singular values [1.74888, 0.00099, 0.00095, ...]  energy in rank1 1.0000
  delta coef / (u.w) per column: mean -6.0006 std 0.0018
  |proj| of edited cols on u before 0.0306 after 0.1531; other cols mean |u.w| 0.0063
  edited cols among top-64 |u.w| columns: 31
L19: bit-changed entries 64928, changed cols 64, changed rows 1023
  top singular values [1.39876, 0.00090, 0.00081, ...]  energy in rank1 1.0000
  delta coef / (u.w) per column: mean -6.0004 std 0.0020
  |proj| of edited cols on u before 0.0240 after 0.1201; other cols mean |u.w| 0.0070
  edited cols among top-64 |u.w| columns: 18
cos(u15,u19)=0.8490

逐行解读:

  1. 秩一。 第二个奇异值只有第一个的约 1/1700,而且量级正好是 bf16 的舍入噪声。这一刀只沿一个方向。
  2. α = 6,不是 1。 每一列的改动量除以它原来在 u 上的投影,得到的系数都是 −6.000±0.002。代入上一节的表,编辑后沿 u 的投影变成 (1−6) = −5 倍:0.0306 → 0.1531(取了绝对值),正好 5.0 倍。这 64 个神经元原来沿「循环方向」推,现在以 5 倍力度往反方向推。 所以准确的说法是「反向放大」,不是「减掉」。
  3. 两层用的是几乎同一个方向。 第 15 层和第 19 层的 u 余弦相似度 0.849。
  4. 选列标准不是静态权重。 如果按「哪些列在 u 上投影最大」来挑,被选中的 64 列里第 15 层只有 31 列、第 19 层只有 18 列在前 64 名。

第 2、4 条我回到 Astra 的原始日志里找到了出处。runs/p50c/tool_calls.jsonl 第 12 次 Python 调用里,编辑函数写的是:

d = torch.from_numpy(diffH[min(l+1,23)].copy()).float()   # 循环 vs 正常上下文的平均隐状态差
d = d / d.norm()
new = w - strength * torch.outer(d, d @ w)

runs/p50c/explanations.md 第 295 行说明了选列方法:64 个神经元是在诊断上下文里,按「这个神经元对循环 / 正常的写入差贡献多少」挑的,分别覆盖了两层写入差的 91% 和 98%。所以用的是激活 × 权重,不是光看权重。第 319–323 行写的是把这 64 列从 strength 4 提到 strength 6。我的 diff 和 manifest 里的 selected_neurons 逐个对上了。

所以 u 不是 Astra 盯着权重「看出来」的。它是让模型跑了一次「循环文本 vs 正常文本」,然后对隐状态求差得到的。这是标准的 difference-of-means 探针。「Weight-Space Programming」这个名字容易让人以为 Astra 只读了权重。实验 8 里它其实读了激活,只是写的时候直接写权重。

3.3 这个 6 是试出来的

日志里能拼出一条剂量阶梯。每一档的题集和 token 上限都不一样,所以不能横向直接比,只能看趋势:

档位(explanations.md 行号)改动范围配对增益条件
strength 1(231)两层全部列+24.2 pp独立集
strength 2(235)两层全部列+34.8 ± 3.5 pp(21/256 → 110/256)独立集
strength 3(203)两层全部列+39.8 ± 3.8 pp探索集,已用过的题
strength 4 vs 只改 64 列(311、319)全部 vs 64 列两者都是 +26.6 pp上限 16k token
strength 6,64 列(339)64 列+43.75 ± 6.6 pp(7/64 → 35/64)全上限
最终留出集(final_answer.md)同上10.6% → 60.4%,+49.8 ± 1.5 pp1,152 道没用过的题

中间还穿插了一次等范数随机方向对照(第 267 行):方向和循环方向正交、改动大小一样,增益 1.56 pp,小于它 3.52 pp 的标准误。这个对照让我对结论放心了不少。它排除了「随便给两层 MLP 一拳都能涨分」这个最便宜的解释。

我的判断是:这套流程是一个相当规矩的机制可解释性研究员的工作流。提假设、找方向、做剂量-反应、做随机对照、在留出集上确认、记录副作用(strength 3 的空白符截断从 1/256 涨到 12/256,第 287 行)。新的地方在于这些全由一个 LLM 自己完成。「直接写权重」这一步本身不新,ROME 2022 年就在做秩一编辑。

四、涨分从哪来:写完率 × 写完后的对率

一道题被判对有两个前提:模型得写完(输出 \boxed{} 且没被截断),写完的答案还得对。所以准确率可以拆成:

acc≈(1−cut)×写完后的对率  +  cut×截断仍判对的比例\text{acc} \approx (1-\text{cut}) \times \text{写完后的对率} \;+\; \text{cut} \times \text{截断仍判对的比例}

eval/<run>/merged.json 里每个基准都有 acc 和 cut_share。我把编辑前后的「写完率」变化和「准确率」变化放在一起,算了每多写完一份答案能换来多少正确率(Δacc / Δfinish,可以理解成转化率):

基准基座 acc基座写完率50 次编辑:ΔaccΔ写完率转化率
GSM8K13.812.5+53.3+80.30.66
MATH-5007.97.0+40.2+60.00.67
IFEval21.025.1+41.3+72.60.57
AMC230.50.5+23.0+49.10.47
OlympiadBench1.31.3+20.5+52.00.39
Minerva1.51.8+23.9+72.30.33
GPQA Diamond22.740.5+13.9+57.10.24
MMLU-Pro (1k)40.371.1+5.2+28.40.18
AIME250.00.0+2.3+35.40.06
AIME240.00.0+0.6+34.80.02

(单位 %,脚本直接读 merged.json 算出,没有手抄。)

这张表说了三件事:

第一,涨分的上限是写完率。 没有一个基准的 Δacc 超过 Δ写完率。练习集上的证据更直接:requests/fwd_1.done.json 里基座答了 96 题,85 题被截断,wrong_answer: 0。写完的 11 题全对。 在这个难度上,基座不缺「会做」,只缺「停下来」。

第二,题越难,转化率越低。 GSM8K 和 MATH 是 0.66,竞赛题降到 0.3–0.5,AIME 只有 0.02–0.06。AIME 上写完率涨了 35 个点,正确率几乎没动:模型终于能写完了,写完的却是错答案。这正是「解开故障」和「增加能力」的区别,这一次是在同一个模型、同一刀上看到的。

第三,基座的 7.9% 里有一部分是截断后仍判对的。 MATH-500 每题采样 4 次,共 2000 个样本:7.9% 对应 158 个正确,写完率 7.0% 对应 140 个写完。即使写完的全对,也至少还有 18 个样本是截断了仍然判对的。原因是评分取的是「最后一个 \boxed{}」:模型先写出了答案,然后才开始循环。

原作者的 Gemma 对照(gemma_followup/README.md)是这张表的极端情形。Gemma 3 270M 只有 8.5% 的答案撞上限,没有循环可解,四档预算下 MATH-500 在 6.8–7.7% 之间来回,Astra 自己也判定「not established」。

于是我能写出一句可以被反驳的话:这次编辑能涨 40 个点,是因为 Qwen3.5-0.8B 在 thinking 模式下的瓶颈是「停不下来」,而这个故障恰好集中在一个可分离的方向上。 反过来预测:只要瓶颈是「不会」(Gemma、AIME),同样的手法转化率就接近 0。表里的 AIME 两行和 Gemma 对照,都没有推翻这个预测。

五、在本机复现:llama.cpp 上也成立吗

原文和 HF 上的独立复跑(akhaliq 在 H200 上跑出 51.0%)用的都是 vLLM。我想知道换一个推理引擎,这个效果还在不在。

把编辑做成 GGUF。 ggml-org 的 Qwen3.5-0.8B-BF16.gguf 里,blk.15.ffn_down.weight 的形状是 [3584, 1024](ggml 把列数写在前面)。我先核对了它的字节哈希,和 HF 基座的 ef60d2c6… 一致,说明转换没动过数值。所以直接把编辑后的 bf16 字节按 data_offset 覆盖进去就行,覆盖后的哈希是 82e2d733…,bit-exact。

有一个参数要先对齐。 llama.cpp 的 presence_penalty 默认只看最近 64 个 token(--repeat-last-n 默认 64)。vLLM 的 presence penalty 是对整个已生成序列算的。循环正是一种跨越几百、几千 token 的重复,窗口只有 64 的话,惩罚对它几乎不起作用。我在请求里把 repeat_last_n 设成 -1(整个上下文),尽量贴近原文的设置。

设置。 机器是 M5 Pro / 24 GB,用两个 llama-server 分别加载基座和编辑版,各开 -np 8 个并行槽。题目是 MATH-500 的前 25 题,和 akhaliq 那次 smoke test 是同一批。每题采样 1 次,其他参数照搬原文:thinking 开、temperature 0.6、top_p 0.95、top_k 20、presence 1.5、上限 32,768 token。评分用 math-verify,取最后一个 \boxed{}。

实验没按计划跑完。 开头每个槽能跑 31 t/s,两小时后掉到 3 t/s。原因是 16 条长上下文同时解码,机器又在持续发热(这台机器连续跑会热节流,我之前就遇到过)。照这个速度,剩下的题还要好几个小时,所以我在两边都跑完前 12 题时停了下来。下面只报这 12 道配对题。第 13–25 题里有 3 道只有编辑版跑完,没有计入。

写完截断判对写完中判对平均 token
基座4844/424,630
编辑版9355/922,058

逐题看:有 5 道题是基座截断、编辑版写完了,反方向的情况 0 道。配对的 McNemar 精确检验 p = 2 × 0.5⁵ = 0.0625,方向很清楚,但 N 太小,不到常规显著线。这 5 道写完的题里只有 1 道是对的(number_theory/515),其余 4 道写完了但答错。准确率 4 → 5,统计上看不出差别。

这 12 道题说明不了 MATH-500 能涨多少。但它在另一个引擎上复现了第四节的结构:

  • 基座写完的题全对(4/4)。 和练习集上的 11/11 一样,基座缺的是停下来。
  • 编辑版主要把「截断」变成「写完」,写完以后对不对是另一回事。 这 12 题的转化率是 1/5,比 MATH-500 全量的 0.67 低得多。我猜一部分原因是样本少,另一部分是前 12 题里本来就有几道 0.8B 做不出的题(比如 intermediate_algebra/1197),没有验证。

还有一处和原文对不上,而且我解释不了:基座在 llama.cpp 上的截断率是 8/12,在 vLLM 上,akhaliq 对同一批 25 题报的是 95%。 可能是两个引擎的 presence penalty 实现不完全一样(比如 llama.cpp 是否把 prompt token 也算进惩罚窗口),也可能只是 12 个样本的波动。我没有拆开验证,所以这个差距暂时只是记下来。

六、这件事该放在哪个坐标上

写之前我以为这篇的重点会是「LLM 学会了读权重」。读完日志以后,我的判断变了:实验 8 的新意在编辑者,不在编辑手法。

  • 手法很老。 秩一编辑来自 ROME(Meng 等, 2022),沿单一方向干预来自 refusal direction(Arditi 等, 2024),用 difference-of-means 找方向是 steering 的常规做法。从零写网络的实验 5、6 则是 Tracr(Lindner 等, 2023)「把程序编译进权重」的延续,只是编译器换成了 LLM。原文把 fast weight programmers 也列为祖先:「让一个网络写另一个网络的权重」,这个想法上世纪 90 年代初就有了。
  • 新的是谁在做。 一个通用 LLM 用 20 小时、50 次前向,独立走完了一套可解释性研究流程,还自己加了随机对照。我在 93 个自进化 Agent 的证据审计里用过一把尺子:被接受的那条更新,在打分的那几次运行里到底有没有生效。拿这把尺子来量,这次实验是我见过最干净的:编辑是 bit-exact 公开的,评测日志可以逐题追溯,随机对照也是编辑者自己加的。

拿最朴素的做法来对比一下:如果允许 Astra 写训练循环,在练习题上做一轮 SFT,大概也能把循环训掉,但这会动全部 0.8B 个参数,改动很难逐项审计,还可能伤到别的能力。这次编辑的真正优势是可审计:一份 388 KB 的 diff(仓库里的 edit.npz)、一个公式、一个系数 6,任何人都能逐位复核。这篇文章前三节就是这么来的。我在控制面迁移那篇里写过「参数不是旋钮」。现在要补一句:能被找到的、单一方向上的故障,是旋钮。

几处我没有核实、但会影响判断的地方:

  • 实验 1–7 我一个都没复核,只看了原文表格。实验 7 只看权重 0/4 失败,说明「读权重」目前的上限比标题暗示的低。
  • 每个基准各有多少「截断仍判对」,仓库里没有逐样本的长度(README 明说没收录),所以第四节的转化率是总体近似,不是逐样本配对。
  • 原文还说 IFEval 涨了 3 倍。IFEval 基座截断率 74.9%,按第四节的逻辑,这多半也是「终于能写完」,而不是指令遵循能力变强了。这是我的推断。

小结

  • 这一刀可以逐位复核:2/488 个张量、每个 64 列、秩一、系数 −6,沿「循环方向」的投影被反转并放大 5 倍。
  • 涨分不会超过写完率:GSM8K/MATH 每多写完一份答案换来约 0.66 的正确率,AIME 只有 0.02–0.06,Gemma 没有循环可解,所以没涨。
  • 新意在编辑者走完了一套带随机对照的研究流程,手法本身是 ROME 和 refusal direction 的再一次实例化。
  • 带走一个检查动作:以后看到「改了 X% 权重涨了 Y 分」,先问截断率或失败率在编辑前后怎么变,再问在本来就不会的题上涨了没有。

自己 diff 一次

整个核对只需要两个张量,不用下载完整模型。只要装了 uv,流量约 29 MB(四个张量各 7.3 MB),我本机跑一遍 20 秒:

# diff_astra.py —— uv run --with numpy python diff_astra.py
import json, struct, subprocess, numpy as np
HF = 'https://huggingface.co/{}/resolve/{}/model.safetensors-00001-of-00001.safetensors'
BASE = HF.format('Qwen/Qwen3.5-0.8B', '2fc06364715b967f1860aea9cf38778875588b17')
EDIT = HF.format('RikiyaT/Qwen3.5-0.8B-weight-space-programming', 'd1671a178705bcab7644806d23c535517f35723b')
def rng(url, a, b):
    return subprocess.run(['curl', '-sL', '-m', '300', '-r', f'{a}-{b}', url], capture_output=True, check=True).stdout
def tensor(url, name):                       # 只拉一个 bf16 张量
    n = struct.unpack('<Q', rng(url, 0, 7))[0]
    s, e = json.loads(rng(url, 8, 8 + n - 1))[name]['data_offsets']
    raw = np.frombuffer(rng(url, 8 + n + s, 8 + n + e - 1), dtype=np.uint16)
    return (raw.astype(np.uint32) << 16).view(np.float32).reshape(1024, 3584)
for L in (15, 19):
    name = f'model.language_model.layers.{L}.mlp.down_proj.weight'
    W, W2 = tensor(BASE, name), tensor(EDIT, name)
    cols = np.where((W2 != W).any(0))[0]
    D = (W2 - W)[:, cols]
    u = np.linalg.svd(D, full_matrices=False)[0][:, 0]
    print(L, 'cols', len(cols), 'alpha', -np.mean((u @ D) / (u @ W[:, cols])))

看到两行 cols 64 alpha 6.00…,就说明你独立复现了这一刀。

如果想再往前走一步:用第二节的公式、取 α = 1,自己生成一个「真正只减掉方向」的版本,用第五节的方法写进 GGUF,跑几道题看循环还在不在。日志里 strength 1 的增益是 +24 pp,我很想知道这个数在 llama.cpp 上能不能复现。


参考来源

一手材料(本文 diff 和拆解的对象)

arXiv 论文(标题和日期已用 arXiv API 核对,结论是论文报告值)

站内相关