ERNIE-4.5-0.3B-PT模型解释性分析工具使用指南

ERNIE-4.5-0.3B-PT模型解释性分析工具使用指南

你是不是经常好奇，大语言模型到底是怎么“思考”的？为什么输入一段文字，它就能生成那么贴切的回复？今天我们就来聊聊这个话题，带你一步步揭开ERNIE-4.5-0.3B-PT这个模型的神秘面纱。

解释性分析，说白了就是给模型装个“透视镜”，看看它内部到底在干什么。这对于开发者来说特别有用，能帮你理解模型为什么做出某个决策，发现潜在的问题，甚至优化模型的性能。接下来，我会手把手教你如何使用几种实用的解释性分析工具，让你也能看懂模型的“内心戏”。

1. 环境准备与模型加载

在开始分析之前，我们得先把环境搭好，把模型加载进来。这个过程其实很简单，跟着步骤走就行。

1.1 安装必要的库

首先，我们需要安装几个关键的Python库。打开你的终端或者命令行工具，执行下面的命令：

pip install transformers torch matplotlib seaborn numpy

如果你想要更丰富的可视化效果，还可以安装一些额外的库：

pip install plotly gradio

这些库的作用分别是：

• transformers：Hugging Face的模型库，用来加载和操作模型
• torch：PyTorch深度学习框架
• matplotlib/seaborn：数据可视化工具
• numpy：数值计算库
• plotly/gradio：交互式可视化工具（可选）

1.2 加载ERNIE-4.5-0.3B-PT模型

模型加载的代码很简单，几行就能搞定：

from transformers import AutoModelForCausalLM, AutoTokenizer # 指定模型名称 model_name = "baidu/ERNIE-4.5-0.3B-PT" # 加载分词器 tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) # 加载模型 model = AutoModelForCausalLM.from_pretrained( model_name, trust_remote_code=True, output_attentions=True, # 这个参数很重要，告诉模型要输出注意力权重 output_hidden_states=True # 这个参数告诉模型要输出隐藏状态 ) # 把模型设置为评估模式 model.eval() print("模型加载成功！")

这里有几个关键点需要注意：

1. trust_remote_code=True：ERNIE模型需要这个参数才能正确加载
2. output_attentions=True：这个参数必须设置为True，否则拿不到注意力权重
3. output_hidden_states=True：这个参数让我们能获取隐藏状态
4. model.eval()：把模型设置为评估模式，这样不会进行训练相关的操作

1.3 准备测试文本

我们先准备一些测试文本，用来观察模型的行为：

# 准备几个测试句子 test_texts = [ "今天天气真好，适合去公园散步。", "人工智能正在改变我们的生活。", "北京是中国的首都，有着悠久的历史。" ] # 对文本进行分词 inputs = tokenizer(test_texts[0], return_tensors="pt", padding=True, truncation=True) print(f"分词结果：{inputs}") print(f"输入ID：{inputs['input_ids']}") print(f"对应的文本：{tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])}")

运行这段代码，你会看到文本被分成了一个个的token（可以理解为词语或字）。这是模型理解文本的第一步。

2. 注意力可视化：看看模型在关注什么

注意力机制是大语言模型的核心，它决定了模型在处理每个词时，会关注上下文中的哪些词。可视化注意力权重，就像给模型装了个“注意力追踪器”。

2.1 获取注意力权重

首先，我们让模型处理一段文本，并获取它的注意力权重：

import torch # 禁用梯度计算，节省内存 with torch.no_grad(): outputs = model(**inputs) # 获取注意力权重 # outputs.attentions是一个元组，每个元素对应一个注意力层的权重 attentions = outputs.attentions print(f"总共有 {len(attentions)} 个注意力层") print(f"每个注意力层的形状：{attentions[0].shape}")

注意力权重的形状通常是(batch_size, num_heads, sequence_length, sequence_length)，意思是：

• batch_size：批处理大小，我们这里是1
• num_heads：注意力头的数量，ERNIE-4.5-0.3B有16个注意力头
• sequence_length：序列长度，就是文本被分成了多少个token

2.2 可视化单个注意力头的注意力图

让我们看看第一个注意力层、第一个注意力头的注意力分布：

