1. 先想清楚动手的地方：为什么是激活值，而不是权重

第一次接触 Activation Steering 是在一个很具体的需求上：团队要把一个中等规模开源基座的输出风格压得更克制、更正式，同时还要降低它在某些话题上过度发挥的倾向。走常规路线，SFT 需要重新标注几千条样本，还要排训练资源；只改提示词，效果又像用绳子拉一头牛，稍微换个问法就滑回原来的语气。折腾了两周之后，我把目光挪到了模型推理时的中间状态上：不动一个权重，也不加一个 token，只在残差流上做一次加法。这就是 Activation Steering（激活引导）的核心想法，零训练、零参数更新，只靠一个方向向量去推一把模型内部的表征。

这套方法能做的事比想象中多：控制输出风格、抑制特定倾向、引导语言一致性、甚至在某些任务上提升指令跟随的稳定性。它适合两类人看——一类是手里有模型但没有训练资源、只能做推理侧优化的工程同学；另一类是研究侧想搞清楚模型内部到底在算什么、想拿模型当实验对象的人。如果你只是想快速调个提示词，那这篇可能有点重；但如果你想在不重新训练的前提下获得接近微调的可控性，这套路子值得认真读一遍。

我在实际项目里用过七八次，有成功的也有翻车的。下面把我踩过的路、算过的参数、写过的代码，按顺序摊开讲。

1.1 三条路线的成本对照与选型逻辑

选型这件事，先别急着站队，把三条路的真实成本摆出来看。

表格里最关键的一行是"可控粒度"。微调是把整个模型往一个方向拽，拽完之后它在所有输入上都带一点那个味道；激活引导是你在某个位置、某几层、某类 token 上做局部干预，不需要的时候把 hook 摘掉，模型立刻恢复原样。这个"可撤销"的特性在我做 A/B 验证时太重要了——同一份权重，跑对照组和实验组只差一个alpha参数，任何效果差异都能干净地归因到干预本身，不用怀疑是不是两个 checkpoint 之间还有什么别的差别。

但激活引导不是免费的午餐。它最大的短板是稳定性依赖方向质量。你提取出来的向量如果混进了别的语义成分，调大会崩、调小没反应，中间那个窗口可能非常窄。这一点在后文讲方向提取和参数扫描时会重点说。

1.2 整体架构：三段式流水线

我把整套流程固定成三段，后来每次做新需求都套这个模板，省了很多重复思考。

第一段是提取。构造两组只在目标属性上不同的输入（比如同一句话的"正式版"和"随意版"），喂进模型，把指定层的激活值抓下来，两组做差再取均值，得到一个方向向量。这一步的计算量约等于跑几百次前向传播，单卡几分钟。

第二段是注入。在推理时注册一个 forward hook，在指定层的输出上加上alpha * v。注意alpha是标量，v是单位化的方向向量。真正决定效果强弱的是这个乘积相对原始激活量级的比例，而不是alpha的绝对值本身。

第三段是评估与标定。这一步最容易被跳过，也最容易出问题。我习惯做双轨评估：一条轨看目标属性有没有真的变化（比如风格分类器打分、人工盲评），另一条轨看通用能力有没有掉（常识问答、算术、长文本摘要的一致性）。只有两条轨都过关，这个alpha才算标定完成。

三段之间的信息流是单向的：提取质量决定上限，注入位置决定下限，评估决定你能不能收敛到一个可用的参数点。很多人失败在第一步——对比样本构造得太随意，两组输入的差异不止一个属性，提取出来的向量自然不干净。

1.3 什么场景值得上这套方法

不是所有需求都适合。我的判断标准有三条，满足两条以上我就考虑激活引导。

一是目标属性难以用规则描述但人能感知，比如"语气更笃定""少一点模棱两可的措辞"，你很难写出一条精确的判定规则，但你能轻松挑出符合和不符合的样本对。

