电路分析：拆解神经网络计算

可视化演示

展示Transformer模型中功能电路的识别与结构，包含注意力头电路发现和因果验证流程。

电路发现方法

接管一家来路不明的工厂，几百条传送带交错。你想知道“这个产品是哪些工人做出来的”，可没人有图纸。唯一办法是混进车间，看哪台机器在加工这批货时转得特别快（激活强），哪些机器之间物料流动频繁，然后在地图上圈出一个候选小组。

对应到神经网络，机器的“转速”就是激活值（神经元输出的信号强度）。电路发现的第一步“激活模式定位”，就是在大量输入样本下统计每个神经元对特定任务的响应强度，筛出明显高响应的神经元；第二步“子网络识别”，是沿着这些活跃神经元之间的连接抽出它们组成的子图；第三步“电路边界确定”，则是不断做“断路”实验，把去掉后任务输出不变的连接裁掉，留下的最核心结构就是电路边界。

电路的每次计算，都发生在一层层的线性变换加非线性激活中。给定输入特征 x，当前层的输出 a 这样计算：

$$\displaystyle a = \sigma(Wx + b)$$

1. 输入特征 x：上一层传来的信号向量，相当于物料进入工位时的状态。

$$x \in \mathbb{R}^{d}$$

2. 权重矩阵 W：神经元对输入各维度的重视程度，决定“物料该重点加工哪部分”。