import matplotlib.pyplot as plt import numpy as np # 获取第一个样本、第一个注意力层、第一个注意力头的注意力权重 attention_layer = 0 # 第一层 attention_head = 0 # 第一个头 attention_weights = attentions[attention_layer][0, attention_head].numpy() # 获取token文本 tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0]) # 创建热力图 plt.figure(figsize=(10, 8)) plt.imshow(attention_weights, cmap='viridis', aspect='auto') plt.colorbar(label='注意力权重') plt.xticks(range(len(tokens)), tokens, rotation=45, ha='right') plt.yticks(range(len(tokens)), tokens) plt.title(f'第{attention_layer+1}层 第{attention_head+1}个注意力头的注意力权重') plt.xlabel('Key Tokens (被关注的词)') plt.ylabel('Query Tokens (正在处理的词)') plt.tight_layout() plt.show()

运行这段代码，你会看到一个热力图。图中每个格子表示一个词对另一个词的关注程度。颜色越亮（黄色），表示关注度越高；颜色越暗（紫色），表示关注度越低。

2.3 理解注意力图

怎么看懂这个图呢？我举个例子：

假设我们处理的是“今天天气真好”这句话：

• 当模型处理“天气”这个词时（Query），它可能会高度关注“今天”和“真好”（Key）
• 当模型处理“真好”时，它可能会关注“天气”
• 对角线通常比较亮，因为每个词都会关注自己

你可以尝试不同的层和头，看看它们关注的重点有什么不同。一般来说：

• 底层（前几层）：更多关注局部信息，比如相邻的词
• 高层（后几层）：更多关注全局信息和语义关系

2.4 可视化所有注意力头的平均注意力

有时候我们想看看整体趋势，可以计算所有注意力头的平均值：

# 计算第一个注意力层所有头的平均注意力 avg_attention = attentions[0][0].mean(dim=0).numpy() plt.figure(figsize=(10, 8)) plt.imshow(avg_attention, cmap='viridis', aspect='auto') plt.colorbar(label='平均注意力权重') plt.xticks(range(len(tokens)), tokens, rotation=45, ha='right') plt.yticks(range(len(tokens)), tokens) plt.title('第一层所有注意力头的平均注意力权重') plt.xlabel('Key Tokens') plt.ylabel('Query Tokens') plt.tight_layout() plt.show()

这个图能给你一个整体的印象，看看模型在处理这段文本时，整体的关注模式是什么样的。

3. 特征重要性分析：找出关键影响因素

除了看注意力，我们还可以分析哪些特征（token）对模型的决策最重要。这就像找出影响模型判断的关键因素。

3.1 基于梯度的特征重要性分析

这种方法通过计算梯度来判断每个输入token的重要性：

# 启用梯度计算 model.zero_grad() inputs['input_ids'].requires_grad = True # 前向传播 outputs = model(**inputs) # 取最后一个token的logits作为目标 logits = outputs.logits[0, -1, :] # 选择概率最高的token作为目标 target_token_id = torch.argmax(logits).item() # 计算梯度 loss = torch.nn.functional.cross_entropy(logits.unsqueeze(0), torch.tensor([target_token_id])) loss.backward() # 获取梯度 gradients = inputs['input_ids'].grad[0].abs().numpy() tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0]) # 可视化 plt.figure(figsize=(12, 6)) bars = plt.bar(range(len(tokens)), gradients) plt.xticks(range(len(tokens)), tokens, rotation=45, ha='right') plt.title('基于梯度的特征重要性分析') plt.xlabel('Token') plt.ylabel('梯度绝对值（重要性）') plt.tight_layout() # 给重要性最高的几个token标色 max_grad_idx = np.argsort(gradients)[-3:] # 取最重要的3个 for idx in max_grad_idx: bars[idx].set_color('red') plt.show() print("最重要的几个token：") for idx in max_grad_idx: print(f" '{tokens[idx]}' (重要性: {gradients[idx]:.4f})")

这种方法的基本思想是：如果一个token的梯度很大，说明模型对这个token很敏感，改变它会对输出产生很大影响。

3.2 基于注意力权重的特征重要性

我们也可以直接从注意力权重中提取特征重要性：