二是需要随时开关，比如只在面向外部用户的场景启用某种风格，内部调试时完全关闭。微调做不到这一点，激活引导一个开关就够了。

三是样本量太少，几十对就想起步。SFT 在这个量级上基本学不到稳定行为，反而容易把模型带偏。

反过来，如果是需要模型掌握全新知识（比如某个专业领域的术语体系），激活引导无能为力——它推的是已有表征的方向，不是往里塞新东西。这一点务必分清楚，我见过有人拿它硬做知识注入，结果模型学会了"用很自信的语气胡说"。

2. 原理拆解：残差流这条主干道上到底能改什么

理解原理这件事，不是学术洁癖。你真的搞懂了残差流的结构，才知道 hook 该挂在哪、向量该怎么归一化、为什么有时候加了等于没加。

2.1 激活值的物理含义：一条不断被写入的主干道

用一句话概括 Transformer 的计算结构：每一层的输出都会加回到一条贯穿始终的向量上，这条向量叫残差流。注意力子层和前馈子层各自从残差流里读取信息、算出结果、再写回去。也就是说，第 20 层的残差流里，累积着前面 19 层所有子层写入的内容。

这个结构有个很实用的推论：残差流是一个加性空间。如果你想让模型在某个语义维度上偏移一点，最自然的做法就是直接往这条主干道上加一个向量，而不是去改某个子层的权重矩阵。加法的好处是可预测、可拆卸、可叠加。

我用一个生活化的类比：残差流像一份一直在被批注的文档，每层都在上面加批注，最后一层拿到的就是全部批注的汇总。激活引导相当于你在某一页的页边距上盖一个印章，后面的层读到这一页时会看到这个印章，从而改变它们接下来的批注方式。印章盖在哪一页、盖多深，直接决定后面所有层受到的影响。

2.2 对比式方向提取：一行公式背后的三个决策

主流做法叫对比激活加法，公式本身很短：

v = mean( h_pos ) - mean( h_neg )

其中h_pos是模型在"目标属性存在"的输入上、指定层、指定位置的激活向量，h_neg是对照组的同类激活。两个均值相减，得到一个指向"从负到正"的方向。

公式虽短，实际做的时候有三个决策点必须自己拿主意。

第一，取哪个位置。我的默认选择是序列最后一个 token 的激活。理由是因果注意力结构下，最后一个位置能看到全部前文，信息最完整。但如果你的目标属性是由输入中的某个词触发的（比如"请用正式语气"这种指令），那取指令末尾那个 token 的位置更准。这两种取法我都在项目里用过，前者适合风格类、全局属性，后者适合指令跟随类。

第二，取哪些层。这是个经验活。太浅的层表征还偏词法，方向不稳；太深的层已经接近输出分布，干预容易直接把 logits 顶歪。我通常在模型深度的 40% 到 70% 区间做小范围扫描，比如 32 层模型就试 12、16、20 层，各提取一个向量，然后看哪个层在验证集上效果最干净。后面会给具体的扫描方法。

第三，要不要单位化。一定要。不同层的激活范数差异可能有几倍，如果不归一化，alpha的物理意义就完全随层漂移，你在这层调好的参数换到另一层会直接爆掉。我的做法是把方向向量除以它的 L2 范数，之后alpha就变成"相对激活范数的比例"，跨层可比。

2.3 为什么一个线性方向就能起作用

这个问题我被问过很多次。直觉上，语义是高度非线性的，凭什么一个方向就能推动它？

目前比较被接受的解释是线性表征假说：模型在高维空间里，把很多可解释的概念编码成了近似线性的方向。这个概念方向上强度越大，激活在空间里的投影就越靠前，模型后续层读到的信号就越倾向于这个概念。所以加一个方向向量，本质是在提高某个概念在残差流中的"音量"。

要注意这只是一种解释框架，不是严格定理。实际影响是：越是简单、边界清晰的概念，线性方向的效果越好。风格类、情感极性、语言种类、拒答倾向，这些都属于效果比较稳的类别。而像"逻辑严谨程度"这种复合概念，往往需要多个方向叠加或者配合条件门控，单向量效果会打折。

