大模型可解释性研究：我们能看到模型在想什么

┌─────────────────────────────────────────────────────┐
│              可解释性层次                             │
├─────────────────────────────────────────────────────┤
│                                                     │
│  Level 0: 黑箱 (Black Box)                          │
│  只知道输入输出, 内部完全未知                        │
│                                                     │
│  Level 1: 行为可解释 (Behavioral)                   │
│  知道模型在不同输入下的行为模式                      │
│  方法: 探测, 对抗样本, 行为测试                     │
│                                                     │
│  Level 2: 注意力可解释 (Attention)                  │
│  知道模型关注输入的哪些部分                          │
│  方法: 注意力可视化, 激活最大化                     │
│                                                     │
│  Level 3: 机械可解释 (Mechanistic)                  │
│  知道模型内部的计算电路                              │
│  方法: 电路分析, 因果追踪, SAE                      │
│                                                     │
│  Level 4: 完全理解 (Full Understanding)             │
│  完全理解模型的每一个计算步骤                        │
│  (尚未达到)                                         │
│                                                     │
└─────────────────────────────────────────────────────┘

def visualize_attention(model, text, layer=0, head=0):
    """可视化特定层和头的注意力模式"""
    outputs = model(text, output_attentions=True)
    attention = outputs.attentions[layer][0, head]  # [seq, seq]
    
    # 绘制热力图
    plt.figure(figsize=(12, 10))
    sns.heatmap(attention.detach().numpy(),
                xticklabels=text.split(),
                yticklabels=text.split(),
                cmap='YlOrRd')
    plt.title(f'Layer {layer}, Head {head}')
    plt.show()

模式: A B ... A → B (如果A出现后跟着B, 下次看到A就预测B)

Induction Head 的工作方式:
  当前 Token: A
  搜索之前出现的 A
  注意 A 后面的 Token (B)
  预测: B

class CircuitAnalyzer:
    """分析模型内部的计算电路"""
    
    def find_circuit(self, model, input_pattern):
        """找到处理特定模式的电路"""
        # 1. 识别活跃的神经元
        activations = self.get_activations(model, input_pattern)
        active_neurons = self.select_active(activations, threshold=0.5)
        
        # 2. 追踪信息流
        edges = self.trace_information_flow(model, active_neurons)
        
        # 3. 构建电路图
        circuit = self.build_circuit(active_neurons, edges)
        
        # 4. 验证电路
        verified = self.verify_circuit(model, circuit, input_pattern)
        
        return circuit

"Alice gave Bob the book because she wanted him to read it."

IOI 电路的工作流程:
  1. Previous Token Heads: 标记每个 Token 的前驱
  2. Induction Heads: 识别代词指代
  3. S-Inhibition Heads: 抑制主语
  4. Name Mover Heads: 将正确的名字"移动"到输出

  整个电路: ~26个注意力头协作完成 IOI 任务

class SparseAutoencoder(nn.Module):
    def __init__(self, input_dim, feature_dim, sparsity=0.99):
        super().__init__()
        self.encoder = nn.Linear(input_dim, feature_dim)  # 扩展
        self.decoder = nn.Linear(feature_dim, input_dim)  # 压缩
        self.sparsity = sparsity
    
    def forward(self, x):
        # 编码到高维稀疏空间
        features = F.relu(self.encoder(x))
        
        # L1 稀疏约束
        l1_loss = features.abs().sum(-1).mean()
        
        # 重建
        reconstructed = self.decoder(features)
        
        return reconstructed, features, l1_loss

多义性 (Polysemantic):
  神经元 N1: 在"猫"出现时激活, 也在"代码缩进"出现时激活
  → 一个神经元编码多个不相关概念 (叠加)

单义性 (Monosemantic):
  特征 F1: 只在"猫"出现时激活
  特征 F2: 只在"代码缩进"时激活
  → 每个特征只编码一个概念 (清晰)

SAE 将叠加的多义表示分解为清晰的单义特征

class LinearProbe:
    def __init__(self, hidden_dim, num_classes):
        self.classifier = nn.Linear(hidden_dim, num_classes)
    
    def train(self, hidden_states, labels):
        """在冻结的隐藏状态上训练探针"""
        for epoch in range(100):
            logits = self.classifier(hidden_states)
            loss = F.cross_entropy(logits, labels)
            loss.backward()
    
    def evaluate(self, hidden_states, labels):
        """评估隐藏状态中包含多少信息"""
        with torch.no_grad():
            logits = self.classifier(hidden_states)
            accuracy = (logits.argmax(-1) == labels).float().mean()
        return accuracy

def causal_intervention(model, hidden_state, probe, concept_direction):
    """通过修改隐藏状态来验证因果关系"""
    # 1. 获取原始预测
    original_output = model.lm_head(hidden_state)
    
    # 2. 沿概念方向修改隐藏状态
    modified_state = hidden_state + alpha * concept_direction
    
    # 3. 获取修改后的预测
    modified_output = model.lm_head(modified_state)
    
    # 4. 比较差异
    change = modified_output - original_output
    return change

class BackdoorDetector:
    """检测模型中植入的后门"""
    def detect(self, model, trigger_patterns):
        for pattern in trigger_patterns:
            # 分析触发模式激活的电路
            circuit = self.analyze_circuit(model, pattern)
            
            # 检查是否有异常的短路路径
            if self.has_shortcircuit(circuit):
                print(f"警告: 检测到可能的后门触发器: {pattern}")

class HallucinationDetector:
    """通过内部状态检测幻觉"""
    def __init__(self):
        self.confidence_probe = LinearProbe(hidden_dim, 2)  # 确信/不确定
    
    def detect(self, model, input_text):
        hidden_states = model.get_hidden_states(input_text)
        
        # 逐 Token 检测确信度
        confidences = []
        for h in hidden_states:
            conf = self.confidence_probe.predict(h)
            confidences.append(conf)
        
        # 标记低确信度的 Token 为潜在幻觉
        hallucination_mask = [c < 0.5 for c in confidences]
        return hallucination_mask

def verify_alignment(model, safety_features):
    """验证模型是否正确对齐"""
    for feature_name, direction in safety_features.items():
        # 检查安全相关特征是否被正确激活
        activation = get_feature_activation(model, direction)
        
        if activation < threshold:
            print(f"警告: 安全特征 '{feature_name}' 激活不足")

# 通过可解释性发现的问题 → 改进模型
def improve_model_with_interpretability(model):
    # 1. 找到产生幻觉的电路
    halluc_circuit = find_hallucination_circuit(model)
    
    # 2. 找到导致偏见的特征
    bias_features = find_bias_features(model)
    
    # 3. 微调以修正这些问题
    for feature in bias_features:
        # 降低偏见特征的权重
        model = reduce_feature_weight(model, feature)
    
    # 4. 增强安全电路
    model = strengthen_circuit(model, 'refusal_circuit')
    
    return model