# 计算每个token作为Query时接收到的总注意力 # 对每个Query token，把它对所有Key token的注意力求和 importance_scores = [] for i, token in enumerate(tokens): # 计算其他所有token对这个token的注意力总和 # 注意：我们看的是其他token对这个token的关注，而不是这个token对其他token的关注 attention_to_token = 0 for layer_idx in range(len(attentions)): # 取所有注意力头的平均值 layer_attention = attentions[layer_idx][0].mean(dim=0) # 其他所有token对这个token的注意力（排除自己对自己的注意力） attention_from_others = layer_attention[:, i].sum() - layer_attention[i, i] attention_to_token += attention_from_others.item() importance_scores.append(attention_to_token) # 归一化 importance_scores = np.array(importance_scores) importance_scores = importance_scores / importance_scores.sum() # 可视化 plt.figure(figsize=(12, 6)) bars = plt.bar(range(len(tokens)), importance_scores) plt.xticks(range(len(tokens)), tokens, rotation=45, ha='right') plt.title('基于注意力权重的特征重要性') plt.xlabel('Token') plt.ylabel('重要性分数') plt.tight_layout() # 标出最重要的token max_importance_idx = np.argsort(importance_scores)[-3:] for idx in max_importance_idx: bars[idx].set_color('orange') plt.show() print("\n基于注意力权重的关键token：") for idx in max_importance_idx: print(f" '{tokens[idx]}' (重要性: {importance_scores[idx]:.4f})")

这种方法反映了每个token在上下文中的“受关注程度”，被关注越多的token通常越重要。

4. 隐藏状态分析：深入模型内部

隐藏状态是模型在每一层处理后的中间表示，分析它们能让我们了解信息是如何在模型中流动和变化的。

4.1 获取和分析隐藏状态

# 获取所有层的隐藏状态 hidden_states = outputs.hidden_states print(f"隐藏状态数量（包括输入嵌入）：{len(hidden_states)}") print(f"每层隐藏状态的形状：{hidden_states[0].shape}") # 隐藏状态包括： # - 第0层：输入嵌入（embedding） # - 第1到N层：每个Transformer层的输出

4.2 可视化隐藏状态的相似性

我们可以计算不同层之间隐藏状态的相似性，看看信息是如何变化的：

from sklearn.metrics.pairwise import cosine_similarity # 取第一个token在所有层的隐藏状态 token_idx = 2 # 比如取第三个token layer_representations = [] for layer_idx in range(len(hidden_states)): # 获取该层第一个样本、指定token的隐藏状态 hidden_state = hidden_states[layer_idx][0, token_idx].detach().numpy() layer_representations.append(hidden_state) # 计算层与层之间的余弦相似度 similarity_matrix = np.zeros((len(layer_representations), len(layer_representations))) for i in range(len(layer_representations)): for j in range(len(layer_representations)): sim = cosine_similarity( layer_representations[i].reshape(1, -1), layer_representations[j].reshape(1, -1) )[0, 0] similarity_matrix[i, j] = sim # 可视化相似性矩阵 plt.figure(figsize=(10, 8)) plt.imshow(similarity_matrix, cmap='YlOrRd', vmin=0, vmax=1) plt.colorbar(label='余弦相似度') plt.title(f"Token '{tokens[token_idx]}' 在不同层的表示相似性") plt.xlabel('层索引') plt.ylabel('层索引') plt.xticks(range(len(hidden_states))) plt.yticks(range(len(hidden_states))) # 添加相似度数值 for i in range(len(hidden_states)): for j in range(len(hidden_states)): plt.text(j, i, f'{similarity_matrix[i, j]:.2f}', ha='center', va='center', color='black', fontsize=8) plt.tight_layout() plt.show()

这个图能告诉我们：

• 对角线：自己和自己比较，相似度应该是1
• 相邻层：通常相似度较高，因为变化不大
• 相隔较远的层：相似度可能较低，表示信息发生了较大变化

4.3 分析隐藏状态的维度重要性

我们还可以看看隐藏状态的哪些维度最重要：

