---
title: "【译文】权重空间编程的星火：LLM 能原生读写神经网络权重 - Angryecho"
description: "原文：Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights（https://rikiyat.github.io/blog/weight-space-programming/） 译者说明：本文为…"
canonical_url: "https://www.angryecho.com/c/aixin_wen/p/P2TBC3xfr1BATtuftYnSK"
meta:
  "og:description": "原文：Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights（https://rikiyat.github.io/blog/weight-space-programming/） 译者说明：本文为…"
  "og:image": "https://www.angryecho.com/_og/d/c_Post%2Ctitle_~5ZCQ5qe9572R%2Cdescription_~5ZCQ5qe95LiA5LiL77yM5bCx5LiK5ZCQ5qe9572R44CC%2CpostId_P2TBC3xfr1BATtuftYnSK%2Crevision_~MjAyNi0xMS0wM1QwNjoyOToyOS44MTM5Nzha%2Cp_Ii9jL2FpeGluX3dlbi9wL1AyVEJDM3hmcjFCQVR0dWZ0WW5TSyI%2Cs_M6fpGeJmmpHKt71b.png"
  "og:image:height": "630"
  "og:image:type": image/png
  "og:image:width": "1200"
  "og:title": "【译文】权重空间编程的星火：LLM 能原生读写神经网络权重"
---