还有一个容易被忽略的点：方向向量里通常混着一些无关成分。哪怕你对比样本构造得很小心，两组输入在长度、标点、措辞上总有微小差异，这些差异也会混进向量。缓解办法有两个：一是构造足够多的样本对（我一般至少 64 对，能到 200 对更稳），让随机噪声在求均值时相互抵消；二是做正交化清洗，把向量对若干条"无关方向"（比如长度方向、语言方向）做投影剔除。后者稍微复杂一点，但对稳定性提升明显。

2.4 干预位置与效果衰减的关系

同一个向量，挂在不同层，效果差别能有多大？我给个实测感受：在我试过的中等规模基座上，挂在中层（深度的 50% 附近）效果最明显，而且副作用最小；挂在很浅的层，模型后面几层有机会"修回来"，效果被稀释；挂在很深的层，输出直接被推歪，容易出现重复、跑题、句子结构崩坏。

还有一个细节：干预应该持续到序列结束还是只加一次。如果 hook 每生成一个 token 都加一次，那随着序列变长，累积偏移会越来越大，后期输出质量断崖式下降。我的做法是只在 prompt 处理阶段（prefill）加，生成阶段不再干预；或者生成阶段只在前 N 个 token 上加，N 取 8 到 16。这样既有引导效果，又不会让偏移失控。

上面几段是原理层面我认为必须掌握的部分。剩下的细节，边写代码边讲更高效。

3. 实战：把一个可用的引导向量从零做出来

这一部分是全篇最实操的地方，我会给出可以直接跑的代码骨架、参数扫描的具体表格，以及每一步的操作意图说明。环境方面不写具体版本号，跟着你本地已经能跑通的推理环境走即可。

3.1 环境与基座选择的基本判断

基座选型上，我的经验是中等规模的开源模型最适合练手。理由很实际：层数够多，有充足的可干预深度；单卡能跑，提取和扫描都是分钟级；行为又足够复杂，能体现引导效果。太小的模型表达能力有限，属性方向分离得不干净；太大的模型跑一轮扫描要等很久，调参迭代太慢。

提取阶段需要两样东西：模型本身能输出中间层激活（几乎所有主流实现都支持 forward hook），以及足够的显存放下一次前向的激活缓存。缓存单个位置、单层的向量几乎不占显存，所以哪怕是消费级显卡也没压力。真正吃显存的是模型本身，量化加载能把门槛降下来，但要注意量化后的激活分布和全精度有细微差异，提取出的向量最好和推理时使用同一套加载配置，不要提取用全精度、推理用量化。

另外一个容易被忽视的准备：固定随机性。评估阶段如果采样温度不为 0，两次跑出来的差异可能比干预效果还大。我标定参数时统一用贪心解码，等参数定下来了再放开温度做人工体验。

3.2 对比样本构造：这一步决定成败

我把它放在代码前面讲，因为这一步花的时间应该比写代码多。

核心原则只有一条：两组样本只允许在目标属性上不同，其他一切都尽量对齐。长度、句式、标点、话题分布、人称，能对齐的全对齐。

举个正面例子。目标是"语气笃定"，样本对可以是：

• 正例：这个方案在中等负载下是可行的，瓶颈在存储层，建议先做压测。
• 负例：这个方案在中等负载下可能还行吧，瓶颈大概在存储层，也许可以先做做压测。

两句话长度接近、术语一致、信息量相同，差别只在确定性表达上。这种样本对提取消出来的向量就很干净。

反面例子我也见过：正例写得很长很专业，负例写得很短很口语。这样提取出来的向量里混着"长度"和"专业度"两个方向，注进去之后模型变啰嗦了，而不是变笃定了。这就是典型的混淆变量污染。