# 计算最后一个隐藏层所有token的隐藏状态 last_hidden_state = hidden_states[-1][0].detach().numpy() # 形状: (seq_len, hidden_size) # 计算每个维度的方差（方差大的维度可能包含更多信息） dimension_variances = np.var(last_hidden_state, axis=0) top_dim_indices = np.argsort(dimension_variances)[-10:] # 取方差最大的10个维度 plt.figure(figsize=(12, 6)) plt.bar(range(10), dimension_variances[top_dim_indices]) plt.xticks(range(10), [f'Dim {idx}' for idx in top_dim_indices], rotation=45) plt.title('隐藏状态方差最大的10个维度') plt.xlabel('维度索引') plt.ylabel('方差') plt.tight_layout() plt.show() print("信息量最大的维度（方差最大）：") for idx in top_dim_indices[::-1]: # 从大到小排序 print(f" 维度 {idx}: 方差 = {dimension_variances[idx]:.6f}")

5. 实用技巧与进阶分析

掌握了基础分析方法后，我们来看看一些实用技巧和进阶方法。

5.1 对比不同输入的分析结果

比较模型对不同输入的处理方式，能帮助我们理解模型的偏好和模式：

def analyze_text(text): """分析单条文本的函数""" inputs = tokenizer(text, return_tensors="pt") with torch.no_grad(): outputs = model(**inputs, output_attentions=True, output_hidden_states=True) # 计算平均注意力（最后一层，所有头的平均） last_layer_attention = outputs.attentions[-1][0].mean(dim=0) avg_attention = last_layer_attention.mean(dim=0).numpy() # 对Query维度平均 return avg_attention # 分析多个文本 texts = [ "猫在沙发上睡觉", "狗在公园里奔跑", "人工智能学习算法" ] results = [] for text in texts: attention = analyze_text(text) results.append({ 'text': text, 'attention': attention, 'avg_attention_strength': attention.mean() # 平均注意力强度 }) # 比较结果 print("不同文本的平均注意力强度比较：") for result in results: print(f" 文本: {result['text'][:20]}...") print(f" 平均注意力强度: {result['avg_attention_strength']:.4f}") print()

5.2 创建交互式分析工具

如果你想要更直观的体验，可以创建一个简单的交互界面：

import gradio as gr def interactive_analysis(text, layer_idx, head_idx): """交互式分析函数""" inputs = tokenizer(text, return_tensors="pt") with torch.no_grad(): outputs = model(**inputs, output_attentions=True) # 获取指定层和头的注意力 attention = outputs.attentions[layer_idx][0, head_idx].numpy() tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0]) # 创建热力图 fig, ax = plt.subplots(figsize=(10, 8)) im = ax.imshow(attention, cmap='viridis', aspect='auto') plt.colorbar(im, ax=ax, label='注意力权重') ax.set_xticks(range(len(tokens))) ax.set_xticklabels(tokens, rotation=45, ha='right') ax.set_yticks(range(len(tokens))) ax.set_yticklabels(tokens) ax.set_title(f'第{layer_idx+1}层 第{head_idx+1}头 注意力可视化') ax.set_xlabel('Key Tokens') ax.set_ylabel('Query Tokens') plt.tight_layout() return fig # 创建Gradio界面（注释掉，因为需要实际运行Gradio） """ # 定义输入组件 text_input = gr.Textbox(label="输入文本", value="今天天气真好") layer_input = gr.Slider(minimum=0, maximum=len(model.config.num_hidden_layers)-1, value=0, step=1, label="层索引") head_input = gr.Slider(minimum=0, maximum=model.config.num_attention_heads-1, value=0, step=1, label="注意力头索引") # 创建界面 iface = gr.Interface( fn=interactive_analysis, inputs=[text_input, layer_input, head_input], outputs="plot", title="ERNIE模型注意力可视化工具", description="输入文本，选择层和注意力头，查看注意力权重分布" ) iface.launch() """

5.3 批量分析脚本

如果你需要分析大量文本，这个批量脚本会很有用：