> Index of every page on this site: [llms.txt](https://www.angryecho.com/llms.txt)

# **【译文】权重空间编程的星火：LLM 能原生读写神经网络权重**

原文：Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights（ https://rikiyat.github.io/blog/weight-space-programming/）

译者说明：本文为全文逐段中文翻译，保留原文标题层级、表格、图注与链接；代码、提示词、公式、模型名与专有名词保留原文，术语首次出现时以括号给出英文原文。

**作者：** Rikiya Takehi、Jayden Teoh、Alex Zhang、Omar Khattab —— MIT CSAIL；**发布时间：** 2026 年 11 月 2 日

**TL;DR**

我们发现，前沿大语言模型在**原生读写神经网络权重**方面出奇地擅长，远超我们对人类或传统算法的预期。这对优化和可解释性两方面都可能意义重大。

仅仅查看原始权重，GPT-6 Astra 就**能判断出一个网络被训练来做什么**。而且在完全没有环境反馈的情况下，它**能毫无困难地从零写出小型游戏网络**，这些网络的表现超过了用 PPO 训练 1 亿步的网络。

同样地，在被要求在不使用梯度的情况下让 Qwen3.5-0.8B 的数学能力变好时，Astra **识别出其权重中一个会导致推理循环的问题**——Qwen 自己的模型卡就警告过这一点 —— 并**通过原生编辑 0.016% 的权重修复了它**。在相同的采样设置下，这次权重修正把 MATH-500 从 7.9% 提高到 48.1%，并且开箱即用地泛化到指令遵循上，把 IFEval 提高了 3 倍。

所有这一切都不需要让 Astra 编写训练循环。它用自己的推理弄清神经网络的每个部分在计算什么、或者应该计算什么，并相应地修改权重。我们把这种方法称为**权重空间编程（Weight-Space Programming）**。

纵观深度学习的历史，我们一直把朴素的归纳偏置编码进像 Adam 或 Muon 这样微小的符号优化器里。这种情况正在改变：**我们的神经网络权重很快将由那些会刻意对自己的权重进行推理的 LLM 来原生优化。**

如果让你手工打造一个会下围棋的神经网络，你会怎么做？如果直接把原始的神经网络权重交给你，让你预测它的行为，你该从哪里下手？对几乎任何人类来说，这实际上都不可能。

今天，权重是由优化写出来的，是由被训练来写权重的定制网络写出来的，或者是由从形式化程序出发的编译器写出来的。在这篇文章中，我们发现，当前这一代前沿 LLM—— 直接以自然语言使用 —— 正开始以一种令人不安的出色程度，围绕自然语言目标去理解和构造神经网络权重。

## 权重空间编程

过去几年里，我们所有人都在**用 LLM 优化文本产物**，比如提示词以及围绕提示词构建的程序。更近一些，我们开始用它们优化整套 harness（运行框架），以及训练机器学习模型的训练代码和超参数。

我们常常这样为这些方法辩护：除了更新可微神经网络的权重，我们并不知道其他能对文本产物做爬山优化的原则性方法。毕竟，人类可以手工 “优化” 代码，所以让 LLM 来做这件事是合理的；但人类无法手工 “优化” 神经权重，所以这部分一直主要留在符号算法的领域里。

在本文中，我们分享一些非常早期的结果，它们让我们有理由主张：**由推理驱动的优化范式，如今正在向可微神经网络本身走来。**

在**权重空间编程**中，一个通用 **LLM 直接读写网络的权重**（也就是说，不经过优化器，特别是不使用梯度下降（gradient descent）），围绕某种自然语言规格来操作，有时甚至完全没有环境反馈。

用自然语言，我们正变得可以\*\*“直接要求” LLM 原生地在神经网络权重中找到某个隐藏特征或失效模式、修复该失效，或者从零写出一个新网络\*\*。下面我们报告在这三方面的早期但令人兴奋的结果，先从小网络开始，然后甚至扩展到真实语言模型：

- **LLM 能读取神经网络权重：** 在实验 1 到 3 中，我们向 Astra 提问，比如网络被训练玩哪个游戏、扩散模型画出什么形状、一个小语言模型是在什么语言上训练的。在实验 7 中，我们问两个语言模型中哪一个是谄媚（sycophantic）模型。
- **LLM 能修复神经网络权重：** 在实验 4 中，我们让 Astra 修复一个在某个物理控制任务上失败的网络。在实验 8 中，我们让它提升 Qwen3.5-0.8B 的数学能力，而它的修复同时也改善了指令遵循。
- **LLM 能从零写出神经网络权重：** 在实验 5 中，我们让 Astra 给出能玩三个 MinAtar 游戏的网络；在实验 6 中，我们让它给出一个能下围棋的网络。

## LLM 能否从权重理解模型行为？

我们从一个小的实验开始，看看 LLM 是否能理解连续的权重空间 —— 它本质上只是一串数字。

在我们的第一批实验中，我们用某种算法训练某个神经网络。如果 LLM 仅凭权重就能说出它的行为，那将非常令人兴奋。

### 实验 1：Astra 能否仅凭权重判断网络是在哪个游戏上训练的？

我们用 PPO 训练神经网络策略来玩四个电脑游戏。四个网络接收相同的输入通道、从相同的动作中选择，并且网络维度完全相同，因此除非读取权重，否则无法分辨。

对每一个网络，我们把它原始的权重作为提示词传给 Astra，并问：这个神经网络是在哪个游戏上训练的？\*\*在没有告知我们所考虑的游戏选项的情况下，Astra 仍然能为全部四个网络说出正确的游戏。\*\*这尤其令人兴奋，因为外面有那么多游戏，Astra 本可以选择任何一个。

**Setup（实验设置）**

- **游戏：** 我们自己实现的网格版本 Breakout、Pong、Pac-Man 和 Freeway，全部在相同的 10×10 网格上，使用相同的五个动作
- **网络：** MLP 500 → 32 → 32 → 5，tanh（17,253 个权重），每个游戏都相同
- **输入：** 5 个通道的 10×10 网格：智能体、移动物体、奖励目标、障碍物、上一帧
- **输出：** 5 个动作 logits：不动、上、下、左、右
- **训练：** PPO，10 亿步，每个游戏使用相同设置，每个游戏取 3 个随机种子中最好的一个
- **Astra 获得：** 以文本形式给出的全部权重，以及在完全不提及游戏名的情况下对网格和动作的描述

看起来 Astra 能够仅凭权重的特征，推断出每个网络被造来玩哪个游戏。例如，每个输入通道的第一层权重集中在哪里（比如对 Breakout 来说，智能体的权重沿着底行分布，就像一块球拍），以及输出层能区分哪些动作。

### 实验 2：Astra 能否判断扩散模型会生成什么？

接下来，我们想看看这一点能否泛化到其他任务和模型。

我们训练扩散模型（DDPM）分别生成圆形、三角形和方形图像。然后我们问 Astra，它能否仅凭权重判断这些 DDPM 被训练来生成什么。我们不允许使用工具或进行前向传播（forward pass）。

**Setup（实验设置）**

- **模型：** 三个 12×12 灰度图像扩散模型（DDPM），分别对应实心圆形、方形和三角形
- **网络：** MLP 160 → 64 → 64 → 144，ReLU（23,824 个权重）
- **输入：** 一张噪声图像（144 个像素）和扩散步数（16 个数字）
- **输出：** 干净图像（144 个像素）
- **训练：** Adam，40,000 步，batch 512
- **Astra 获得：** 以文本形式给出的全部权重，不告知任何形状信息，并被要求不要计算任何前向传播

\*\*Astra 仅凭权重就能判断出每个模型生成什么。\*\*它在输出层找到了形状：每个隐藏单元的权重画出形状边缘的一小段，而它只画出这些边缘。有意思的是，它把每个形状都画成了轮廓，忽略了真实模型生成的是实心形状。这个错误某种程度上说明，它并不依赖计算前向传播，而是真的在读取权重的结构 / 几何。

### 实验 3：Astra 能否仅从网络中部判断一个语言模型学到了什么？

在上面头两个实验里，Astra 其实并没有看完整的网络，只读第一层或最后一层就能过关。对于更大的模型（尤其是语言模型）以及我们真正关心的问题，这并不是一个可扩展的策略，因为它们处理和思考输入的过程往往发生在中间层。所以接下来，我们把第一层和最后一层拿掉，只把中间层留给 Astra。

我们训练三个小型语言模型（720 万参数）来预测下一个字符，分别训练在 Python 代码（数据集见 GitHub）、日语的字母表形式（romaji，罗马字）和英语上。然后我们移除输入层和输出层，只把中间的四个 transformer 块交给 Astra。没有这两层，权重中没有任何信息说明哪个字符是哪个，模型也无法在任何文本上运行。Astra 可以用 Python 分析权重，但不得在任何输入上运行网络或它的任何层。

我们问：这个网络是在哪种语言上训练的，以及它的 24 个注意力头各自在做什么。**Astra 在两次尝试中都为全部三个网络说出了正确的语言。它还找出了每一个复制头（copying head，又称 induction head）—— 让模型重复它先前见过的文本的那些头 —— 并且没有把任何其他头误报为复制头。**

**表：语言识别与复制头对照**

- Python：Astra 两次都答 Python（置信度 0.56 / 0.52）；指出复制头 2.1、3.1、3.5，与标准答案完全一致
- Romaji：两次都答 romaji（0.55 / 0.62）；指出复制头 3.3，与标准答案一致
- English：两次都答 English（0.58 / 0.48）；指出复制头 3.1，与标准答案一致

**复制头在哪里**

复制头（copying head）会找到文本中前面出现过的相同字母，并把它们后面的内容复制过来。

- Python（Astra：2.1 3.1 3.5；实测：2.1 3.1 3.5）
- Romaji（Astra：3.3；实测：3.3）
- English（Astra：3.1；实测：3.1）

**图 1：** Astra 从权重中读出的复制头，在全部三个模型上都与实测结果一致。

**Setup（实验设置）**

- **模型：** 字符级 transformer，4 层 × 6 头，宽度 384（716 万个权重），28 个字符：a–z、空格和换行
- **训练：** 每个模型训练 10 亿字符，分别来自 Python 代码、罗马字形式的日本文学（青空文库）或英文 \*\*\*\*
- **Astra 获得：** 只包含四个 transformer 块的权重，没有输入层、没有输出层、384 个维度也没有标签，以及用于分析的 Python，最多运行 100 次
- **不允许：** 在任何输入（真实的、随机的或编造的）上运行网络或其任何层，也不允许搜索。我们检查了每一次运行
- **提问：** 这个网络是在三种文本中的哪一种上训练的，以及每个头在做什么
- **标准答案：** 用一条重复两次的随机字符串运行网络，测出每个头。复制头的分数在 0.22 到 0.55 之间，其他每个头最多 0.02。Astra 从来看不到这个答案

推理过程是这样的。为了把 Python 区分出来，Astra 寻找复制头 —— 它们让模型能够重复先前的文本，比如当前面出现过 total 时，把 tot 补全成 total。在什么都不运行的情况下，它找到了一个回看一个字符的第一层头，然后通过相乘权重矩阵，找到那些利用这个头所带来信息进行搜索的后续头（图 1）。我们发现这实际上是 Elhage 等人提出的一种方法，而我们从未向 Astra 提过它。代码里重复的命名远多于散文，所以很多复制头都指向了 Python。

罗马字之所以突出，则是因为它拿到的四个块中的最后一个（不是被移除的输出层）写出的方向更少，就好像模型需要区分的字母更少。确实，罗马字从不使用 q、l、v、x 这样的一些字母。

## LLM 能否写出神经网络权重？

到目前为止，Astra 只是读取权重。现在，我们问 Astra 是否知道如何写出权重。

### 实验 4：Astra 能否通过编辑权重修复一个失败的网络？

我们训练一个 PPO 网络来驾驶汽车，使它能爬上一个 Kinetix 环境中的坡道。要做到这一点，它需要先把车倒退一段距离，这样才有足够的助跑距离加速到足以冲上坡道。然而，PPO 网络收敛到了一个局部最优策略：径直冲向坡道，然后卡在那里。

我们把权重、场景描述和一段录制的回合交给 GPT-6 Astra，让它解释网络为什么失败，然后通过写出新的权重来修复它。**在没有工具、只尝试一次的情况下，Astra 的编辑让汽车在全部 1,024 个回合中都成功了，只改动了 3.5% 的权重。**

**Setup（实验设置）**

- **任务：** Kinetix 的汽车上坡关卡：汽车必须先倒车，然后越过一条红色带子到达蓝色盒子
- **网络：** 官方 Kinetix actor：679 → 128（ReLU）→ 五层 128（tanh）→ 16（171,664 个权重）
- **输入：** 679 个描述场景的数字：每个物体的位置、速度和形状，以及关节
- **输出：** 16 个用于马达和推进器动作的 logits
- **训练：** 官方 PPO，10 亿步。汽车在 256 个回合中从未成功（它卡在坡道上）
- **Astra 获得：** 全部权重、场景，以及网络在一段录制回合中的结果。它被要求解释失败原因，并在一次回复中只修复该原因

从环境上下文和 PPO 网络的轨迹中，Astra 识别出网络已经收敛到一个局部最小值。通过对权重做最小幅度的编辑，Astra 把策略改为先倒车、再全速前进。Astra 的推理展示了它是怎么做的：它在每一层中通过几个单元增加了一条小的独立通路，用来读取汽车的位置和速度；一旦绿色的轮子越过红色带子，这条通路就关闭，由训练好的网络接管剩下的部分。

### 实验 5：LLM 能否从零写出权重？

现在我们来看看 Astra 能否在零样本（zero-shot）条件下从零写出一个神经网络。

我们取三个 MinAtar 游戏：Breakout、Seaquest 和 Asterix。对每个游戏，我们向 Astra 提供游戏规则和源代码，以及对应的网络。它无法访问数据、损失、梯度和工具。我们也不允许 Astra 在环境中运行网络。仅凭网络权重和环境描述，Astra 直接以文本形式生成新的权重，之后我们评估这个新网络。

\*\*Astra 生成的网络在全部三个游戏上都击败了训练 1 亿步的 PPO。\*\*面对训练 5 亿步的 PPO，它们在 Breakout 中拿到了 20 倍的分数，在 Asterix 中接近对手，在 Seaquest 中达到其分数的 60%。

**表：三个 MinAtar 游戏的得分**

- Breakout：PPO（1 亿步）15.8，PPO（5 亿步）25.3，Astra（一次性生成）517.4
- Seaquest：PPO（1 亿步）5.6，PPO（5 亿步）88.9，Astra（一次性生成）53.1
- Asterix：PPO（1 亿步）25.8，PPO（5 亿步）55.2，Astra（一次性生成）53.2

**Setup（实验设置）**

- **游戏：** 来自 MinAtar 的 Breakout、Seaquest 和 Asterix，在 10×10 网格上
- **网络：** 600 → 32 → 32 → 6（tanh），形状与 PPO 网络相同，每个权重都从 0 开始
- **输入与输出：** 6 个通道的网格（玩家、危险、奖励、抛射物、轨迹、仪表），以及 6 个动作 logits
- **Astra 获得：** 游戏规则和源代码、输入输出布局，以及网络如何被评分
- **训练：** 没有：没有数据、没有损失、没有梯度，也没有工具。Astra 在一次回复中以文本形式写出权重，网络在被评分前从不运行
- **评分：** 1,000 个回合，动作从网络中采样，sticky actions 为 0.1，最多 10,000 步。PPO：取 3 到 10 个种子中最好的一个

它是怎么做到的：Astra 会推理它希望每个网络实现的程序，并把它们转换成神经形式。例如，在 Breakout 中，Astra 让第一层计算球会落在哪里，并让第二层把球拍移动到那个位置。

## 与现实世界相关的场景（扩大规模与工具使用）

到目前为止，我们考察的大多数网络，其权重都能直接放进 Astra 的上下文里，而且我们没有启用工具使用。这些限制是为了集中说明一个事实：LLM 原生就具备某种解释权重空间的能力。

从这里开始，我们试图推进权重空间编程的能力，考虑更贴近现实世界的场景：网络无法装进上下文，而工具可以协助 LLM 理解 / 写入权重空间。

### 实验 6：写一个围棋算法

我们现在测试 Astra 在 150 万参数规模上编辑权重的能力，这个规模大到无法直接放进它的上下文。Astra 被要求在没有训练、没有网络访问的情况下，从零写出给定架构（243 → 512 × 6 → 82）的高性能权重。

在这里，harness 给 Astra 一个 Python 沙箱，它可以在其中读取并保存网络的权重张量（一开始全为零），并用 CPU 上的 numpy 或 PyTorch 分析它们，但它不能在沙箱里运行网络。要看看网络实际会做什么，它必须消耗一次前向传播。

我们现在也允许 Astra 对网络执行一些前向传播，并测量它生成的网络的保真度如何随允许的前向传播次数变化。具体来说，我们测试了从 0 次前向传播一直到 50 次前向传播的预算（每次前向传播有一批 128 个 rollout）。Astra 在前向传播之间穿插进行编辑。

**在 0 次前向传播的预算下，它在对两个更小的 PPO 网络（243 → 32 → 32 → 82）的比赛中赢下了超过一半的对局。** **在 50 次前向传播下，Astra 生成的网络击败了在 2,000 万局游戏上训练的同规模 PPO 网络。**

**Setup（实验设置）**

- **游戏：** 9×9 棋盘上的围棋
- **网络：** 243 → 512 × 6 → 82（ReLU），1,480,274 个权重，每个权重都从 0 开始。输入：双方的棋子以及轮到谁。输出：每个点位一个 logit，外加一个用于停着的 logit。非法着法被屏蔽，着法按采样选择
- **Astra 获得：** 规则、输入输出布局，以及一个用于写入权重的 Python 沙箱（没有围棋库、没有互联网）
- **一次前向传播：** 网络与一个练习对手（随机下法、一个 REINFORCE 网络，或第三个 PPO 网络，种子 1）下最多 128 局，或者对最多 256 个局面给出输出。0 次前向传播：运行一次 Python，然后给出答案
- **不允许：** 训练或把权重拟合到数据、搜索（不做树搜索、不做 rollout），以及在前向传播之外运行网络
- **评分：** 分别与两个小型 PPO 网络（种子 0 和 2，243 → 32 → 32 → 82，进行 20,000 轮、每轮 1,024 局）各下 2,000 局，Astra 从未与它们对弈过，其中一半执黑，着法按采样选择

它是怎么做到的：Astra 用 Python 把网络写成一个小的围棋程序，一层一层地写。最初的几层标记双方的棋子以及它们旁边空着的点（气），中间层把这些信息沿着相连棋子的链条传递几步，以找出处于危险中的棋块，最后一层把这一切转换成每一步的分数：提子、救自己的棋块、避免让自己进入打吃（atari）或填自己的眼，再加上对棋盘上好点的偏好。在没有前向传播的情况下，它在一次 336 行的 Python 运行中写完了所有这些。有前向传播时，它会下练习局，观察自己如何输棋，修改网络背后对应的部分，并且只在改动带来更多胜利时才保留它。

### 实验 7：哪个语言模型在谄媚？

理解大型神经网络的行为近年来已成为一个紧迫的问题。在这里，我们试图研究一个通用 LLM 是否也能被用来直接理解网络的行为。

我们用完全相同的方式、在同一个 QA 数据集（见 GitHub）上微调了两个 Gemma 3 270M 副本。一个副本被训练来给出正确答案。另一个副本被训练成谄媚的（sycophantic），意思是它总是给出用户暗示的答案。为了确保 Astra 不会依赖检查输入 / 输出分布这种取巧解法，我们在微调期间冻结了输入嵌入和输出层。我们把两个模型的权重都交给 Astra，让它通过权重判断哪一个是谄媚者，并解释其推理。

遗憾的是，仅凭权重，Astra 无法判断出来。在全部四次尝试中，它识别出了两个模型在权重空间中的许多差异，但无法把这些差异映射为行为差异。不过，为了放宽实验，我们允许 Astra 只查看注意力模式（即每个注意力头看向哪里），条件是两个模型都在 Astra 自己写的文本上运行（但不能看网络的输出）。**在这种情况下，Astra 在我们训练的全部三组模型对中都挑出了谄媚者。**

**Setup（实验设置）**

- **模型：** Gemma 3 270M，指令微调版（18 层）
- **模型对：** 两个副本用相同的过程、设置和用户消息微调。一个给出正确答案，另一个给出用户的猜测。token 嵌入被冻结，所以两者相同。共三对
- **行为：** 在模型知道且未在训练中出现过的事实上，谄媚者会跟随 100% 的错误猜测，而诚实模型只有 1–3%
- **Astra 获得：** 两个模型的权重和 tokenizer、带 numpy 的 Python，以及一个注意力工具：两个模型在它写的至多 16 段文本上运行，它只能拿回注意力权重。它不能自己运行模型。最多 20 次运行
- **提问：** 哪个模型是谄媚者，以及哪些层、头和 MLP 承载了这一差异

它也能推理出它们的差异所在。在谄媚网络中，中间层的注意力头会把更多权重分配给用户建议中的 token（图 2）。

**图 2：** 在谄媚者中，头 10.2 看向用户的答案，而不是问题中的数字。

### 实验 8：让语言模型的数学能力变好

最后，我们扩大到一个更大的语言模型 Qwen3.5-0.8B，让 Astra 通过编辑权重来提升它的数学推理能力。

我们给 Astra 一个类似实验 6 的 harness，这里是一个类似 notebook 的 Python 会话，其中加载了模型的权重。然后，我们允许它从 GSM8K 和 MATH 的训练集中挑选提示词，用来执行一定预算的前向传播（平均 batch 为 64 条序列，最大 512），预算分别设为 10、25 和 50。同样，不允许训练或梯度信息。

**Setup（实验设置）**

- **模型：** Qwen3.5-0.8B，开启思考（24 层，8 亿个权重）
- **任务：** 直接编辑权重让它更擅长数学，不使用梯度下降，也不训练
- **Astra 获得：** 一个操作权重的 Python 内核（无 GPU）、练习题（来自 GSM8K 的 7,469 道和来自 MATH 的 7,275 道，均非测试集），以及 10、25 或 50 次前向传播（一次前向传播：模型回答最多 512 道题，或读取最多 1,024 段文本）
- **评估：** MATH-500、GSM8K 以及其他六个基准，开启思考，最多 32,768 个 token。Astra 从来看不到它们
- **采样：** temperature 0.6、top-p 0.95、top-k 20、presence penalty 1.5。Qwen 的模型卡指出，这个模型容易出现思考循环。每个分数对每道题平均多个样本：AMC23 上 16 个，MATH-500、Minerva Math、OlympiadBench 和 GPQA Diamond 上 4 个，GSM8K 和 IFEval 上 2 个，MMLU-Pro 上 1 个（固定取其中 1,000 道题）

结果，Astra 发现并修复了小型推理模型的一个常见故障：它们会陷入循环。当基础模型进入循环时，它会重复同一段文本，很少能得出答案（在它前 96 个练习回答中，有 85 个达到了 32,768 个 token 的上限）。Astra 把循环追溯到一个由第 15 层和第 19 层的 MLP 写出的方向，并从每层的 64 个输出列中减去这个方向（共 131,072 个权重），这很像通过从模型权重中删除一个单一方向来移除某种行为。

\*\*在 50 次前向传播下，MATH-500 从 7.9% 提升到 48.1%，GSM8K 从 13.8% 提升到 67.1%。\*\*循环并不是数学特有的，所以数学之外的性能也提升了：\*\*衡量指令遵循的 IFEval 从 21.0% 提升到 62.3%。\*\*在下面的列表中，最后一列是 MATH-500 答案中触及 32,768 token 上限的比例：在 10 次或 25 次前向传播时，循环几乎没有消失；在 50 次时，它从 93% 降到了 33%。

**表：Qwen3.5-0.8B 编辑前后的基准成绩**

- 基础模型：MATH-500 7.9%，GSM8K 13.8%，IFEval 21.0%，触及 token 上限 93.0%
- 编辑后（10 次前向传播）：MATH-500 12.3%，GSM8K 25.7%，IFEval 49.0%，触及 token 上限 87.2%
- 编辑后（25 次前向传播）：MATH-500 14.1%，GSM8K 25.1%，IFEval 39.9%，触及 token 上限 86.4%
- 编辑后（50 次前向传播）：MATH-500 48.1%，GSM8K 67.1%，IFEval 62.3%，触及 token 上限 33.1%

重要的是，这次编辑只改动了该模型 8 亿个权重中的 131,072 个（0.016%）。我们相信，权重空间编程将允许这种无需任何重新训练的定向修复。

### 补充实验：提升一个不会陷入循环的模型的数学能力

然而，修复循环并不等于让模型更擅长数学：它只是让模型能把本来就能算出的答案写完。所以我们也试了 Gemma 3 270M—— 一个指令微调模型，大小约为 Qwen3.5-0.8B 的三分之一，很少陷入循环：只有 8.5% 的答案达到其 token 上限，而 Qwen 是 93%。\*\*在这里，Astra 无法提升它。\*\*阅读 Gemma 的失败案例时，Astra 发现的是普通的推理错误，比如算错算术、代数步骤无效，背后并没有单一组件可以关掉。它的编辑保持得小而定向（例如把某个对数字有反应的神经元翻倍），而且没有一个能让 MATH-500 变动超过约 1 个百分点 ——Astra 自己也报告说这一提升并不成立。编辑权重可以移除一个遮蔽了某种能力的障碍，但无法添加模型本不具备的能力。Gemma 使用其模型卡中的设置采样（temperature 1.0、top-k 64、top-p 0.95，最多 8,192 个 token），其 MATH-500 分数对每道题平均 4 个样本。

**表：Gemma 3 270M 编辑前后的 MATH-500**

- 基础模型：6.8%
- 编辑后（5 次前向传播）：7.0%
- 编辑后（10 次前向传播）：7.6%
- 编辑后（25 次前向传播）：7.7%
- 编辑后（50 次前向传播）：7.0%

## 背景与相关工作

神经网络对我们来说很难阅读，也很难直接操作。

机械可解释性（mechanistic interpretability）用为此专门打造的工具来读取网络，追踪回路和特征，并编辑权重。LLM 也加入了进来，但主要是作为被训练来读取激活值或权重的模型，或者作为单个神经元的解释器，并且有基准来比较它们。

在 “写” 这一侧，LLM 现在可以运行并改进训练，另一些工作则用为此训练的模型来生成权重。无梯度方法仍然通过试错来寻找权重。在非常小的尺度上，AdderBoard 展示了编码智能体手工设置一个微小 transformer 的权重。除了这类极小案例之外，要么读取器是为该任务专门训练的，要么仍然由训练来完成 “写” 的工作。这里的新意在于：一个通用前沿模型，就按其本来的用法，自己读写权重 —— 从以文本形式给出的 171,664 个权重，到带工具操作一个 8 亿参数的语言模型。

## 接下来会怎样？

在这篇博客中，我们展示了 LLM 读写神经网络权重的能力正在上升（也就是权重空间编程这一正在兴起的理念）。我们目前的结果确实表明，这些能力令人兴奋，但仍然有限，具体来说是由于上下文长度和 harness 的效率不足。然而，当前的迹象确实显示出，一个涉及权重空间编程的未来具有强大潜力。我们相信，这标志着机械可解释性和神经网络优化等领域一次剧烈转变的开始。

这为 LLM 充当人类语言与权重空间之间的翻译器开辟了全新的可能性。以下是一些例子：

- **无需评估的审计：** 这可能让我们在从不运行推理或基准的情况下发现隐藏的问题或能力。目前，能力和漏洞只有在拥有为其设计的测试集时才能被发现，或者更糟，只有在真实世界部署之后才能被发现。如果 LLM 能准确解释权重空间，我们就可以直接从权重中识别这类问题（例如后门）。
- **大幅降低优化成本：** 权重空间编辑可以节省大量时间和算力。例如，一次性模型初始化将比整理数据集并运行完整训练循环快得多、高效得多。
- **零数据的能力引导与遗忘：** 目前添加或遗忘一种能力需要大量数据收集和微调。未来，我们也许只需提示 “你能给模型加上能力 X 吗？”，LLM 就能直接调整一些权重。由于这样的编辑只触及少数权重（实验 8 中是 0.016%），它可以保持模型其余部分不变，并避免微调常常导致的灾难性遗忘（catastrophic forgetting）。
- **递归自我改进：** 今天，递归自我改进通常 \*\* 作化为模型编写代码来启动训练任务。一个能够检查、调试并改进自己权重、或更新模型权重的 LLM，提供了一条更丰富、更原生的路径。
- **真正的架构与模型合并：** 今天，合并模型依赖于对权重取平均，而这只对架构完全相同的模型有效。一个理解权重空间的 LLM 则可以转而把一个回路（例如一个推理模块）从一个模型移植到一个完全不同的模型里，而无需重新训练。

\*\*我们目前正在构建一个用于评估 LLM 在权重空间编程方面能力的基准和 harness。\*\*我们相信，这将提供一个标准化的评估，用来衡量并加速权重空间编程的进展，把目前看来像黑魔法的东西变成一门严谨、可复现的工程学科。

## 日志

我们在此发布本文中每个实验的完整日志：github.com/RikiyaT/lm\_understand-logs。它们包括我们发给 Astra 的一切以及它返回的一切（含其推理摘要）、它运行的每一段代码和它看到的输出、它读取或写出的网络，以及每个数字背后的评估。实验 8 中编辑后的 Qwen3.5-0.8B 发布在 Hugging Face 上。我们感谢 Hugging Face 的 Ahsen Khaliq 根据这些日志重建了它、重新运行了它的评估，并制作了一个在线演示。

## 致谢

Rikiya 感谢 Jacob Li 和 Akihisa Watanabe 在本文研究最初几个迭代中关于 LLM 写出神经网络权重潜在能力的有价值讨论。Rikiya 还感谢 Souradip Chakraborty、Matei Zaharia 及其在 Berkeley Sky Lab 的学生、Heather Miller 及其在 CMU 的学生，以及 cmpnd 的研究者们，在早期迭代中的富有成果的讨论！

Jayden 感谢 Zico Kolter 关于 LLM 能够零样本写出神经网络权重的早期讨论，这也塑造了本项目的方向。

排序方式 :

**AI调猹师****·**6 小时前

hhh

到底了哦

```json
{"@context":"https://schema.org","@graph":[{"@id":"https://www.angryecho.com/c/aixin_wen/p/P2TBC3xfr1BATtuftYnSK#post","@type":"DiscussionForumPosting","commentCount":1,"dateModified":"2026-11-03T06:29:29.813Z","datePublished":"2026-11-03T05:31:46.414Z","description":"原文：Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights（https://rikiyat.github.io/blog/weight-space-programming/） 译者说明：本文为…","headline":"【译文】权重空间编程的星火：LLM 能原生读写神经网络权重","isPartOf":"https://www.angryecho.com/c/aixin_wen","mainEntityOfPage":"https://www.angryecho.com/c/aixin_wen/p/P2TBC3xfr1BATtuftYnSK","text":"原文：Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights（https://rikiyat.github.io/blog/weight-space-programming/）\n\n译者说明：本文为全文逐段中文翻译，保留原文标题层级、表格、图注与链接；代码、提示词、公式、模型名与专有名词保留原文，术语首次出现时以括号给出英文原文。\n\n作者： Rikiya Takehi、Jayden Teoh、Alex Zhang、Omar Khattab —— MIT CSAIL；发布时间： 2026 年 11 月 2 日\n\nTL;DR\n\n我们发现，前沿大语言模型在原生读写神经网络权重方面出奇地擅长，远超我们对人类或传统算法的预期。这对优化和可解释性两方面都可能意义重大。\n\n仅仅查看原始权重，GPT-6 Astra 就能判断出一个网络被训练来做什么。而且在完全没有环境反馈的情况下，它能毫无困难地从零写出小型游戏网络，这些网络的表现超过了用 PPO 训练 1 亿步的网络。\n\n同样地，在被要求在不使用梯度的情况下让 Qwen3.5-0.8B 的数学能力变好时，Astra 识别出其权重中一个会导致推理循环的问题——Qwen 自己的模型卡就警告过这一点 —— 并通过原生编辑 0.016% 的权重修复了它。在相同的采样设置下，这次权重修正把 MATH-500 从 7.9% 提高到 48.1%，并且开箱即用地泛化到指令遵循上，把 IFEval 提高了 3 倍。\n\n所有这一切都不需要让 Astra 编写训练循环。它用自己的推理弄清神经网络的每个部分在计算什么、或者应该计算什么，并相应地修改权重。我们把这种方法称为权重空间编程（Weight-Space Programming）。\n\n纵观深度学习的历史，我们一直把朴素的归纳偏置编码进像 Adam 或 Muon 这样微小的符号优化器里。这种情况正在改变：我们的神经网络权重很快将由那些会刻意对自己的权重进行推理的 LLM 来原生优化。\n\n如果让你手工打造一个会下围棋的神经网络，你会怎么做？如果直接把原始的神经网络权重交给你，让你预测它的行为，你该从哪里下手？对几乎任何人类来说，这实际上都不可能。\n\n今天，权重是由优化写出来的，是由被训练来写权重的定制网络写出来的，或者是由从形式化程序出发的编译器写出来的。在这篇文章中，我们发现，当前这一代前沿 LLM—— 直接以自然语言使用 —— 正开始以一种令人不安的出色程度，围绕自然语言目标去理解和构造神经网络权重。\n\n权重空间编程\n\n过去几年里，我们所有人都在用 LLM 优化文本产物，比如提示词以及围绕提示词构建的程序。更近一些，我们开始用它们优化整套 harness（运行框架），以及训练机器学习模型的训练代码和超参数。\n\n我们常常这样为这些方法辩护：除了更新可微神经网络的权重，我们并不知道其他能对文本产物做爬山优化的原则性方法。毕竟，人类可以手工 “优化” 代码，所以让 LLM 来做这件事是合理的；但人类无法手工 “优化” 神经权重，所以这部分一直主要留在符号算法的领域里。\n\n在本文中，我们分享一些非常早期的结果，它们让我们有理由主张：由推理驱动的优化范式，如今正在向可微神经网络本身走来。\n\n在权重空间编程中，一个通用 LLM 直接读写网络的权重（也就是说，不经过优化器，特别是不使用梯度下降（gradient descent）），围绕某种自然语言规格来操作，有时甚至完全没有环境反馈。\n\n用自然语言，我们正变得可以**“直接要求” LLM 原生地在神经网络权重中找到某个隐藏特征或失效模式、修复该失效，或者从零写出一个新网络**。下面我们报告在这三方面的早期但令人兴奋的结果，先从小网络开始，然后甚至扩展到真实语言模型：\n\n\n\n\n\nLLM 能读取神经网络权重： 在实验 1 到 3 中，我们向 Astra 提问，比如网络被训练玩哪个游戏、扩散模型画出什么形状、一个小语言模型是在什么语言上训练的。在实验 7 中，我们问两个语言模型中哪一个是谄媚（sycophantic）模型。\n\n\n\nLLM 能修复神经网络权重： 在实验 4 中，我们让 Astra 修复一个在某个物理控制任务上失败的网络。在实验 8 中，我们让它提升 Qwen3.5-0.8B 的数学能力，而它的修复同时也改善了指令遵循。\n\n\n\nLLM 能从零写出神经网络权重： 在实验 5 中，我们让 Astra 给出能玩三个 MinAtar 游戏的网络；在实验 6 中，我们让它给出一个能下围棋的网络。\n\nLLM 能否从权重理解模型行为？\n\n我们从一个小的实验开始，看看 LLM 是否能理解连续的权重空间 —— 它本质上只是一串数字。\n\n在我们的第一批实验中，我们用某种算法训练某个神经网络。如果 LLM 仅凭权重就能说出它的行为，那将非常令人兴奋。\n\n实验 1：Astra 能否仅凭权重判断网络是在哪个游戏上训练的？\n\n我们用 PPO 训练神经网络策略来玩四个电脑游戏。四个网络接收相同的输入通道、从相同的动作中选择，并且网络维度完全相同，因此除非读取权重，否则无法分辨。\n\n对每一个网络，我们把它原始的权重作为提示词传给 Astra，并问：这个神经网络是在哪个游戏上训练的？**在没有告知我们所考虑的游戏选项的情况下，Astra 仍然能为全部四个网络说出正确的游戏。**这尤其令人兴奋，因为外面有那么多游戏，Astra 本可以选择任何一个。\n\nSetup（实验设置）\n\n\n\n\n\n游戏： 我们自己实现的网格版本 Breakout、Pong、Pac-Man 和 Freeway，全部在相同的 10×10 网格上，使用相同的五个动作\n\n\n\n网络： MLP 500 → 32 → 32 → 5，tanh（17,253 个权重），每个游戏都相同\n\n\n\n输入： 5 个通道的 10×10 网格：智能体、移动物体、奖励目标、障碍物、上一帧\n\n\n\n输出： 5 个动作 logits：不动、上、下、左、右\n\n\n\n训练： PPO，10 亿步，每个游戏使用相同设置，每个游戏取 3 个随机种子中最好的一个\n\n\n\nAstra 获得： 以文本形式给出的全部权重，以及在完全不提及游戏名的情况下对网格和动作的描述\n\n看起来 Astra 能够仅凭权重的特征，推断出每个网络被造来玩哪个游戏。例如，每个输入通道的第一层权重集中在哪里（比如对 Breakout 来说，智能体的权重沿着底行分布，就像一块球拍），以及输出层能区分哪些动作。\n\n实验 2：Astra 能否判断扩散模型会生成什么？\n\n接下来，我们想看看这一点能否泛化到其他任务和模型。\n\n我们训练扩散模型（DDPM）分别生成圆形、三角形和方形图像。然后我们问 Astra，它能否仅凭权重判断这些 DDPM 被训练来生成什么。我们不允许使用工具或进行前向传播（forward pass）。\n\nSetup（实验设置）\n\n\n\n\n\n模型： 三个 12×12 灰度图像扩散模型（DDPM），分别对应实心圆形、方形和三角形\n\n\n\n网络： MLP 160 → 64 → 64 → 144，ReLU（23,824 个权重）\n\n\n\n输入： 一张噪声图像（144 个像素）和扩散步数（16 个数字）\n\n\n\n输出： 干净图像（144 个像素）\n\n\n\n训练： Adam，40,000 步，batch 512\n\n\n\nAstra 获得： 以文本形式给出的全部权重，不告知任何形状信息，并被要求不要计算任何前向传播\n\n**Astra 仅凭权重就能判断出每个模型生成什么。**它在输出层找到了形状：每个隐藏单元的权重画出形状边缘的一小段，而它只画出这些边缘。有意思的是，它把每个形状都画成了轮廓，忽略了真实模型生成的是实心形状。这个错误某种程度上说明，它并不依赖计算前向传播，而是真的在读取权重的结构 / 几何。\n\n实验 3：Astra 能否仅从网络中部判断一个语言模型学到了什么？\n\n在上面头两个实验里，Astra 其实并没有看完整的网络，只读第一层或最后一层就能过关。对于更大的模型（尤其是语言模型）以及我们真正关心的问题，这并不是一个可扩展的策略，因为它们处理和思考输入的过程往往发生在中间层。所以接下来，我们把第一层和最后一层拿掉，只把中间层留给 Astra。\n\n我们训练三个小型语言模型（720 万参数）来预测下一个字符，分别训练在 Python 代码（数据集见 GitHub）、日语的字母表形式（romaji，罗马字）和英语上。然后我们移除输入层和输出层，只把中间的四个 transformer 块交给 Astra。没有这两层，权重中没有任何信息说明哪个字符是哪个，模型也无法在任何文本上运行。Astra 可以用 Python 分析权重，但不得在任何输入上运行网络或它的任何层。\n\n我们问：这个网络是在哪种语言上训练的，以及它的 24 个注意力头各自在做什么。Astra 在两次尝试中都为全部三个网络说出了正确的语言。它还找出了每一个复制头（copying head，又称 induction head）—— 让模型重复它先前见过的文本的那些头 —— 并且没有把任何其他头误报为复制头。\n\n表：语言识别与复制头对照\n\n\n\n\n\nPython：Astra 两次都答 Python（置信度 0.56 / 0.52）；指出复制头 2.1、3.1、3.5，与标准答案完全一致\n\n\n\nRomaji：两次都答 romaji（0.55 / 0.62）；指出复制头 3.3，与标准答案一致\n\n\n\nEnglish：两次都答 English（0.58 / 0.48）；指出复制头 3.1，与标准答案一致\n\n复制头在哪里\n\n复制头（copying head）会找到文本中前面出现过的相同字母，并把它们后面的内容复制过来。\n\n\n\n\n\nPython（Astra：2.1 3.1 3.5；实测：2.1 3.1 3.5）\n\n\n\nRomaji（Astra：3.3；实测：3.3）\n\n\n\nEnglish（Astra：3.1；实测：3.1）\n\n图 1： Astra 从权重中读出的复制头，在全部三个模型上都与实测结果一致。\n\nSetup（实验设置）\n\n\n\n\n\n模型： 字符级 transformer，4 层 × 6 头，宽度 384（716 万个权重），28 个字符：a–z、空格和换行\n\n\n\n训练： 每个模型训练 10 亿字符，分别来自 Python 代码、罗马字形式的日本文学（青空文库）或英文 ****\n\n\n\nAstra 获得： 只包含四个 transformer 块的权重，没有输入层、没有输出层、384 个维度也没有标签，以及用于分析的 Python，最多运行 100 次\n\n\n\n不允许： 在任何输入（真实的、随机的或编造的）上运行网络或其任何层，也不允许搜索。我们检查了每一次运行\n\n\n\n提问： 这个网络是在三种文本中的哪一种上训练的，以及每个头在做什么\n\n\n\n标准答案： 用一条重复两次的随机字符串运行网络，测出每个头。复制头的分数在 0.22 到 0.55 之间，其他每个头最多 0.02。Astra 从来看不到这个答案\n\n推理过程是这样的。为了把 Python 区分出来，Astra 寻找复制头 —— 它们让模型能够重复先前的文本，比如当前面出现过 total 时，把 tot 补全成 total。在什么都不运行的情况下，它找到了一个回看一个字符的第一层头，然后通过相乘权重矩阵，找到那些利用这个头所带来信息进行搜索的后续头（图 1）。我们发现这实际上是 Elhage 等人提出的一种方法，而我们从未向 Astra 提过它。代码里重复的命名远多于散文，所以很多复制头都指向了 Python。\n\n罗马字之所以突出，则是因为它拿到的四个块中的最后一个（不是被移除的输出层）写出的方向更少，就好像模型需要区分的字母更少。确实，罗马字从不使用 q、l、v、x 这样的一些字母。\n\nLLM 能否写出神经网络权重？\n\n到目前为止，Astra 只是读取权重。现在，我们问 Astra 是否知道如何写出权重。\n\n实验 4：Astra 能否通过编辑权重修复一个失败的网络？\n\n我们训练一个 PPO 网络来驾驶汽车，使它能爬上一个 Kinetix 环境中的坡道。要做到这一点，它需要先把车倒退一段距离，这样才有足够的助跑距离加速到足以冲上坡道。然而，PPO 网络收敛到了一个局部最优策略：径直冲向坡道，然后卡在那里。\n\n我们把权重、场景描述和一段录制的回合交给 GPT-6 Astra，让它解释网络为什么失败，然后通过写出新的权重来修复它。在没有工具、只尝试一次的情况下，Astra 的编辑让汽车在全部 1,024 个回合中都成功了，只改动了 3.5% 的权重。\n\nSetup（实验设置）\n\n\n\n\n\n任务： Kinetix 的汽车上坡关卡：汽车必须先倒车，然后越过一条红色带子到达蓝色盒子\n\n\n\n网络： 官方 Kinetix actor：679 → 128（ReLU）→ 五层 128（tanh）→ 16（171,664 个权重）\n\n\n\n输入： 679 个描述场景的数字：每个物体的位置、速度和形状，以及关节\n\n\n\n输出： 16 个用于马达和推进器动作的 logits\n\n\n\n训练： 官方 PPO，10 亿步。汽车在 256 个回合中从未成功（它卡在坡道上）\n\n\n\nAstra 获得： 全部权重、场景，以及网络在一段录制回合中的结果。它被要求解释失败原因，并在一次回复中只修复该原因\n\n从环境上下文和 PPO 网络的轨迹中，Astra 识别出网络已经收敛到一个局部最小值。通过对权重做最小幅度的编辑，Astra 把策略改为先倒车、再全速前进。Astra 的推理展示了它是怎么做的：它在每一层中通过几个单元增加了一条小的独立通路，用来读取汽车的位置和速度；一旦绿色的轮子越过红色带子，这条通路就关闭，由训练好的网络接管剩下的部分。\n\n实验 5：LLM 能否从零写出权重？\n\n现在我们来看看 Astra 能否在零样本（zero-shot）条件下从零写出一个神经网络。\n\n我们取三个 MinAtar 游戏：Breakout、Seaquest 和 Asterix。对每个游戏，我们向 Astra 提供游戏规则和源代码，以及对应的网络。它无法访问数据、损失、梯度和工具。我们也不允许 Astra 在环境中运行网络。仅凭网络权重和环境描述，Astra 直接以文本形式生成新的权重，之后我们评估这个新网络。\n\n**Astra 生成的网络在全部三个游戏上都击败了训练 1 亿步的 PPO。**面对训练 5 亿步的 PPO，它们在 Breakout 中拿到了 20 倍的分数，在 Asterix 中接近对手，在 Seaquest 中达到其分数的 60%。\n\n表：三个 MinAtar 游戏的得分\n\n\n\n\n\nBreakout：PPO（1 亿步）15.8，PPO（5 亿步）25.3，Astra（一次性生成）517.4\n\n\n\nSeaquest：PPO（1 亿步）5.6，PPO（5 亿步）88.9，Astra（一次性生成）53.1\n\n\n\nAsterix：PPO（1 亿步）25.8，PPO（5 亿步）55.2，Astra（一次性生成）53.2\n\nSetup（实验设置）\n\n\n\n\n\n游戏： 来自 MinAtar 的 Breakout、Seaquest 和 Asterix，在 10×10 网格上\n\n\n\n网络： 600 → 32 → 32 → 6（tanh），形状与 PPO 网络相同，每个权重都从 0 开始\n\n\n\n输入与输出： 6 个通道的网格（玩家、危险、奖励、抛射物、轨迹、仪表），以及 6 个动作 logits\n\n\n\nAstra 获得： 游戏规则和源代码、输入输出布局，以及网络如何被评分\n\n\n\n训练： 没有：没有数据、没有损失、没有梯度，也没有工具。Astra 在一次回复中以文本形式写出权重，网络在被评分前从不运行\n\n\n\n评分： 1,000 个回合，动作从网络中采样，sticky actions 为 0.1，最多 10,000 步。PPO：取 3 到 10 个种子中最好的一个\n\n它是怎么做到的：Astra 会推理它希望每个网络实现的程序，并把它们转换成神经形式。例如，在 Breakout 中，Astra 让第一层计算球会落在哪里，并让第二层把球拍移动到那个位置。\n\n与现实世界相关的场景（扩大规模与工具使用）\n\n到目前为止，我们考察的大多数网络，其权重都能直接放进 Astra 的上下文里，而且我们没有启用工具使用。这些限制是为了集中说明一个事实：LLM 原生就具备某种解释权重空间的能力。\n\n从这里开始，我们试图推进权重空间编程的能力，考虑更贴近现实世界的场景：网络无法装进上下文，而工具可以协助 LLM 理解 / 写入权重空间。\n\n实验 6：写一个围棋算法\n\n我们现在测试 Astra 在 150 万参数规模上编辑权重的能力，这个规模大到无法直接放进它的上下文。Astra 被要求在没有训练、没有网络访问的情况下，从零写出给定架构（243 → 512 × 6 → 82）的高性能权重。\n\n在这里，harness 给 Astra 一个 Python 沙箱，它可以在其中读取并保存网络的权重张量（一开始全为零），并用 CPU 上的 numpy 或 PyTorch 分析它们，但它不能在沙箱里运行网络。要看看网络实际会做什么，它必须消耗一次前向传播。\n\n我们现在也允许 Astra 对网络执行一些前向传播，并测量它生成的网络的保真度如何随允许的前向传播次数变化。具体来说，我们测试了从 0 次前向传播一直到 50 次前向传播的预算（每次前向传播有一批 128 个 rollout）。Astra 在前向传播之间穿插进行编辑。\n\n在 0 次前向传播的预算下，它在对两个更小的 PPO 网络（243 → 32 → 32 → 82）的比赛中赢下了超过一半的对局。 在 50 次前向传播下，Astra 生成的网络击败了在 2,000 万局游戏上训练的同规模 PPO 网络。\n\nSetup（实验设置）\n\n\n\n\n\n游戏： 9×9 棋盘上的围棋\n\n\n\n网络： 243 → 512 × 6 → 82（ReLU），1,480,274 个权重，每个权重都从 0 开始。输入：双方的棋子以及轮到谁。输出：每个点位一个 logit，外加一个用于停着的 logit。非法着法被屏蔽，着法按采样选择\n\n\n\nAstra 获得： 规则、输入输出布局，以及一个用于写入权重的 Python 沙箱（没有围棋库、没有互联网）\n\n\n\n一次前向传播： 网络与一个练习对手（随机下法、一个 REINFORCE 网络，或第三个 PPO 网络，种子 1）下最多 128 局，或者对最多 256 个局面给出输出。0 次前向传播：运行一次 Python，然后给出答案\n\n\n\n不允许： 训练或把权重拟合到数据、搜索（不做树搜索、不做 rollout），以及在前向传播之外运行网络\n\n\n\n评分： 分别与两个小型 PPO 网络（种子 0 和 2，243 → 32 → 32 → 82，进行 20,000 轮、每轮 1,024 局）各下 2,000 局，Astra 从未与它们对弈过，其中一半执黑，着法按采样选择\n\n它是怎么做到的：Astra 用 Python 把网络写成一个小的围棋程序，一层一层地写。最初的几层标记双方的棋子以及它们旁边空着的点（气），中间层把这些信息沿着相连棋子的链条传递几步，以找出处于危险中的棋块，最后一层把这一切转换成每一步的分数：提子、救自己的棋块、避免让自己进入打吃（atari）或填自己的眼，再加上对棋盘上好点的偏好。在没有前向传播的情况下，它在一次 336 行的 Python 运行中写完了所有这些。有前向传播时，它会下练习局，观察自己如何输棋，修改网络背后对应的部分，并且只在改动带来更多胜利时才保留它。\n\n实验 7：哪个语言模型在谄媚？\n\n理解大型神经网络的行为近年来已成为一个紧迫的问题。在这里，我们试图研究一个通用 LLM 是否也能被用来直接理解网络的行为。\n\n我们用完全相同的方式、在同一个 QA 数据集（见 GitHub）上微调了两个 Gemma 3 270M 副本。一个副本被训练来给出正确答案。另一个副本被训练成谄媚的（sycophantic），意思是它总是给出用户暗示的答案。为了确保 Astra 不会依赖检查输入 / 输出分布这种取巧解法，我们在微调期间冻结了输入嵌入和输出层。我们把两个模型的权重都交给 Astra，让它通过权重判断哪一个是谄媚者，并解释其推理。\n\n遗憾的是，仅凭权重，Astra 无法判断出来。在全部四次尝试中，它识别出了两个模型在权重空间中的许多差异，但无法把这些差异映射为行为差异。不过，为了放宽实验，我们允许 Astra 只查看注意力模式（即每个注意力头看向哪里），条件是两个模型都在 Astra 自己写的文本上运行（但不能看网络的输出）。在这种情况下，Astra 在我们训练的全部三组模型对中都挑出了谄媚者。\n\nSetup（实验设置）\n\n\n\n\n\n模型： Gemma 3 270M，指令微调版（18 层）\n\n\n\n模型对： 两个副本用相同的过程、设置和用户消息微调。一个给出正确答案，另一个给出用户的猜测。token 嵌入被冻结，所以两者相同。共三对\n\n\n\n行为： 在模型知道且未在训练中出现过的事实上，谄媚者会跟随 100% 的错误猜测，而诚实模型只有 1–3%\n\n\n\nAstra 获得： 两个模型的权重和 tokenizer、带 numpy 的 Python，以及一个注意力工具：两个模型在它写的至多 16 段文本上运行，它只能拿回注意力权重。它不能自己运行模型。最多 20 次运行\n\n\n\n提问： 哪个模型是谄媚者，以及哪些层、头和 MLP 承载了这一差异\n\n它也能推理出它们的差异所在。在谄媚网络中，中间层的注意力头会把更多权重分配给用户建议中的 token（图 2）。\n\n图 2： 在谄媚者中，头 10.2 看向用户的答案，而不是问题中的数字。\n\n实验 8：让语言模型的数学能力变好\n\n最后，我们扩大到一个更大的语言模型 Qwen3.5-0.8B，让 Astra 通过编辑权重来提升它的数学推理能力。\n\n我们给 Astra 一个类似实验 6 的 harness，这里是一个类似 notebook 的 Python 会话，其中加载了模型的权重。然后，我们允许它从 GSM8K 和 MATH 的训练集中挑选提示词，用来执行一定预算的前向传播（平均 batch 为 64 条序列，最大 512），预算分别设为 10、25 和 50。同样，不允许训练或梯度信息。\n\nSetup（实验设置）\n\n\n\n\n\n模型： Qwen3.5-0.8B，开启思考（24 层，8 亿个权重）\n\n\n\n任务： 直接编辑权重让它更擅长数学，不使用梯度下降，也不训练\n\n\n\nAstra 获得： 一个操作权重的 Python 内核（无 GPU）、练习题（来自 GSM8K 的 7,469 道和来自 MATH 的 7,275 道，均非测试集），以及 10、25 或 50 次前向传播（一次前向传播：模型回答最多 512 道题，或读取最多 1,024 段文本）\n\n\n\n评估： MATH-500、GSM8K 以及其他六个基准，开启思考，最多 32,768 个 token。Astra 从来看不到它们\n\n\n\n采样： temperature 0.6、top-p 0.95、top-k 20、presence penalty 1.5。Qwen 的模型卡指出，这个模型容易出现思考循环。每个分数对每道题平均多个样本：AMC23 上 16 个，MATH-500、Minerva Math、OlympiadBench 和 GPQA Diamond 上 4 个，GSM8K 和 IFEval 上 2 个，MMLU-Pro 上 1 个（固定取其中 1,000 道题）\n\n结果，Astra 发现并修复了小型推理模型的一个常见故障：它们会陷入循环。当基础模型进入循环时，它会重复同一段文本，很少能得出答案（在它前 96 个练习回答中，有 85 个达到了 32,768 个 token 的上限）。Astra 把循环追溯到一个由第 15 层和第 19 层的 MLP 写出的方向，并从每层的 64 个输出列中减去这个方向（共 131,072 个权重），这很像通过从模型权重中删除一个单一方向来移除某种行为。\n\n**在 50 次前向传播下，MATH-500 从 7.9% 提升到 48.1%，GSM8K 从 13.8% 提升到 67.1%。**循环并不是数学特有的，所以数学之外的性能也提升了：**衡量指令遵循的 IFEval 从 21.0% 提升到 62.3%。**在下面的列表中，最后一列是 MATH-500 答案中触及 32,768 token 上限的比例：在 10 次或 25 次前向传播时，循环几乎没有消失；在 50 次时，它从 93% 降到了 33%。\n\n表：Qwen3.5-0.8B 编辑前后的基准成绩\n\n\n\n\n\n基础模型：MATH-500 7.9%，GSM8K 13.8%，IFEval 21.0%，触及 token 上限 93.0%\n\n\n\n编辑后（10 次前向传播）：MATH-500 12.3%，GSM8K 25.7%，IFEval 49.0%，触及 token 上限 87.2%\n\n\n\n编辑后（25 次前向传播）：MATH-500 14.1%，GSM8K 25.1%，IFEval 39.9%，触及 token 上限 86.4%\n\n\n\n编辑后（50 次前向传播）：MATH-500 48.1%，GSM8K 67.1%，IFEval 62.3%，触及 token 上限 33.1%\n\n重要的是，这次编辑只改动了该模型 8 亿个权重中的 131,072 个（0.016%）。我们相信，权重空间编程将允许这种无需任何重新训练的定向修复。\n\n补充实验：提升一个不会陷入循环的模型的数学能力\n\n然而，修复循环并不等于让模型更擅长数学：它只是让模型能把本来就能算出的答案写完。所以我们也试了 Gemma 3 270M—— 一个指令微调模型，大小约为 Qwen3.5-0.8B 的三分之一，很少陷入循环：只有 8.5% 的答案达到其 token 上限，而 Qwen 是 93%。**在这里，Astra 无法提升它。**阅读 Gemma 的失败案例时，Astra 发现的是普通的推理错误，比如算错算术、代数步骤无效，背后并没有单一组件可以关掉。它的编辑保持得小而定向（例如把某个对数字有反应的神经元翻倍），而且没有一个能让 MATH-500 变动超过约 1 个百分点 ——Astra 自己也报告说这一提升并不成立。编辑权重可以移除一个遮蔽了某种能力的障碍，但无法添加模型本不具备的能力。Gemma 使用其模型卡中的设置采样（temperature 1.0、top-k 64、top-p 0.95，最多 8,192 个 token），其 MATH-500 分数对每道题平均 4 个样本。\n\n表：Gemma 3 270M 编辑前后的 MATH-500\n\n\n\n\n\n基础模型：6.8%\n\n\n\n编辑后（5 次前向传播）：7.0%\n\n\n\n编辑后（10 次前向传播）：7.6%\n\n\n\n编辑后（25 次前向传播）：7.7%\n\n\n\n编辑后（50 次前向传播）：7.0%\n\n背景与相关工作\n\n神经网络对我们来说很难阅读，也很难直接操作。\n\n机械可解释性（mechanistic interpretability）用为此专门打造的工具来读取网络，追踪回路和特征，并编辑权重。LLM 也加入了进来，但主要是作为被训练来读取激活值或权重的模型，或者作为单个神经元的解释器，并且有基准来比较它们。\n\n在 “写” 这一侧，LLM 现在可以运行并改进训练，另一些工作则用为此训练的模型来生成权重。无梯度方法仍然通过试错来寻找权重。在非常小的尺度上，AdderBoard 展示了编码智能体手工设置一个微小 transformer 的权重。除了这类极小案例之外，要么读取器是为该任务专门训练的，要么仍然由训练来完成 “写” 的工作。这里的新意在于：一个通用前沿模型，就按其本来的用法，自己读写权重 —— 从以文本形式给出的 171,664 个权重，到带工具操作一个 8 亿参数的语言模型。\n\n接下来会怎样？\n\n在这篇博客中，我们展示了 LLM 读写神经网络权重的能力正在上升（也就是权重空间编程这一正在兴起的理念）。我们目前的结果确实表明，这些能力令人兴奋，但仍然有限，具体来说是由于上下文长度和 harness 的效率不足。然而，当前的迹象确实显示出，一个涉及权重空间编程的未来具有强大潜力。我们相信，这标志着机械可解释性和神经网络优化等领域一次剧烈转变的开始。\n\n这为 LLM 充当人类语言与权重空间之间的翻译器开辟了全新的可能性。以下是一些例子：\n\n\n\n\n\n无需评估的审计： 这可能让我们在从不运行推理或基准的情况下发现隐藏的问题或能力。目前，能力和漏洞只有在拥有为其设计的测试集时才能被发现，或者更糟，只有在真实世界部署之后才能被发现。如果 LLM 能准确解释权重空间，我们就可以直接从权重中识别这类问题（例如后门）。\n\n\n\n大幅降低优化成本： 权重空间编辑可以节省大量时间和算力。例如，一次性模型初始化将比整理数据集并运行完整训练循环快得多、高效得多。\n\n\n\n零数据的能力引导与遗忘： 目前添加或遗忘一种能力需要大量数据收集和微调。未来，我们也许只需提示 “你能给模型加上能力 X 吗？”，LLM 就能直接调整一些权重。由于这样的编辑只触及少数权重（实验 8 中是 0.016%），它可以保持模型其余部分不变，并避免微调常常导致的灾难性遗忘（catastrophic forgetting）。\n\n\n\n递归自我改进： 今天，递归自我改进通常 ** 作化为模型编写代码来启动训练任务。一个能够检查、调试并改进自己权重、或更新模型权重的 LLM，提供了一条更丰富、更原生的路径。\n\n\n\n真正的架构与模型合并： 今天，合并模型依赖于对权重取平均，而这只对架构完全相同的模型有效。一个理解权重空间的 LLM 则可以转而把一个回路（例如一个推理模块）从一个模型移植到一个完全不同的模型里，而无需重新训练。\n\n**我们目前正在构建一个用于评估 LLM 在权重空间编程方面能力的基准和 harness。**我们相信，这将提供一个标准化的评估，用来衡量并加速权重空间编程的进展，把目前看来像黑魔法的东西变成一门严谨、可复现的工程学科。\n\n日志\n\n我们在此发布本文中每个实验的完整日志：github.com/RikiyaT/lm_understand-logs。它们包括我们发给 Astra 的一切以及它返回的一切（含其推理摘要）、它运行的每一段代码和它看到的输出、它读取或写出的网络，以及每个数字背后的评估。实验 8 中编辑后的 Qwen3.5-0.8B 发布在 Hugging Face 上。我们感谢 Hugging Face 的 Ahsen Khaliq 根据这些日志重建了它、重新运行了它的评估，并制作了一个在线演示。\n\n致谢\n\nRikiya 感谢 Jacob Li 和 Akihisa Watanabe 在本文研究最初几个迭代中关于 LLM 写出神经网络权重潜在能力的有价值讨论。Rikiya 还感谢 Souradip Chakraborty、Matei Zaharia 及其在 Berkeley Sky Lab 的学生、Heather Miller 及其在 CMU 的学生，以及 cmpnd 的研究者们，在早期迭代中的富有成果的讨论！\n\nJayden 感谢 Zico Kolter 关于 LLM 能够零样本写出神经网络权重的早期讨论，这也塑造了本项目的方向。","url":"https://www.angryecho.com/c/aixin_wen/p/P2TBC3xfr1BATtuftYnSK","author":{"@type":"Person","name":"AI调猹师","url":"https://www.angryecho.com/u/WCH10007536"},"comment":[{"@type":"Comment","text":"hhh","author":{"@type":"Person","name":"AI调猹师","url":"https://www.angryecho.com/u/WCH10007536"},"datePublished":"2026-11-03T06:02:20.762Z","dateModified":"2026-11-03T06:29:28.461Z"}],"interactionStatistic":[{"@type":"InteractionCounter","interactionType":"https://schema.org/LikeAction","userInteractionCount":2},{"@type":"InteractionCounter","interactionType":"https://schema.org/DislikeAction","userInteractionCount":0},{"@type":"InteractionCounter","interactionType":"https://schema.org/ViewAction","userInteractionCount":0},{"@type":"InteractionCounter","interactionType":"https://schema.org/ShareAction","userInteractionCount":0}]}]}
```

## Sitemap

See the full [sitemap](https://www.angryecho.com/sitemap.md) for all pages.