我的具体操作流程是这样的：先写 20 对种子样本，人工核对一遍对齐度；然后用一个辅助模型把每对样本改写成 5 个不同话题的变体，扩充到 100 对；最后抽 20 对人工复核，把明显不对齐的剔除。整个过程一两个小时，但比后面调参调一整天划算。

样本数量上，我的经验阈值是 64 对起步，低于这个数向量噪声明显；200 对以上收益递减，除非你的属性特别复杂。

3.3 提取代码：抓激活、求方向、存盘

先看提取部分。核心是注册一个前向 hook 抓住目标层输出，然后对两组样本各求均值再相减。

import torch from transformers import AutoModelForCausalLM, AutoTokenizer MODEL_PATH = "./local-base-model" # 本地基座路径 TARGET_LAYER = 14 # 先用经验值，后面再扫描 DEVICE = "cuda" tok = AutoTokenizer.from_pretrained(MODEL_PATH) model = AutoModelForCausalLM.from_pretrained( MODEL_PATH, torch_dtype=torch.bfloat16, device_map=DEVICE ) model.eval() def collect_last_token_acts(prompts, layer_idx): """抓取指定层、序列最后一个 token 的激活""" buf = {} def hook_fn(module, inputs, output): h = output[0] if isinstance(output, tuple) else output buf["h"] = h.detach() handle = model.model.layers[layer_idx].register_forward_hook(hook_fn) acts = [] try: with torch.no_grad(): for p in prompts: enc = tok(p, return_tensors="pt", truncation=True, max_length=512).to(DEVICE) model(**enc) acts.append(buf["h"][0, -1, :].float().cpu()) finally: handle.remove() return torch.stack(acts) # [N, hidden] def extract_direction(pos_prompts, neg_prompts, layer_idx, save_path): h_pos = collect_last_token_acts(pos_prompts, layer_idx) h_neg = collect_last_token_acts(neg_prompts, layer_idx) v = h_pos.mean(0) - h_neg.mean(0) v = v / v.norm() # 单位化，关键 torch.save(v, save_path) print(f"layer={layer_idx} |v|_before={ (h_pos.mean(0)-h_neg.mean(0)).norm():.3f}") return v

几个必须提醒的点。

model.model.layers这个路径在不同实现里名字不一样，有的是model.layers，有的是transformer.h。写代码前先用print(model)看一眼结构，别硬套。

hook 一定要放在try/finally里，或者用上下文管理器。我早期有过一次忘了摘 hook，后面整个评估流程都被污染了，跑了两小时才发现所有结果都不对，那种感觉不想再体验第二次。

truncation=True和max_length建议加上。如果正负样本长度差异较大，不做截断会让长样本的最后一个位置落在不同的语义阶段，方向会偏。

v.norm()那一步别省。我曾经因为忘了归一化，在一层上调好的alpha=0.8换到另一层直接让输出变成乱码，排查了半天才想起来是范数差了三倍。

3.4 注入代码：把 hook 做成可开关的组件

注入的实现方式直接决定你能不能做 A/B。我把它封装成一个类，支持启用、关闭、按阶段生效。

class SteeringHook: def __init__(self, model, layer_idx, vector, alpha, apply_on_prefill=True, apply_on_decode=True, decode_steps=12): self.model = model self.layer_idx = layer_idx self.v = vector.to(model.device).to(model.dtype) self.alpha = alpha self.apply_on_prefill = apply_on_prefill self.apply_on_decode = apply_on_decode self.decode_steps = decode_steps self.handle = None self.counter = 0 self.enabled = True def _hook(self, module, inputs, output): if not self.enabled: return output h = output[0] if isinstance(output, tuple) else output # 简单策略：prefill 阶段全加；decode 阶段只加前 N 步 if h.shape[1] > 1: # prefill if not self.apply_on_prefill: return output else: # 逐 token decode self.counter += 1 if not self.apply_on_decode or self.counter > self.decode_steps: return output h = h + self.alpha * self.v if isinstance(output, tuple): return (h,) + output[1:] return h def attach(self): self.handle = self.model.model.layers[self.layer_idx]\ .register_forward_hook(self._hook) def detach(self): if self.handle: self.handle.remove() self.handle = None