import json from tqdm import tqdm def batch_analysis(texts, output_file="analysis_results.json"): """批量分析多个文本""" results = [] for text in tqdm(texts, desc="分析进度"): inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512) with torch.no_grad(): outputs = model(**inputs, output_attentions=True, output_hidden_states=True) # 提取关键信息 result = { 'text': text, 'tokens': tokenizer.convert_ids_to_tokens(inputs['input_ids'][0]), 'attention_patterns': {}, 'hidden_state_stats': {} } # 保存每层的平均注意力 for layer_idx, attention in enumerate(outputs.attentions): avg_attention = attention[0].mean(dim=0).mean(dim=0).numpy().tolist() # 平均所有头和Query result['attention_patterns'][f'layer_{layer_idx}'] = avg_attention # 保存隐藏状态的统计信息 for layer_idx, hidden_state in enumerate(outputs.hidden_states): hidden_np = hidden_state[0].detach().numpy() result['hidden_state_stats'][f'layer_{layer_idx}'] = { 'mean': float(hidden_np.mean()), 'std': float(hidden_np.std()), 'min': float(hidden_np.min()), 'max': float(hidden_np.max()) } results.append(result) # 保存结果 with open(output_file, 'w', encoding='utf-8') as f: json.dump(results, f, ensure_ascii=False, indent=2) print(f"分析完成，结果已保存到 {output_file}") return results # 使用示例 sample_texts = [ "机器学习是人工智能的重要分支", "深度学习在图像识别中表现出色", "自然语言处理让计算机理解人类语言" ] # 运行批量分析（注释掉，避免实际运行） # batch_results = batch_analysis(sample_texts, "sample_analysis.json")

6. 常见问题与解决方案

在实际使用中，你可能会遇到一些问题。这里我整理了几个常见问题和解决方法：

问题1：内存不足

• 症状：运行分析时程序崩溃或报内存错误
• 原因：注意力权重和隐藏状态很占内存，特别是长文本
• 解决方案：

  # 1. 限制文本长度 max_length = 128 # 根据你的内存调整 inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=max_length) # 2. 分析时只保留需要的层 with torch.no_grad(): outputs = model(**inputs, output_attentions=True, output_hidden_states=True) # 只分析特定层，而不是所有层 layers_to_analyze = [0, 5, 10, -1] # 分析第1、6、11层和最后一层 selected_attentions = [outputs.attentions[i] for i in layers_to_analyze]

问题2：分析结果难以理解

• 症状：注意力图看起来杂乱无章，没有明显模式
• 原因：可能文本太短或太简单，或者选择了不合适的层/头
• 解决方案：
  1. 尝试更复杂的文本
  2. 多试几个不同的层和注意力头
  3. 使用平均注意力而不是单个头的注意力
  4. 对注意力权重进行归一化处理：

  # 对每个Query的注意力进行softmax归一化 attention_weights = attentions[0][0, 0].numpy() normalized_attention = np.exp(attention_weights) / np.sum(np.exp(attention_weights), axis=1, keepdims=True)

问题3：分析速度太慢

• 症状：处理一个文本要等很久
• 原因：模型较大，或者文本太长
• 解决方案：
  1. 使用GPU加速（如果有的话）
  2. 减少分析的层数
  3. 对长文本进行分段分析
  4. 使用更轻量级的分析方法

问题4：不同运行结果不一致

• 症状：同样的输入，两次分析结果略有不同
• 原因：可能是模型中的dropout还在生效
• 解决方案：

  # 确保模型在评估模式 model.eval() # 并且禁用dropout with torch.no_grad(): outputs = model(**inputs)

7. 总结

走完这一趟ERNIE-4.5-0.3B-PT的解释性分析之旅，你应该对模型内部的工作机制有了更直观的认识。注意力可视化让我们看到了模型在处理文本时的“关注点”，特征重要性分析帮我们找出了影响模型决策的关键因素，而隐藏状态分析则让我们深入到了模型的“思维过程”中。

实际用下来，这些工具在调试模型、理解模型行为、甚至发现模型偏见方面都挺有用的。比如你可以看看模型在处理某些敏感话题时，注意力都集中在哪些词上，或者分析为什么模型会对某些输入产生奇怪的输出。

如果你刚开始接触这块，建议先从简单的文本和基础分析开始，慢慢熟悉各种工具的使用。遇到问题也不用担心，多试试不同的方法和参数，很多时候调整一下分析的角度就能得到更清晰的结果。

解释性分析这个领域还在快速发展，新的工具和方法不断出现。保持好奇心，多动手实践，你会越来越擅长理解和分析这些复杂的大模型。毕竟，能看懂模型的“思考过程”，在优化和使用模型时会有很大优势。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。