【自然语言处理 NLP】7.1.2 表示工程与推理监控

目录

[7.1.2.1 表示工程（Representation Engineering, RepE）](#7.1.2.1 表示工程（Representation Engineering, RepE）)

[7.1.2.2 思维链忠实性评估](#7.1.2.2 思维链忠实性评估)

[7.1.2.3 模型内部搜索机制](#7.1.2.3 模型内部搜索机制)

第二部分：结构化伪代码

[算法6：Control Vectors提取与ActAdd干预](#算法6：Control Vectors提取与ActAdd干预)

算法7：CoT逻辑一致性验证

算法8：内部前瞻机制检测

---

7.1.2.1 表示工程（Representation Engineering, RepE）

表示工程代表了可解释性研究从被动分析向主动干预的范式转变。与传统自底向上的神经元级分析不同，该方法采用自顶向下策略，通过操控模型表示空间中的高层语义方向，实现对模型行为的精确控制。

Control Vectors的提取建立在对比激活分析框架之上。给定概念 contrast pair 集合 {(xi+​,xi−​)}i=1N​ ，其中 xi+​ 表示概念正例（如"诚实回答"），xi−​ 表示概念负例（如"欺骗性回答"），控制向量 vc​ 通过平均激活差异计算获得：

vc​=N1​i=1∑N​(h(xi+​)−h(xi−​))

其中 h(x)∈Rd 表示输入 x 在特定层隐藏状态的激活向量。该向量捕获了概念在表示空间中的方向，其范数反映概念激活强度。

Activation Addition（ActAdd）技术通过在推理过程中注入控制向量实现行为调制。对于生成步骤 t ，标准的前向传播计算为：

ht​=Transformer(x<t​)

引入控制向量后，修改后的隐藏状态为：

ht′​=ht​+α⋅vc​

其中标量 α 控制干预强度。后续层计算基于 ht′​ 进行，导致生成分布向目标概念方向偏移。

在诚实性控制应用中，对比数据集构建遵循特定协议。正例包含真实陈述与正确事实，负例包含已知谎言或虚构信息。提取的控制向量在TruthfulQA评测中显著提升模型真实性指标，同时通过正交投影保持模型有用性（Helpfulness）维度不变：

vc⊥​=vc​−∥vh​∥2vc​⋅vh​​vh​

其中 vh​ 表示有用性方向向量。

7.1.2.2 思维链忠实性评估

思维链（Chain-of-Thought, CoT）提示技术通过显式生成中间推理步骤增强大语言模型在复杂任务上的表现。然而，推理步骤与最终答案间的逻辑一致性并非必然保证，存在推理步骤跳跃、计算幻觉等忠实性缺陷。

逻辑一致性检查框架将CoT推理形式化为有向无环图验证问题。对于数学问题 Q 与生成推理链 R=(r1​,r2​,...,rk​,a) ，其中 ri​ 表示第 i 步推理，a 表示最终答案，验证器独立评估每步推理的有效性：

Valid(ri​)=I[fverifier​(ri​,{rj​}j<i​)=consistent]

验证器可采用独立模型或基于规则的方法，检查数学运算正确性与逻辑蕴涵关系。

跳步检测（Skipped Step Detection）通过分析推理链的完备性实现。对于需要 n 步基础操作的问题，统计CoT中显式声明的中间计算步骤数 k 。当 k<n 时，标记存在潜在跳步，提示模型可能依赖模式匹配而非真实推理：

SkipScore=1−nk​

幻觉计算检测（Hallucinated Calculation Detection）聚焦于数值推理的准确性。提取CoT中声明的数值结果 vstated​ ，与基于上下文独立计算的结果 vcomputed​ 对比：

Hallucination=∣vstated​−vcomputed​∣>ϵ

Compositionality Gap的量化揭示了模型在分布外泛化的局限。通过构建需要多步组合推理的测试集，测量CoT正确率与单步正确率的差异：

Gap=E[CoT Correct]−i=1∏n​P(Step i Correct)

该指标反映模型在保持长程依赖与累积误差控制方面的能力边界。

7.1.2.3 模型内部搜索机制

模型内部搜索机制揭示了生成式模型在输出token前进行前瞻性评估的认知特性。与标准自回归模型的即时预测不同，内部前瞻（Internal Look-Ahead）假设模型通过内部模拟评估未来生成选项，优化当前决策。

隐藏状态前瞻分析通过训练探针（Probe）预测未来位置 token 实现。对于位置 t 的隐藏状态 ht​ ，训练独立分类器预测 t+Δ 位置的 token 分布：

P(xt+Δ​∣ht​)=Softmax(WΔ​⋅ht​+bΔ​)

其中 Δ∈{1,2,...,k} 表示前瞻窗口。当探针在 Δ>1 时显著优于随机基线，表明当前隐藏状态编码了未来生成计划的信息。

Phantom Tokens假说提出模型在生成过程中维护未输出但已规划的 token 表示。在代码生成任务中，分析表明模型在输出当前代码行前，隐藏状态已包含后续5-10个token的语法结构信息。这种内部模拟通过注意力机制的前向引用实现：

Attentiont→t+j​=∑i​exp(Qt​KiT​/d​)exp(Qt​Kt+jT​/d​)​

即使在 t+j 位置尚未生成时，键向量 Kt+j​ 已通过上层解码器的前向传播被预先计算。

内部搜索的因果验证通过干预实验实现。在位置 t 注入噪声干扰前瞻信息，观测对位置 t+Δ 生成质量的影响：

ht′​=ht​+ϵ,ϵ∼N(0,σ2I)

若噪声注入导致后续位置生成困惑度显著上升，证明位置 t 的表示确实参与了未来token的规划计算。

---

第二部分：结构化伪代码

算法6：Control Vectors提取与ActAdd干预

plain

复制

Algorithm RepresentationEngineeringControl
Input: Model M, Contrast pairs C = {(x_i^+, x_i^-)}_{i=1}^N, 
       Layer set L, Coefficient α
Output: Control vectors {v_l}_{l∈L}, Modified model behavior

1.  For each layer l ∈ L do
2.      Initialize accumulator v_l ← 0 ∈ ℝ^d
3.      For each pair (x^+, x^-) ∈ C do
4.          h^+ ← M.getHidden(x^+, layer=l)
5.          h^- ← M.getHidden(x^-, layer=l)
6.          v_l ← v_l + (h^+ - h^-)
7.      End for
8.      v_l ← v_l / N  // average difference
9.      v_l ← v_l / ||v_l||  // normalize
10. End for

11. Function ActAddIntervention(M, prompt x, control v_l, strength α)
12.     For each generation step t do
13.         h_t ← M.forward(x_{<t}, layer=l)
14.         h_t' ← h_t + α · v_l
15.         logits ← M.continueFrom(h_t', layer=l)
16.         x_t ← Sample(logits)
17.         x ← x ⊕ x_t  // append token
18.     End for
19.     Return generated sequence

20. Function EvaluateTruthfulness(M, v_l, D_{TruthfulQA})
21.     acc_{base} ← Accuracy(M, D_{TruthfulQA})
22.     M' ← M with ActAdd intervention using v_l
23.     acc_{ctrl} ← Accuracy(M', D_{TruthfulQA})
24.     Return acc_{ctrl} - acc_{base}

算法7：CoT逻辑一致性验证

plain

复制

Algorithm CoTFaithfulnessVerification
Input: CoT reasoning R = (r_1,...,r_k, a), Question Q, 
       Verifier model V
Output: Consistency score s ∈ [0,1], Error flags F

1.  Initialize F ← ∅, s ← 0
2.  Extract all numerical claims N ← ExtractNumbers(R)
3.  
4.  // Step-by-step verification
5.  For i ← 1 to k do
6.      context ← Q ⊕ (r_1,...,r_{i-1})
7.      claim_i ← ExtractClaim(r_i)
8.      
9.      // Independent computation
10.     computed ← V.verify(context, claim_i)
11.     stated ← GetValue(claim_i)
12.     
13.     If |computed - stated| > ε then
14.         F ← F ∪ {(i, "numerical_error")}
15.     End if
16.     
17.     // Logical entailment check
18.     If not V.entails(context, claim_i) then
19.         F ← F ∪ {(i, "logical_gap")}
20.     End if
21. End for

22. // Final answer consistency
23. derived ← ComputeFromSteps({r_i}_{i=1}^k)
24. If derived ≠ a then
25.     F ← F ∪ {("final", "answer_mismatch")}
26. End if

27. s ← 1 - |F|/k
28. Return s, F

算法8：内部前瞻机制检测

plain

复制

Algorithm InternalLookAheadDetection
Input: Model M, Dataset D_{code}, Horizon K
Output: Probing accuracies {acc_Δ}_{Δ=1}^K, Causal effects E

1.  For each Δ ∈ {1,...,K} do
2.      Train probe P_Δ: ℝ^d → Vocabulary
3.      Initialize correct ← 0, total ← 0
4.      
5.      For each sequence x ∈ D_{code} do
6.          For t ← 1 to |x|-Δ do
7.              h_t ← M.getHidden(x_{<t}, layer=8)
8.              pred ← P_Δ(h_t)
9.              actual ← x_{t+Δ}
10.             If pred = actual then
11.                 correct ← correct + 1
12.             End if
13.             total ← total + 1
14.         End for
15.     End for
16.     acc_Δ ← correct / total
17. End for

18. // Causal intervention
19. Function CausalValidation(M, D, Δ)
20.     E ← 0
21.     For each x ∈ D do
22.         For t ← 1 to |x|-Δ do
23.             // Clean run
24.             h_t ← M.getHidden(x_{<t})
25.             p_clean ← M.predict(x_{t+Δ} | h_t)
26.             
27.             // Corrupted run
28.             h_t' ← h_t + ε, ε ∼ 𝒩(0, σ²I)
29.             p_corrupt ← M.predict(x_{t+Δ} | h_t')
30.             
31.             E ← E + |log p_clean - log p_corrupt|
32.         End for
33.     End for
34.     Return E / |D|