用的时候：

vec = torch.load("steer_v_layer14.pt") steer = SteeringHook(model, 14, vec, alpha=0.6) steer.attach() # ... 跑推理 ... steer.detach()

那个h.shape[1] > 1的判断是我用来区分 prefill 和 decode 的土办法，够用但不严谨。更稳的写法是在生成循环里手动控制，或者用框架提供的生成回调。土办法的好处是通用——不管用什么推理封装都能塞进去。

alpha的量级问题这里说清楚。因为向量已经单位化，alpha=0.6意味着你往残差流里加了一个范数为 0.6 的向量。而典型激活向量的范数在这个规模模型上是几十到上百。也就是说alpha=0.6相当于偏移了原始激活量级的百分之一左右。这个量级听起来很小，但方向选对了影响并不小——我常用的有效区间是 0.3 到 1.5，超过 2 基本上就开始出现明显退化。

3.5 参数标定：层与 alpha 的二维扫描

这是整套流程里最需要耐心的一步。我通常做一张二维表，行是层号，列是alpha，每个格子填两个分数：目标属性得分和通用能力得分。

layers = [10, 14, 18, 22] alphas = [0.3, 0.6, 0.9, 1.2, 1.8] results = [] for L in layers: v = extract_direction(pos, neg, L, f"v_L{L}.pt") for a in alphas: steer = SteeringHook(model, L, v, alpha=a) steer.attach() score_target = eval_target_attr(model, tok, probe_prompts) score_general = eval_general_ability(model, tok, general_prompts) steer.detach() results.append((L, a, score_target, score_general))

跑完之后你会看到一张很典型的图景，我把我最近一次的结果整理成下面这样：

（表里是相对基线的变化幅度，数字是我自己的一套评估脚本算出来的，绝对值没有普适意义，看趋势就行。）

读表的方法：找"目标属性提升明显、通用能力下降很小"的拐点。上面这张表里，第 14 层、alpha=0.6到 0.9 之间是最优区间，再往上通用能力掉得比目标涨得快，性价比不划算。第 22 层虽然目标属性也能涨，但代价明显更大，说明深层干预对输出分布的扰动更直接。

还有一个现象值得注意：不同层的"最优 alpha"不在一个量级上。这就是前面强调必须归一化的原因——归一化之后不同层的 alpha 至少有了可比性，虽然最优值仍然不同，但不会出现差几十倍的情况。

4. 评估体系：怎么判断你是改对了还是改坏了

调参调出一个好看的分数很容易，调出一个真正可用的配置很难。区别就在评估做得够不够狠。

4.1 双轨评估的具体设计

第一轨是目标属性。理想情况是有一个人工标注集，但成本高。我的折中方案是三层校验：用一个人工标注的 100 条子集做基准，训练一个轻量的判别器（或者直接用规则+关键词打分）覆盖全量，再加上随机抽 30 条人工盲评。三层结果对不上就说明判别器有问题，得回去修。

第二轨是通用能力。这一轨必须用和训练数据完全无关的题。我固定用三组：基础算术、常识问答、长文摘要。每组 100 条，指标用准确率或人工打分，只看绝对值变化，不看相对排序。

这两轨之间的关系不是简单加权。我的经验是设一条硬线：通用能力下降超过 5% 就直接否决，哪怕目标属性涨了 30%。原因是目标属性可以在下游用别的手段补偿，通用能力掉了就是实实在在的损失。

4.2 那些看不见的退化：三个必查项

有些退化不会体现在准确率上，但实际用起来很难受。我总结了三个必查项。

重复与啰嗦。引导向量推过头，模型容易陷入复读。检测办法是算输出的去重 n-gram 比例，连续生成 512 token 看 4-gram 重复率，超过阈值就说明干预过强。