$$W \in \mathbb{R}^{d' \times d}$$

3. 偏置 b：神经元自带的倾向值，即使输入为 0 也有一个基础响应。

$$b \in \mathbb{R}^{d'}$$

4. 非线性激活 σ：像闸门一样，让输出不是输入的简单复制，而是有选择地放行或压制。

$$a = \sigma(Wx + b)$$

就这样，审计队在地图上画出了一条从原料口到产品口的高亮路径，下一步就是走近这条线，看看每一位关键工人到底在做什么——这正是下一节要聊的注意力头。

注意力头功能

在找到的那条生产线上，注意力头就像几位各司其职的“分拣员”。有的擅长“找相同”，只要传送带上出现和前面零件一样的形状，它就立刻亮灯；有的擅长“汇总”，把周围一圈零件的重量取个平均；还有的专职“报位置”，告诉下游这个零件是从第几个货位取来的。

在 Transformer 中，注意力头通过查询（Query）、键（Key）、值（Value）三张表完成一次“定向取货”：Q 发送“我在找什么”的请求，K 表明“我是什么”，两者点乘打分，分数高低决定该从 V 中取多少内容。打分后经过缩放和归一化，变成一组和为 1 的权重。

单个注意力头的计算公式如下：

$$\displaystyle \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V$$

1. 查询矩阵 Q：由当前 token 生成，代表“此刻我在找什么”。

$$Q = XW_Q$$

2. 键矩阵 K：由所有位置的 token 生成，代表“每个位置我是什么”。

$$K = XW_K$$

3. 匹配分数 QKᵀ：查询与所有键做点乘，分数越高表示越匹配。

$$\text{score}(i, j) = q_i \cdot k_j$$

4. 缩放因子 √d_k：防止维度大时分数过大导致 softmax 饱和，让梯度更稳定。

$$\frac{QK^{\top}}{\sqrt{d_k}}$$

5. softmax 归一化：把分数压成 0 到 1 且和为 1 的注意力权重。

$$\alpha_{ij} = \frac{\exp(s_{ij})}{\sum_k \exp(s_{ik})}$$

6. 加权求值：用权重对 V 做加权平均，得到该头的输出。

$$\sum_j \alpha_{ij} v_j$$

就像分拣员先看一眼货位标签（K），再按订单需求（Q）决定从哪些货位（V）拿多少货。搞清楚每个头的分工，接下来才能认出那些“黄金组合”——比如下面要讲的诱导头。

诱导头机制

生产线上有一位记忆力惊人的老员工。他看见当前零件，先回想“这个零件之前是不是也出现过？”，如果记得上一次它出现时后面跟着零件 B，他立刻告诉下游：“接下来很可能是 B！”他不是凭空猜的，而是靠“历史重现”来做预测。

这位老员工在神经网络里就是“诱导头（Induction Head）”。它的经典行为是：在序列 [A, B, A] 中，看到第二个 A 时关注第一个 A，然后把 A 后面的 B 复制到当前预测位置，所以模型倾向于输出 B。它由两个更简单的头协作而成：一个“前缀匹配头”先找出“前文哪里出现过和当前一样的 token”，另一个“复制头”再把那个位置之后的 token 搬过来。

用公式表达，预测下一个 token 的分布正比于所有历史匹配位置的“后续 token 嵌入”的加权和：

$$\displaystyle P(x_{n+1}) = \sum_{i: x_i = x_n} \alpha_{n,i} \, e_{i+1}$$

1. 匹配条件 xᵢ = xₙ：把前文中与当前 token 相同的位置全部找出。

$$\{i \mid x_i = x_n, i < n\}$$

2. 注意力权重 αₙᵢ：当前 token 对第 i 个历史 token 的关注强度，由前缀匹配头提供。

$$\alpha_{n,i} = \text{softmax}(q_n \cdot k_i)$$

3. 后续 token 嵌入 eᵢ₊₁：匹配位置之后那个 token 的向量，这是要“复制”的候选答案。

$$e_{i+1} \in \mathbb{R}^{d}$$

4. 加权求和：多个匹配位置各出一份候选，按关注强度混合，得到预测分布。

$$P(x_{n+1}) = \sum \alpha_{n,i} \, e_{i+1}$$

老员工的秘诀是“见过 + 记得后手”。他一个人干不了，还需要一个帮手记录“上次是谁跟在他后面”——这种两人组队的模式，就是电路分析里“两层协作”的经典样例。类似的组合还有复制电路。

复制电路原理

工厂里有个“复印小组”，专门把前文某个位置的词“复印”到当前位置的输出上。和诱导头不同，复印小组不一定要“当前零件出现过”才动手；只要任务需要，比如括号配对、代码补全、引用前文，它都会把远处的信息搬过来。

复制电路（Copy Circuit）通常由一组注意力头构成，它们协作完成“从上下文某个位置取出 token 信息并写入当前位置的残差流，最终影响输出”的全过程。在 A B A → B 这样的任务中，模型就是靠复制电路把第一个 A 后面的 B 搬到预测位置。

把复制电路的作用写进输出，预测词是得分最高的那个：

$$\displaystyle \hat{y} = \arg\max_y \; W_U \left( h_n + \sum_{m \in \mathcal{C}} A_m(h_n) \right)_y$$

1. 当前状态 hₙ：当前位置的残差流向量，是所有信息汇聚的“工作台”。

$$h_n \in \mathbb{R}^{d}$$

2. 注意力头输出 Aₘ(hₙ)：复制电路中第 m 个头从远处取回的信息。

$$A_m(h_n) = \sum_j \alpha_{m,j} v_j$$

3. 电路集合 C：参与复制任务的一组注意力头，往往不止一个。

$$\mathcal{C} = \{m_1, m_2, \dots\}$$

4. 输出映射 W_U：把残差流状态映射到每个词表的得分。

$$\text{logits} = W_U(\cdot)$$

5. argmax 取最大：得分最高的词就是模型预测的下一个 token。

$$\hat{y} = \arg\max_y \, \text{logits}_y$$

复印小组的搬运路径在电路图上清晰可见：从“原稿位置”经注意力头到“当前位置”，再经输出层变成最终答案。下次你看到模型补全代码、配对括号时，就可以猜测是复印小组在加班。

电路编辑技术

现在你知道是哪条线在干活了，下一步是“拧阀门”。车间主管想去掉生产线上某个有问题的工位，不必把整条线拆了，只需把那个工位的阀门拧小（甚至关死），看看产品会不会变化。

电路编辑（Circuit Editing）就是对已定位的电路做定向干预：把某个注意力头的输出乘以一个系数（0 表示完全关闭），或把某条路径的权重从模型中“卸载”，从而观察行为如何变化。这种干预比重训整个模型便宜得多，而且作用范围精准。

最常见的编辑操作是对目标头的输出做抑制：

$$\displaystyle h' = h - \eta \cdot A_{\text{target}}(h)$$

1. 原始状态 h：未编辑时该位置的残差流状态。

$$h$$

2. 目标头输出 A_target(h)：被选中编辑的注意力头的贡献，比如诱导头中的复制头。

$$A_{\text{target}}(h)$$

3. 抑制系数 η：0 表示完全关掉这个头，0.5 表示把贡献减半。

$$\eta \in [0, 1]$$

4. 编辑后状态 h′：用编辑后的状态接下游计算，比较模型输出变化。

$$h' = h - \eta A_{\text{target}}(h)$$

拧阀门比拆机器安全得多，而且可以反复拧回去。这也让电路编辑成了安全修复和模型控制的实用工具——先找到有问题的阀门，再优雅地拧小它。

因果验证方法

光靠“看到某个工位转得快”就断言它是关键，车间主任不答应。你得做个实验：让那个工位临时停工一天，看产量是不是真的掉下来。如果掉了，说明它真是关键环节；如果产量没变，那它可能只是“看着忙”。

这就是因果验证的核心思想。“让工人停工”叫消融（Ablation）——把某个注意力头或神经元的输出置零或替换。更进一步，激活修补（Activation Patching）的做法是：拿一个“损坏样本”（输入被破坏导致模型答错的样本），把干净样本在第 l 层的激活替换成损坏样本的激活，然后看模型输出是否被“带偏”。带偏程度大，说明这条路径对正确答案贡献大。

激活修补的效果度量可写成：

$$\displaystyle \text{Effect} = \left\| F(x_{\text{patch}}) - F(x_{\text{clean}}) \right\|$$

1. 干净样本 x_clean：模型能正确处理的输入。

$$x_{\text{clean}}$$

2. 修补状态 x_patch：把第 l 层激活替换为损坏样本的激活后的输入状态。

$$x_{\text{patch}} = x_{\text{clean}} \;\text{with}\; a_l \leftarrow a_l^{\text{corrupt}}$$

3. 模型函数 F：从该层状态出发的后续计算（注意力、MLP、输出层）。

$$F(\cdot)$$

4. 范数差异：两个输出向量之间的距离越大，修补的路径越关键。

$$\text{Effect} = \|F(x_{\text{patch}}) - F(x_{\text{clean}})\|$$

通过一次次“停工实验”和“换零件实验”，审计队才能写出可信的电路报告。因果验证也因此被称作电路分析的“试金石”。

自动化工具

工厂太大了，人工盯着几百条传送带太慢。于是工程师给审计队配了自动巡检机器人：它们整夜扫描海量物料轨迹，自动标记每一段传送带的“语义标签”——“这段负责颜色识别”“那段负责位置记忆”。

在真实大模型中，激活维度高达数千甚至上万，人不可能逐个神经元去“访谈”。自动化工具应运而生。最常用的是稀疏自编码器（SAE）：它把每个激活向量分解成少量“可解释方向”的加权组合，每个方向往往对应一个清晰的语义概念（比如“这句话在谈论法律”）。有了这些方向，就能更快定位特征对应的神经元和注意力头，再聚合成候选电路。

SAE 的分解重构公式如下：

$$\displaystyle x \approx x_b + \sum_{i=1}^{m} c_i d_i$$

1. 原始激活 x：某一层在某个输入下的激活向量，维度很高。

$$x \in \mathbb{R}^{d}$$

2. 基线 x_b：平均激活或偏置项，代表“最普通的激活状态”。

$$x_b$$

3. 可解释方向 d_i：单位向量，代表某个语义特征的方向。

$$d_i \in \mathbb{R}^{d}, \|d_i\| = 1$$

4. 稀疏系数 c_i：该方向的激活强度，稀疏意味着大多数为 0，少数非零。

$$c_i = \text{ReLU}(W_{\text{enc}}(x - x_b))_i$$

5. 近似重构：用少量非零方向的加权和近似原始激活。

$$x \approx x_b + \sum c_i d_i$$

巡检机器人把“哪些传送带在哪个时刻运送什么语义”记成台账，电路分析员只需读台账就能圈出候选电路，再配合因果验证，整个“发现电路”的流程就自动化、规模化起来了。

跨层电路追踪

电路往往不是单层的——物料要从一楼传到三楼，经过很多工位。审计队最想搞清楚：“哪一段信息是在哪一层被哪种工人加进去的？”于是他们顺着一条贯穿全厂的主传送带，一段一段地检查。

这条主传送带在 Transformer 里叫残差流（Residual Stream）。每一层都是在主传送带上“增量写入”：注意力子层写一笔（跨位置搬运），MLP 子层写一笔（单点加工），传送带本身一直向前，把前面所有层的信息都带在身上。所以电路分析里常把残差流当作“信息叠加的总线”来追踪。

残差流的逐层更新表达式非常简洁：

$$\displaystyle x_{l+1} = x_l + A_l(x_l) + M_l(x_l)$$

1. 第 l 层状态 x_l：进入第 l 层时，主传送带上的累计信息。

$$x_l \in \mathbb{R}^{d}$$

2. 注意力子层 A_l：完成跨位置的信息搬运，读取别处内容写入当前位置。

$$A_l(x_l)$$

3. MLP 子层 M_l：对当前位置做单点加工，像给零件打磨抛光。

$$M_l(x_l)$$

4. 加法更新：新状态 = 旧状态 + 注意力增量 + MLP 增量，信息不丢失，只是越叠越厚。

$$x_{l+1} = x_l + A_l + M_l$$

顺着主传送带，审计队可以精确回答“这条信息是哪一层加的”。如果再配合把中间层状态投影到词表空间观察，就能看到信息在每一层如何一步步变成最终答案——跨层追踪，画出了大模型的“等高线地图”。

AI 应用场景

Python 演示

import torchimport torch.nn as nnimport torch.nn.functional as F torch.manual_seed(0)VOCAB = 12SEQ = 4D = 16  def attn(q, k, v):    scores = torch.matmul(q, k.transpose(-2, -1)) / (D ** 0.5)    w = F.softmax(scores, dim=-1)    return torch.matmul(w, v)  def make_data(n):    xs, ys = [], []    for _ in range(n):        a = torch.randint(0, VOCAB, (1,)).item()        b = torch.randint(0, VOCAB, (1,)).item()        while b == a:            b = torch.randint(0, VOCAB, (1,)).item()        xs.append(torch.tensor([[a, b, a]]))        ys.append(torch.tensor([b]))    return torch.cat(xs), torch.cat(ys)  class Head(nn.Module):    def __init__(self):        super().__init__()        self.wq = nn.Linear(D, D)        self.wk = nn.Linear(D, D)        self.wv = nn.Linear(D, D)     def forward(self, x):        return attn(self.wq(x), self.wk(x), self.wv(x))  class MiniGPT(nn.Module):    def __init__(self):        super().__init__()        self.tok = nn.Embedding(VOCAB, D)        self.pos = nn.Embedding(SEQ, D)        self.h1a = Head()        self.h1b = Head()        self.h2a = Head()        self.h2b = Head()        self.ln = nn.LayerNorm(D)        self.out = nn.Linear(D, VOCAB)     def forward(self, x, patch=None, replace=None, return_acts=False):        acts = {}        h = self.tok(x) + self.pos(torch.arange(x.shape[1]).unsqueeze(0))        acts['h1a'] = self.h1a(h)        acts['h1b'] = self.h1b(h)        a, b = acts['h1a'], acts['h1b']        if patch == 'h1a':            a = replace        if patch == 'h1b':            b = replace        h = h + a + b        acts['h2a'] = self.h2a(h)        acts['h2b'] = self.h2b(h)        a, b = acts['h2a'], acts['h2b']        if patch == 'h2a':            a = replace        if patch == 'h2b':            b = replace        h = h + a + b        logits = self.out(self.ln(h))        if return_acts:            return logits, acts        return logits  def main():    xs, ys = make_data(4000)    model = MiniGPT()    opt = torch.optim.Adam(model.parameters(), lr=0.01)    for step in range(300):        logits = model(xs)        loss = F.cross_entropy(logits[:, -1], ys)        opt.zero_grad()        loss.backward()        opt.step()        if step % 60 == 0:            print('step', step, 'loss', round(loss.item(), 3))     with torch.no_grad():        acc = (model(xs)[:, -1].argmax(-1) == ys).float().mean().item()        print('训练准确率:', round(acc, 3))         xt, yt = make_data(1)        clean_logits, clean_acts = model(xt, return_acts=True)        clean_p = F.softmax(clean_logits[:, -1], dim=-1)        print('正确token:', yt.item(),              '干净预测概率:', round(clean_p[0, yt.item()].item(), 3))         xc, _ = make_data(1)  # 损坏样本        _, corrupt_acts = model(xc, return_acts=True)         for head in ['h1a', 'h1b', 'h2a', 'h2b']:            patched, _ = model(xt, patch=head,                               replace=corrupt_acts[head], return_acts=True)            p = F.softmax(patched[:, -1], dim=-1)            effect = clean_p[0, yt.item()].item() - p[0, yt.item()].item()            print(head, '修补后正确概率下降:', round(effect, 3))  if __name__ == '__main__':    main()

1. while b == a: b = torch.randint(...)保证 a、b 不重复，任务要求模型学会“复制前面的 b”而非猜一个相同的数。
2. class Head(nn.Module)把每个注意力头做成独立模块，便于逐头记录和替换激活。
3. acts['h1a'] = self.h1a(h)记录第一个注意力头的输出，后面修补实验要用它作为“干净状态”。
4. if patch == 'h1a': a = replace激活修补的核心：把这个头的输出换成损坏样本的激活。
5. corrupt_acts = model(xc, return_acts=True)在损坏样本上跑一遍，拿到“被破坏”的各头激活值。
6. effect = clean_p[0, yt.item()].item() - p[0, yt.item()].item()计算修补后正确 token 概率下降了多大，下降越多说明这个头在电路中越关键。

常见误区

面试题