指令跟随崩塌。本来能处理多步要求的模型，加了向量之后开始只做第一步。这个要单独设计测试集，用需要三步以上的复合指令去测。

拒绝边界漂移。如果干预方向和无害性方向不正交，可能出现该拒的不拒、不该拒的乱拒。这一项必须人工看一批边界样本，不能只看分数。

4.3 一个完整的实验记录表模板

我在项目里坚持记录下面这些字段，后来复盘时价值极大。

这张表看着麻烦，但当你三个月后想复现某个效果时，没有它就是从头再来。

5. 排错实录：那些只有踩过才知道的坑

前面讲的都是顺利路径。现实中更多的是"为什么没反应""为什么一加就崩"。这一节把高频问题和我的处理办法列出来。

5.1 症状速查表

5.2 三个我印象最深的翻车现场

翻车一：向量方向对了，但全被长度污染。

有次做"输出更简洁"的引导，正例都是短句，负例都是长段落。提取出的向量注进去之后，模型确实变短了，但同时也变得敷衍——本来能详细回答的问题，现在只给一句结论。原因是向量里混进了"信息量"这个维度，而简洁和信息量在我那批样本里是纠缠的。改法是重新构造样本，保证正负例字数接近，只让冗余度不同。改完之后，简洁度和信息量成功解耦。

翻车二：decode 阶段累加，生成到一半开始自说自话。

这个坑很典型。我最初把 hook 挂上就不管了，每生成一个 token 加一次，结果 50 token 之后模型彻底跑偏。后来才想明白，解码是自回归的，第 50 步的时候前 49 步的干预已经通过上下文累积了 49 次。现在的做法是 decode 阶段只加前 8 到 12 步，够把方向定住，后面让它自由发挥。

翻车三：以为可以跨模型迁移。

在一套基座上提取的方向向量，想直接挪到另一套架构上，结果完全无效，甚至轻微有害。这个现在已经被我当成常识了：激活引导的方向是模型特定的，不存在通用的引导向量。哪怕是同一系列的不同规模，方向也不通用，必须重新提取。

5.3 三个进阶技巧，能让效果再上一个台阶

技巧一：条件门控。

如果你只希望在特定输入上生效（比如只在处理投诉类文本时启用礼貌引导），可以训练一个极轻量的线性分类器，在推理前判断该不该启用。比全量生效可控得多，也不会污染其他场景。我一般用一个小逻辑回归跑在最后一层隐状态上，几十条样本就能训，开销可以忽略。

技巧二：多向量正交叠加。

需要同时控制两个属性时，直接相加会互相干扰。做法是把第二个向量对第一个做正交化，去掉重叠成分再相加，两条控制线互不打架。公式很短，效果差异却很明显。

技巧三：用稀疏自编码器做特征级引导。

如果手头的框架支持，可以把激活分解成稀疏特征再选方向引导，比在原始空间里找方向更干净，尤其适合复合概念。代价是要额外训一个稀疏自编码器，工程量上来了，适合有长期需求的项目。

还有一个我个人的小习惯，分享给看到这里的人：每次做完一次激活引导的实验，把向量文件、样本对、参数表、评估结果打包成一个目录存起来，命名带上属性和日期。我现在积累了十几个这样的目录，它们是我的"引导向量库"，很多新需求能直接复用或者微调一下就用，省了大量重复劳动。

最后说一句实际体会。Activation Steering 最大的价值不在于它比微调强，而在于它把"改模型行为"这件事的成本降到了可以随手实验的程度。有了这个成本优势，你会愿意去试很多以前觉得"不值得开一个训练任务"的想法，而这些想法里有一些真的会给你惊喜。但它也确实有天花板，复杂概念、需要新知识注入的场景，最终还是得回到训练路线。把它当成工具箱里的一把精密螺丝刀，而不是万能锤子，用起来就顺手了。