1 课程概述
1.1 课程定位
01.课程简介
本课程系统讲解自然语言处理(NLP)技术，从基础的文本处理到大语言模型，涵盖词向量、序列模型、Transformer、预训练模型、微调技术等核心内容。课程注重理论与实践结合，每个概念都配有完整的代码实现和详细的原理解释。
02.适用人群
a.有深度学习基础的开发者
具备神经网络基础知识，希望转向NLP领域的软件开发者
b.希望从事NLP相关工作的工程师
目标岗位为NLP工程师、算法工程师的技术从业者
c.对大语言模型感兴趣的研究人员
关注LLM技术发展，需要深入理解模型原理的研究者
d.需要处理文本数据的数据科学家
在工作中需要分析和处理大量文本数据的专业人士
03.课程特色
a.理论与实践结合
a.理论基础
详细的数学原理推导，包括梯度计算、注意力机制、Transformer架构等核心概念的深入解析
b.代码实现
每个理论点都有对应的PyTorch代码实现，从零开始构建模型，理解内部机制
b.代码示例
---
# NLP课程代码示例结构
import torch
import torch.nn as nn
import numpy as np
class TextProcessor:
def __init__(self, vocab_size, embed_dim):
self.embedding = nn.Embedding(vocab_size, embed_dim)
self.vocab_size = vocab_size
self.embed_dim = embed_dim
def preprocess(self, text):
# 文本预处理示例
tokens = text.lower().split()
return [self.vocab_to_id.get(token, 0) for token in tokens]
def embed_text(self, token_ids):
# 词嵌入示例
return self.embedding(torch.tensor(token_ids))
---
b.循序渐进
a.知识体系完整
从基础概念到前沿技术，构建完整的NLP知识体系
b.难度递增合理
每章内容在前一章基础上扩展，确保学习曲线平滑
c.实践项目渐进
代码示例从简单到复杂，逐步提升工程能力
c.代码密度高
a.每个概念都有代码
理论讲解后立即提供对应的代码实现
b.完整可运行
所有代码示例都经过测试，可以直接运行
c.详细注释
代码包含详细的中文注释，解释每个步骤的作用
d.紧跟前沿
a.最新技术覆盖
包括最新的LLM技术、微调方法、Prompt工程等
b.实战项目导向
基于实际业务场景设计项目，提升实战能力
c.持续更新
根据技术发展动态更新课程内容
e.就业导向
a.岗位需求匹配
课程内容对标企业NLP岗位实际需求
b.面试准备
包含常见面试题和解答技巧
c.项目经验积累
通过实战项目积累可展示的项目经验
04.学习路径规划
a.阶段一：基础建立（2-3周）
掌握NLP基础概念和文本处理技术
b.阶段二：核心技术（3-4周）
学习序列模型和Transformer架构
c.阶段三：预训练模型（2-3周）
掌握BERT、GPT等预训练模型使用
d.阶段四：前沿技术（2-3周）
了解大语言模型和微调技术
e.阶段五：实战项目（2-3周）
完成端到端的NLP项目开发
05.学习保障
a.答疑支持
提供专业的技术答疑和学习指导
b.代码审查
对学员提交的代码进行专业审查和反馈
c.项目指导
提供项目开发过程中的技术指导和建议
d.就业推荐
为优秀学员提供就业推荐和职业规划指导
1.2 学习目标
01.掌握NLP基础技术
a.文本预处理技术
a.数据清洗
掌握去除HTML标签、特殊字符、标准化文本等清洗技术
b.文本标准化
包括大小写转换、标点符号处理、数字归一化等
c.分词技术
理解中英文分词的差异，掌握jieba、spaCy等工具的使用
d.停用词处理
理解停用词的作用和影响，掌握停用词表的构建和使用
b.代码实现示例
---
import re
import jieba
import string
from nltk.corpus import stopwords
class TextPreprocessor:
def __init__(self, language='chinese'):
self.language = language
self.stop_words = self._load_stop_words()
def clean_text(self, text):
# 移除HTML标签
text = re.sub(r'<[^>]+>', '', text)
# 移除特殊字符
text = re.sub(r'[^\w\s]', '', text)
# 移除多余空白
text = re.sub(r'\s+', ' ', text)
return text.strip()
def tokenize(self, text):
if self.language == 'chinese':
return jieba.lcut(text)
else:
return text.lower().split()
def remove_stopwords(self, tokens):
return [token for token in tokens if token not in self.stop_words]
# 使用示例
processor = TextPreprocessor('chinese')
text = "这是一个自然语言处理的示例文本！"
cleaned = processor.clean_text(text)
tokens = processor.tokenize(cleaned)
filtered = processor.remove_stopwords(tokens)
print(f"原始文本: {text}")
print(f"处理后: {filtered}")
---
b.词向量技术深入理解
a.词嵌入原理
理解分布式假说和词向量的数学原理
b.Word2Vec算法
掌握CBOW和Skip-gram两种模型结构
c.GloVe模型
理解全局向量的构建方法
d.FastText技术
学习子词向量和字符n-gram的概念
e.词向量评估
掌握词向量质量的评估方法和指标
f.实践代码示例
---
from gensim.models import Word2Vec, FastText
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
class WordEmbedding:
def __init__(self, model_type='word2vec'):
self.model_type = model_type
self.model = None
def train_word2vec(self, sentences, vector_size=100, window=5):
"""训练Word2Vec模型"""
self.model = Word2Vec(
sentences=sentences,
vector_size=vector_size,
window=window,
min_count=1,
workers=4
)
return self.model
def train_fasttext(self, sentences, vector_size=100):
"""训练FastText模型"""
self.model = FastText(
sentences=sentences,
vector_size=vector_size,
window=5,
min_count=1,
workers=4
)
return self.model
def find_similar_words(self, word, topn=5):
"""查找相似词"""
if word in self.model.wv:
return self.model.wv.most_similar(word, topn=topn)
return []
def word_analogy(self, word1, word2, word3):
"""词汇类比： king - man + woman = queen"""
result = self.model.wv.most_similar(
positive=[word3, word2],
negative=[word1],
topn=1
)
return result[0] if result else None
# 训练示例
sentences = [
['自然语言', '处理', '技术'],
['机器学习', '深度学习', '神经网络'],
['词向量', '嵌入', '表示']
]
embedding = WordEmbedding('word2vec')
model = embedding.train_word2vec(sentences)
# 查找相似词
similar_words = embedding.find_similar_words('自然语言')
print(f"与'自然语言'相似的词: {similar_words}")
---
02.深入理解序列模型
a.RNN/LSTM在NLP中的应用
a.循环神经网络基础
理解RNN的记忆机制和时间步概念
b.LSTM网络结构
掌握门控机制：输入门、遗忘门、输出门
c.GRU单元
理解更新门和重置门的作用
d.序列建模应用
文本分类、序列标注、语言建模等任务
e.代码实现详解
---
import torch
import torch.nn as nn
import torch.optim as optim
class TextClassifier(nn.Module):
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes, num_layers=2):
super(TextClassifier, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim)
self.lstm = nn.LSTM(
embed_dim,
hidden_dim,
num_layers=num_layers,
batch_first=True,
dropout=0.3,
bidirectional=True
)
self.fc = nn.Linear(hidden_dim * 2, num_classes)
self.dropout = nn.Dropout(0.5)
def forward(self, x, lengths):
# x: [batch_size, seq_len]
embedded = self.embedding(x) # [batch_size, seq_len, embed_dim]
# 打包序列，处理变长序列
packed = nn.utils.rnn.pack_padded_sequence(
embedded, lengths, batch_first=True, enforce_sorted=False
)
# LSTM处理
lstm_out, (hidden, _) = self.lstm(packed)
# 解包序列
lstm_out, _ = nn.utils.rnn.pad_packed_sequence(lstm_out, batch_first=True)
# 使用最后一个时间步的输出
# 对于双向LSTM，连接前向和后向的最后输出
forward_last = lstm_out[torch.arange(lstm_out.size(0)), lengths - 1, :hidden.size(2)]
backward_last = lstm_out[:, 0, hidden.size(2):]
last_output = torch.cat([forward_last, backward_last], dim=1)
output = self.dropout(last_output)
logits = self.fc(output)
return logits
# 使用示例
vocab_size = 10000
embed_dim = 300
hidden_dim = 128
num_classes = 5
model = TextClassifier(vocab_size, embed_dim, hidden_dim, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 模拟输入
batch_size = 32
seq_len = 50
x = torch.randint(0, vocab_size, (batch_size, seq_len))
lengths = torch.randint(10, seq_len, (batch_size,))
y = torch.randint(0, num_classes, (batch_size,))
# 前向传播
outputs = model(x, lengths)
loss = criterion(outputs, y)
print(f"模型输出形状: {outputs.shape}")
print(f"损失值: {loss.item():.4f}")
---
b.Seq2Seq架构原理
a.编码器-解码器结构
理解编码器如何将输入序列编码为固定长度向量
b.解码器生成过程
掌握自回归生成和教师强制训练
c.序列到序列应用
机器翻译、文本摘要、对话生成等任务
d.训练技巧
掌握束搜索(Beam Search)、覆盖机制等优化技术
e.完整实现代码
---
class Encoder(nn.Module):
def __init__(self, input_dim, embed_dim, hidden_dim, num_layers):
super(Encoder, self).__init__()
self.embedding = nn.Embedding(input_dim, embed_dim)
self.rnn = nn.LSTM(embed_dim, hidden_dim, num_layers, dropout=0.3)
self.dropout = nn.Dropout(0.5)
def forward(self, src):
# src: [src_len, batch_size]
embedded = self.dropout(self.embedding(src))
outputs, (hidden, cell) = self.rnn(embedded)
return outputs, hidden, cell
class Decoder(nn.Module):
def __init__(self, output_dim, embed_dim, hidden_dim, num_layers):
super(Decoder, self).__init__()
self.embedding = nn.Embedding(output_dim, embed_dim)
self.rnn = nn.LSTM(embed_dim, hidden_dim, num_layers, dropout=0.3)
self.fc_out = nn.Linear(hidden_dim, output_dim)
self.dropout = nn.Dropout(0.5)
def forward(self, input, hidden, cell):
# input: [batch_size]
input = input.unsqueeze(0) # [1, batch_size]
embedded = self.dropout(self.embedding(input))
output, (hidden, cell) = self.rnn(embedded, (hidden, cell))
prediction = self.fc_out(output.squeeze(0))
return prediction, hidden, cell
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder, device):
super(Seq2Seq, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.device = device
def forward(self, src, trg, teacher_forcing_ratio=0.5):
batch_size = src.shape[1]
trg_len = trg.shape[0]
trg_vocab_size = self.decoder.fc_out.out_features
outputs = torch.zeros(trg_len, batch_size, trg_vocab_size).to(self.device)
encoder_outputs, hidden, cell = self.encoder(src)
input = trg[0, :] # 开始符号
for t in range(1, trg_len):
output, hidden, cell = self.decoder(input, hidden, cell)
outputs[t] = output
teacher_force = random.random() < teacher_forcing_ratio
top1 = output.argmax(1)
input = trg[t] if teacher_force else top1
return outputs
---
03.精通Transformer架构
a.自注意力机制深度解析
a.数学原理
理解Query、Key、Value的计算和注意力分数
b.多头注意力
掌握多头的并行计算和注意力融合
c.位置编码
理解位置信息的编码方法
d.完整Transformer实现
从零实现完整的Transformer模型
e.优化和改进
了解各种Transformer变体和优化方法
04.掌握预训练语言模型
a.BERT模型架构
a.Masked Language Model
理解MLM预训练任务
b.Next Sentence Prediction
掌握NSP任务的作用
c.微调策略
学习BERT的微调方法和技巧
b.GPT系列发展
a.生成式预训练
理解自回归语言模型
b.模型演进
从GPT-1到GPT-4的技术发展
c.应用场景
文本生成、对话系统、内容创作等
d.实战代码示例
---
from transformers import BertTokenizer, BertModel, BertForSequenceClassification
from transformers import GPT2Tokenizer, GPT2LMHeadModel
import torch
class PretrainedModelWrapper:
def __init__(self, model_name='bert-base-chinese'):
self.model_name = model_name
self.tokenizer = None
self.model = None
def load_bert(self):
"""加载BERT模型"""
self.tokenizer = BertTokenizer.from_pretrained(self.model_name)
self.model = BertModel.from_pretrained(self.model_name)
return self.model
def load_gpt2(self):
"""加载GPT-2模型"""
self.tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
self.model = GPT2LMHeadModel.from_pretrained('gpt2')
return self.model
def extract_features(self, text):
"""提取文本特征"""
if self.model is None:
self.load_bert()
inputs = self.tokenizer(text, return_tensors='pt',
padding=True, truncation=True)
with torch.no_grad():
outputs = self.model(**inputs)
# 使用[CLS]标记的表示作为句子表示
features = outputs.last_hidden_state[:, 0, :]
return features
def generate_text(self, prompt, max_length=100):
"""生成文本"""
if self.model is None or 'gpt' not in self.model_name.lower():
self.load_gpt2()
inputs = self.tokenizer.encode(prompt, return_tensors='pt')
with torch.no_grad():
outputs = self.model.generate(
inputs,
max_length=max_length,
num_return_sequences=1,
temperature=0.7,
no_repeat_ngram_size=2,
pad_token_id=self.tokenizer.eos_token_id
)
generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
return generated_text
# 使用示例
wrapper = PretrainedModelWrapper()
# BERT特征提取
text = "自然语言处理是人工智能的重要分支"
features = wrapper.extract_features(text)
print(f"BERT特征形状: {features.shape}")
# GPT-2文本生成
prompt = "人工智能的未来是"
generated = wrapper.generate_text(prompt, max_length=50)
print(f"生成的文本: {generated}")
---
05.深入了解大语言模型
a.LLM技术演进
a.模型规模扩展
理解参数量增长带来的能力提升
b.训练数据质量
掌握数据清洗和筛选的重要性
c.训练策略优化
学习分布式训练和优化技巧
b.主流开源模型
a.LLaMA系列
Meta开源的高性能模型
b.ChatGLM
清华大学的中英双语模型
c.Qwen模型
阿里巴巴的通义千问系列
d.模型架构对比
不同模型的设计选择和性能差异
06.掌握微调技术
a.全参数微调
a.原理理解
所有参数都参与训练更新
b.优缺点分析
效果好但成本高
b.参数高效微调
a.LoRA技术
低秩适应的原理和实现
b.QLoRA优化
量化LoRA的内存优化
c.P-Tuning方法
提示微调的实现
d.Adapter机制
适配器的设计原理
e.实战项目演练
---
from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
class LLMFinetuner:
def __init__(self, model_name='microsoft/DialoGPT-medium'):
self.model_name = model_name
self.tokenizer = None
self.model = None
def load_model(self):
"""加载预训练模型"""
self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
# 添加填充token
if self.tokenizer.pad_token is None:
self.tokenizer.pad_token = self.tokenizer.eos_token
return self.model
def setup_lora(self, r=16, lora_alpha=32, lora_dropout=0.1):
"""设置LoRA配置"""
lora_config = LoraConfig(
r=r, # 低秩维度
lora_alpha=lora_alpha, # 缩放参数
target_modules=["q_proj", "v_proj"], # 目标模块
lora_dropout=lora_dropout,
bias="none",
task_type=TaskType.CAUSAL_LM
)
# 应用LoRA
self.model = get_peft_model(self.model, lora_config)
# 打印可训练参数数量
self.model.print_trainable_parameters()
return self.model
def prepare_training_data(self, conversations):
"""准备训练数据"""
# 对话格式：[{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
inputs = []
labels = []
for conversation in conversations:
text = ""
for msg in conversation:
role_prefix = "用户:" if msg["role"] == "user" else "助手:"
text += f"{role_prefix}{msg['content']}\n"
# 编码文本
encoded = self.tokenizer(
text,
truncation=True,
max_length=512,
padding="max_length",
return_tensors="pt"
)
inputs.append(encoded["input_ids"])
labels.append(encoded["input_ids"])
return {
"input_ids": torch.cat(inputs, dim=0),
"labels": torch.cat(labels, dim=0)
}
def finetune(self, train_data, epochs=3, batch_size=4, learning_rate=1e-4):
"""微调模型"""
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=epochs,
per_device_train_batch_size=batch_size,
learning_rate=learning_rate,
warmup_steps=100,
logging_dir="./logs",
logging_steps=10,
save_steps=500,
fp16=True, # 混合精度训练
dataloader_num_workers=4
)
trainer = Trainer(
model=self.model,
args=training_args,
train_dataset=train_data
)
# 开始训练
trainer.train()
return trainer
# 使用示例
finetuner = LLMFinetuner()
model = finetuner.load_model()
model = finetuner.setup_lora(r=16, lora_alpha=32)
# 准备训练数据
conversations = [
[
{"role": "user", "content": "你好，请介绍一下自然语言处理"},
{"role": "assistant", "content": "自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。"}
]
]
train_data = finetuner.prepare_training_data(conversations)
trainer = finetuner.finetune(train_data, epochs=2)
print("微调完成！")
---
1.3 前置要求
01.必备知识基础
a.Python编程能力
a.基础语法掌握
熟练掌握Python基础语法、数据类型、控制流、函数、类等核心概念
b.面向对象编程
理解封装、继承、多态等面向对象设计原则
c.常用库使用
掌握NumPy、Pandas、Matplotlib等数据科学生态
d.代码实践能力
具备独立编写、调试、优化Python代码的能力
e.Python编程测试代码
---
# Python基础能力测试
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from typing import List, Dict, Tuple, Optional
import time
import json
class DataProcessor:
"""数据处理类，测试Python编程能力"""
def __init__(self):
self.data = None
self.processed_data = None
def load_data(self, file_path: str) -> bool:
"""加载数据文件"""
try:
if file_path.endswith('.json'):
with open(file_path, 'r', encoding='utf-8') as f:
self.data = json.load(f)
elif file_path.endswith('.csv'):
self.data = pd.read_csv(file_path)
else:
raise ValueError("不支持的文件格式")
return True
except Exception as e:
print(f"加载文件失败: {e}")
return False
def preprocess_text(self, texts: List[str]) -> List[str]:
"""文本预处理"""
processed = []
for text in texts:
# 去除特殊字符，转换小写
clean_text = ''.join(char for char in text if char.isalnum() or char.isspace())
processed.append(clean_text.lower().strip())
return processed
def calculate_statistics(self, data: List[float]) -> Dict[str, float]:
"""计算统计信息"""
if not data:
return {}
np_data = np.array(data)
return {
'mean': float(np.mean(np_data)),
'std': float(np.std(np_data)),
'min': float(np.min(np_data)),
'max': float(np.max(np_data)),
'median': float(np.median(np_data))
}
def visualize_data(self, x_data: List[float], y_data: List[float],
title: str = "数据可视化", xlabel: str = "X", ylabel: str = "Y"):
"""数据可视化"""
plt.figure(figsize=(10, 6))
plt.plot(x_data, y_data, 'b-', linewidth=2)
plt.title(title, fontsize=14)
plt.xlabel(xlabel, fontsize=12)
plt.ylabel(ylabel, fontsize=12)
plt.grid(True, alpha=0.3)
plt.show()
# 使用示例
processor = DataProcessor()
# 文本处理测试
test_texts = [
"Hello, World! 这是自然语言处理课程。",
"Python编程是NLP的基础技能。",
"数据预处理是机器学习的重要步骤。"
]
processed_texts = processor.preprocess_text(test_texts)
print("处理后的文本:")
for i, text in enumerate(processed_texts):
print(f"{i+1}: {text}")
# 统计计算测试
test_numbers = [1.2, 2.3, 3.1, 4.5, 5.2, 6.8, 7.1, 8.9, 9.3, 10.0]
stats = processor.calculate_statistics(test_numbers)
print(f"\n统计信息: {stats}")
---
b.深度学习基础理论
a.神经网络原理
理解神经元、激活函数、前向传播、反向传播等基础概念
b.损失函数与优化
掌握交叉熵、均方误差等损失函数，梯度下降等优化方法
c.正则化技术
理解Dropout、BatchNorm等防止过拟合的技术
d.模型评估指标
掌握准确率、精确率、召回率、F1分数等评估指标
e.深度学习理论测试代码
---
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
class NeuralNetwork(nn.Module):
"""基础神经网络类，测试深度学习理解"""
def __init__(self, input_size: int, hidden_size: int, output_size: int):
super(NeuralNetwork, self).__init__()
# 定义网络层
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.fc3 = nn.Linear(hidden_size, output_size)
# 批归一化
self.bn1 = nn.BatchNorm1d(hidden_size)
self.bn2 = nn.BatchNorm1d(hidden_size)
# Dropout层
self.dropout = nn.Dropout(0.3)
def forward(self, x):
# 第一层
x = self.fc1(x)
x = self.bn1(x)
x = F.relu(x)
x = self.dropout(x)
# 第二层
x = self.fc2(x)
x = self.bn2(x)
x = F.relu(x)
x = self.dropout(x)
# 输出层
x = self.fc3(x)
return x
class DeepLearningBasics:
"""深度学习基础操作类"""
def __init__(self):
self.model = None
self.criterion = None
self.optimizer = None
def create_model(self, input_size: int, hidden_size: int, output_size: int):
"""创建模型"""
self.model = NeuralNetwork(input_size, hidden_size, output_size)
self.criterion = nn.CrossEntropyLoss()
self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)
return self.model
def train_step(self, x_batch, y_batch):
"""单步训练"""
self.model.train()
# 前向传播
outputs = self.model(x_batch)
loss = self.criterion(outputs, y_batch)
# 反向传播
self.optimizer.zero_grad()
loss.backward()
# 梯度裁剪，防止梯度爆炸
torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
self.optimizer.step()
return loss.item()
def evaluate(self, x_test, y_test):
"""模型评估"""
self.model.eval()
with torch.no_grad():
outputs = self.model(x_test)
_, predicted = torch.max(outputs.data, 1)
# 计算各种评估指标
accuracy = accuracy_score(y_test.cpu(), predicted.cpu())
precision, recall, f1, _ = precision_recall_fscore_support(
y_test.cpu(), predicted.cpu(), average='weighted'
)
return {
'accuracy': accuracy,
'precision': precision,
'recall': recall,
'f1_score': f1
}
# 使用示例
dl_basics = DeepLearningBasics()
# 创建模型
model = dl_basics.create_model(input_size=10, hidden_size=64, output_size=3)
# 模拟训练数据
batch_size = 32
x_batch = torch.randn(batch_size, 10)
y_batch = torch.randint(0, 3, (batch_size,))
# 训练一步
loss = dl_basics.train_step(x_batch, y_batch)
print(f"训练损失: {loss:.4f}")
# 模拟测试数据
x_test = torch.randn(100, 10)
y_test = torch.randint(0, 3, (100,))
# 评估模型
metrics = dl_basics.evaluate(x_test, y_test)
print(f"模型评估结果: {metrics}")
---
c.PyTorch框架实践
a.Tensor操作
熟练掌握PyTorch张量的创建、操作、变换等基础操作
b.自动求导
理解自动求导机制和梯度计算
c.神经网络模块
掌握nn.Module、nn.Linear等常用模块的使用
d.数据处理工具
熟悉Dataset、DataLoader等数据处理工具
e.PyTorch技能测试代码
---
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
import torchvision.transforms as transforms
from torch.autograd import Variable
class CustomDataset(Dataset):
"""自定义数据集类"""
def __init__(self, data_size: int = 1000, feature_size: int = 20):
# 生成模拟数据
self.features = torch.randn(data_size, feature_size)
self.labels = torch.randint(0, 5, (data_size,))
self.transform = transforms.Compose([
transforms.Normalize(mean=[0.0], std=[1.0])
])
def __len__(self):
return len(self.features)
def __getitem__(self, idx):
feature = self.features[idx]
label = self.labels[idx]
# 应用变换
if self.transform:
feature = self.transform(feature.unsqueeze(0)).squeeze(0)
return feature, label
class PyTorchBasics:
"""PyTorch基础操作类"""
def __init__(self):
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用设备: {self.device}")
def tensor_operations(self):
"""张量操作演示"""
print("=== 张量操作演示 ===")
# 创建张量
tensor_a = torch.randn(3, 4)
tensor_b = torch.randn(4, 5)
print(f"张量A形状: {tensor_a.shape}")
print(f"张量B形状: {tensor_b.shape}")
# 矩阵乘法
result = torch.mm(tensor_a, tensor_b)
print(f"矩阵乘法结果形状: {result.shape}")
# 张量变换
reshaped = tensor_a.view(2, 6)
print(f"重塑后形状: {reshaped.shape}")
# GPU/CPU转换
if torch.cuda.is_available():
tensor_gpu = tensor_a.to(self.device)
print(f"张量在GPU上: {tensor_gpu.is_cuda}")
return tensor_a, tensor_b, result
def autograd_example(self):
"""自动求导示例"""
print("\n=== 自动求导示例 ===")
# 创建需要梯度的变量
x = Variable(torch.randn(2, 2), requires_grad=True)
y = Variable(torch.randn(2, 2), requires_grad=True)
# 定义计算图
z = x.sum() * y.mean()
# 反向传播
z.backward()
print(f"x的梯度:\n{x.grad}")
print(f"y的梯度:\n{y.grad}")
print(f"z的值: {z.item():.4f}")
return x, y, z
def custom_model_example(self):
"""自定义模型示例"""
print("\n=== 自定义模型示例 ===")
class SimpleNet(nn.Module):
def __init__(self, input_size: int, hidden_size: int, output_size: int):
super(SimpleNet, self).__init__()
self.layers = nn.Sequential(
nn.Linear(input_size, hidden_size),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(hidden_size, output_size),
nn.Softmax(dim=1)
)
def forward(self, x):
return self.layers(x)
# 创建模型
model = SimpleNet(20, 50, 5).to(self.device)
# 计算参数数量
total_params = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"总参数数量: {total_params:,}")
print(f"可训练参数数量: {trainable_params:,}")
# 模拟前向传播
input_data = torch.randn(16, 20).to(self.device)
output = model(input_data)
print(f"输入形状: {input_data.shape}")
print(f"输出形状: {output.shape}")
return model, output
def data_loading_example(self):
"""数据加载示例"""
print("\n=== 数据加载示例 ===")
# 创建数据集
dataset = CustomDataset(data_size=100, feature_size=20)
# 创建数据加载器
dataloader = DataLoader(
dataset,
batch_size=16,
shuffle=True,
num_workers=2,
pin_memory=True if torch.cuda.is_available() else False
)
print(f"数据集大小: {len(dataset)}")
print(f"批次数量: {len(dataloader)}")
# 遍历数据
for i, (features, labels) in enumerate(dataloader):
print(f"批次 {i+1}: 特征形状 {features.shape}, 标签形状 {labels.shape}")
if i >= 2: # 只显示前3个批次
break
return dataset, dataloader
# 使用示例
pytorch_basics = PyTorchBasics()
# 测试各种操作
tensors = pytorch_basics.tensor_operations()
autograd_result = pytorch_basics.autograd_example()
model_result = pytorch_basics.custom_model_example()
data_result = pytorch_basics.data_loading_example()
---
02.数学基础要求
a.线性代数知识
a.矩阵运算
熟练掌握矩阵加法、乘法、转置、逆矩阵等基础运算
b.向量空间
理解向量空间、基向量、正交性等概念
c.特征值分解
掌握特征值、特征向量的计算和应用
d.奇异值分解(SVD)
理解SVD原理和在NLP中的应用
e.线性代数实践代码
---
import numpy as np
import scipy.linalg as la
from sklearn.decomposition import PCA
class LinearAlgebraBasics:
"""线性代数基础操作类"""
def __init__(self):
pass
def matrix_operations(self):
"""矩阵基础运算"""
print("=== 矩阵基础运算 ===")
# 创建矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(f"矩阵A:\n{A}")
print(f"矩阵B:\n{B}")
# 矩阵加法
C_add = A + B
print(f"矩阵加法 A + B:\n{C_add}")
# 矩阵乘法
C_mul = np.dot(A, B)
print(f"矩阵乘法 A · B:\n{C_mul}")
# 转置
A_T = A.T
print(f"矩阵A的转置:\n{A_T}")
# 逆矩阵
try:
A_inv = np.linalg.inv(A)
print(f"矩阵A的逆矩阵:\n{A_inv}")
except np.linalg.LinAlgError:
print("矩阵A不可逆")
return A, B, C_mul, A_T
def vector_operations(self):
"""向量运算"""
print("\n=== 向量运算 ===")
# 创建向量
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
print(f"向量v1: {v1}")
print(f"向量v2: {v2}")
# 向量加法
v_add = v1 + v2
print(f"向量加法: {v_add}")
# 点积
dot_product = np.dot(v1, v2)
print(f"点积: {dot_product}")
# 向量范数
norm_l1 = np.linalg.norm(v1, ord=1) # L1范数
norm_l2 = np.linalg.norm(v1, ord=2) # L2范数
print(f"向量v1的L1范数: {norm_l1}")
print(f"向量v1的L2范数: {norm_l2}")
# 向量夹角余弦
cos_similarity = dot_product / (np.linalg.norm(v1) * np.linalg.norm(v2))
print(f"余弦相似度: {cos_similarity:.4f}")
return v1, v2, cos_similarity
def eigenvalue_decomposition(self):
"""特征值分解"""
print("\n=== 特征值分解 ===")
# 创建对称矩阵
M = np.array([[3, 1], [1, 2]])
# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(M)
print(f"原矩阵:\n{M}")
print(f"特征值: {eigenvalues}")
print(f"特征向量:\n{eigenvectors}")
# 验证分解
M_reconstructed = eigenvectors @ np.diag(eigenvalues) @ eigenvectors.T
print(f"重构矩阵:\n{M_reconstructed}")
return eigenvalues, eigenvectors
def svd_decomposition(self):
"""奇异值分解"""
print("\n=== 奇异值分解(SVD) ===")
# 创建矩阵
A = np.array([[1, 2, 3], [4, 5, 6]])
# SVD分解
U, s, Vt = np.linalg.svd(A)
print(f"原矩阵A形状: {A.shape}")
print(f"U矩阵形状: {U.shape}")
print(f"奇异值: {s}")
print(f"V矩阵形状: {Vt.shape}")
# 重构矩阵
S = np.zeros(A.shape)
S[:len(s), :len(s)] = np.diag(s)
A_reconstructed = U @ S @ Vt
print(f"重构矩阵:\n{A_reconstructed}")
print(f"重构误差: {np.linalg.norm(A - A_reconstructed):.6f}")
# 截断SVD（降维）
k = 1 # 保留最大的k个奇异值
U_k = U[:, :k]
s_k = s[:k]
Vt_k = Vt[:k, :]
S_k = np.zeros((A.shape[0], A.shape[1]))
S_k[:len(s_k), :len(s_k)] = np.diag(s_k)
A_truncated = U_k @ S_k[:len(s_k), :] @ Vt_k
print(f"截断SVD重构:\n{A_truncated}")
return U, s, Vt, A_truncated
def pca_example(self):
"""PCA降维示例"""
print("\n=== PCA降维示例 ===")
# 生成模拟数据
np.random.seed(42)
n_samples = 100
n_features = 10
X = np.random.randn(n_samples, n_features)
# PCA降维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
print(f"原始数据形状: {X.shape}")
print(f"降维后数据形状: {X_pca.shape}")
print(f"解释方差比: {pca.explained_variance_ratio_}")
print(f"累积解释方差比: {np.cumsum(pca.explained_variance_ratio_)}")
return X, X_pca, pca
# 使用示例
la_basics = LinearAlgebraBasics()
# 测试各种线性代数操作
matrix_result = la_basics.matrix_operations()
vector_result = la_basics.vector_operations()
eigen_result = la_basics.eigenvalue_decomposition()
svd_result = la_basics.svd_decomposition()
pca_result = la_basics.pca_example()
---
b.概率统计基础
a.概率分布
理解正态分布、泊松分布、二项分布等常见概率分布
b.贝叶斯定理
掌握贝叶斯定理和贝叶斯推断
c.期望与方差
理解随机变量的期望、方差、协方差等统计量
d.假设检验
掌握t检验、卡方检验等统计检验方法
e.概率统计实践代码
---
import numpy as np
import scipy.stats as stats
from scipy.stats import norm, poisson, binom
import matplotlib.pyplot as plt
class ProbabilityBasics:
"""概率统计基础操作类"""
def __init__(self):
pass
def probability_distributions(self):
"""常见概率分布演示"""
print("=== 概率分布演示 ===")
# 正态分布
mu, sigma = 0, 1
x = np.linspace(-4, 4, 1000)
normal_pdf = norm.pdf(x, mu, sigma)
normal_cdf = norm.cdf(x, mu, sigma)
print(f"正态分布 P(X <= 1.96) = {norm.cdf(1.96, mu, sigma):.4f}")
print(f"正态分布 P(|X| <= 1.96) = {norm.cdf(1.96, mu, sigma) - norm.cdf(-1.96, mu, sigma):.4f}")
# 泊松分布
lambda_param = 3
k_values = np.arange(0, 10)
poisson_pmf = poisson.pmf(k_values, lambda_param)
print(f"泊松分布(λ={lambda_param}) P(X=3) = {poisson.pmf(3, lambda_param):.4f}")
print(f"泊松分布(λ={lambda_param}) E[X] = {lambda_param}")
print(f"泊松分布(λ={lambda_param}) Var[X] = {lambda_param}")
# 二项分布
n, p = 10, 0.3
k_values = np.arange(0, n+1)
binom_pmf = binom.pmf(k_values, n, p)
print(f"二项分布(n={n}, p={p}) E[X] = {n * p}")
print(f"二项分布(n={n}, p={p}) Var[X] = {n * p * (1-p)}")
print(f"二项分布(n={n}, p={p}) P(X >= 5) = {1 - binom.cdf(4, n, p):.4f}")
return {
'normal': (x, normal_pdf, normal_cdf),
'poisson': (k_values, poisson_pmf),
'binomial': (k_values, binom_pmf)
}
def bayesian_inference(self):
"""贝叶斯推断示例"""
print("\n=== 贝叶斯推断示例 ===")
# 医学诊断问题示例
# 假设：某种疾病的发病率为1%
# 检测试剂的准确率：真阳性率99%，假阳性率2%
prior_disease = 0.01 # 先验概率
prior_healthy = 1 - prior_disease
sensitivity = 0.99 # 真阳性率
false_positive_rate = 0.02 # 假阳性率
specificity = 1 - false_positive_rate # 特异度
# 计算检测为阳性的概率
prob_positive = prior_disease * sensitivity + prior_healthy * false_positive_rate
# 应用贝叶斯定理
posterior_disease = (prior_disease * sensitivity) / prob_positive
print(f"先验概率 P(疾病) = {prior_disease}")
print(f"检测阳性后 P(疾病|阳性) = {posterior_disease:.4f}")
print(f"检测阳性后 P(健康|阳性) = {1 - posterior_disease:.4f}")
return posterior_disease
def expectation_variance(self):
"""期望与方差计算"""
print("\n=== 期望与方差计算 ===")
# 离散随机变量示例
# 掷骰子
outcomes = np.arange(1, 7) # 1-6
probabilities = np.ones(6) / 6 # 等概率
expectation = np.sum(outcomes * probabilities)
variance = np.sum((outcomes - expectation) ** 2 * probabilities)
std_deviation = np.sqrt(variance)
print(f"骰子点数期望: E[X] = {expectation}")
print(f"骰子点数方差: Var[X] = {variance}")
print(f"骰子点数标准差: σ[X] = {std_deviation:.4f}")
# 连续随机变量示例（正态分布）
mu, sigma = 0, 1
# 正态分布的期望和方差有解析解
print(f"正态分布 N({mu}, {sigma}²) 的期望: {mu}")
print(f"正态分布 N({mu}, {sigma}²) 的方差: {sigma**2}")
return expectation, variance
def hypothesis_testing(self):
"""假设检验示例"""
print("\n=== 假设检验示例 ===")
# t检验示例
# 假设我们有一组样本数据，检验其均值是否等于某个值
np.random.seed(42)
sample_data = np.random.normal(loc=5, scale=2, size=30)
# H0: μ = 5
# H1: μ ≠ 5
hypothesized_mean = 5
sample_mean = np.mean(sample_data)
sample_std = np.std(sample_data, ddof=1)
sample_size = len(sample_data)
# 计算t统计量
t_statistic = (sample_mean - hypothesized_mean) / (sample_std / np.sqrt(sample_size))
# 使用scipy进行t检验
t_stat, p_value = stats.ttest_1samp(sample_data, hypothesized_mean)
print(f"样本均值: {sample_mean:.4f}")
print(f"样本标准差: {sample_std:.4f}")
print(f"t统计量: {t_stat:.4f}")
print(f"p值: {p_value:.4f}")
# 显著性水平
alpha = 0.05
if p_value < alpha:
print(f"在α = {alpha}显著性水平下拒绝原假设")
else:
print(f"在α = {alpha}显著性水平下不能拒绝原假设")
# 卡方检验示例
# 检验观察频数是否符合期望频数
observed_frequencies = np.array([45, 55, 50]) # 观察频数
expected_frequencies = np.array([50, 50, 50]) # 期望频数
chi2_stat, chi2_p_value = stats.chisquare(observed_frequencies, expected_frequencies)
print(f"\n卡方统计量: {chi2_stat:.4f}")
print(f"卡方检验p值: {chi2_p_value:.4f}")
return t_stat, p_value, chi2_stat, chi2_p_value
# 使用示例
prob_basics = ProbabilityBasics()
# 测试各种概率统计操作
distributions = prob_basics.probability_distributions()
bayesian_result = prob_basics.bayesian_inference()
expectation_result = prob_basics.expectation_variance()
hypothesis_result = prob_basics.hypothesis_testing()
---
03.推荐预备知识
a.机器学习基础
a.监督学习
理解分类、回归等监督学习任务
b.无监督学习
掌握聚类、降维等无监督学习方法
c.模型评估
熟悉交叉验证、过拟合、欠拟合等概念
d.特征工程
了解特征选择、特征变换等技巧
e.机器学习基础代码
---
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.cluster import KMeans
from sklearn.metrics import classification_report, confusion_matrix
import numpy as np
class MachineLearningBasics:
"""机器学习基础操作类"""
def __init__(self):
pass
def classification_example(self):
"""分类任务示例"""
print("=== 分类任务示例 ===")
# 生成模拟数据
np.random.seed(42)
n_samples = 1000
n_features = 20
X = np.random.randn(n_samples, n_features)
# 生成二分类标签
y = (X[:, 0] + X[:, 1] > 0).astype(int)
# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# 特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 训练多个模型
models = {
'LogisticRegression': LogisticRegression(random_state=42),
'RandomForest': RandomForestClassifier(n_estimators=100, random_state=42)
}
results = {}
for name, model in models.items():
# 训练模型
model.fit(X_train_scaled, y_train)
# 预测
y_pred = model.predict(X_test_scaled)
# 评估
accuracy = np.mean(y_pred == y_test)
# 交叉验证
cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5)
print(f"{name}:")
print(f" 测试集准确率: {accuracy:.4f}")
print(f" 交叉验证准确率: {cv_scores.mean():.4f} (±{cv_scores.std():.4f})")
results[name] = {
'accuracy': accuracy,
'cv_mean': cv_scores.mean(),
'cv_std': cv_scores.std()
}
return results, X_train_scaled, y_train, X_test_scaled, y_test
def regression_example(self):
"""回归任务示例"""
print("\n=== 回归任务示例 ===")
# 生成模拟数据
np.random.seed(42)
n_samples = 1000
n_features = 15
X = np.random.randn(n_samples, n_features)
# 生成连续目标值
y = 2 * X[:, 0] + 3 * X[:, 1] + np.random.randn(n_samples) * 0.1
# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 训练模型
models = {
'LinearRegression': LinearRegression(),
'RandomForest': RandomForestRegressor(n_estimators=100, random_state=42)
}
results = {}
for name, model in models.items():
# 训练
model.fit(X_train_scaled, y_train)
# 预测
y_pred = model.predict(X_test_scaled)
# 评估
mse = np.mean((y_pred - y_test) ** 2)
rmse = np.sqrt(mse)
mae = np.mean(np.abs(y_pred - y_test))
# R²分数
r2_score = model.score(X_test_scaled, y_test)
print(f"{name}:")
print(f" MSE: {mse:.4f}")
print(f" RMSE: {rmse:.4f}")
print(f" MAE: {mae:.4f}")
print(f" R²: {r2_score:.4f}")
results[name] = {
'mse': mse,
'rmse': rmse,
'mae': mae,
'r2': r2_score
}
return results
def clustering_example(self):
"""聚类任务示例"""
print("\n=== 聚类任务示例 ===")
# 生成模拟数据
np.random.seed(42)
n_samples = 300
n_centers = 3
from sklearn.datasets import make_blobs
X, y_true = make_blobs(n_samples=n_samples, centers=n_centers,
random_state=42, cluster_std=1.5)
# K-means聚类
kmeans = KMeans(n_clusters=n_centers, random_state=42)
cluster_labels = kmeans.fit_predict(X)
# 评估聚类效果
from sklearn.metrics import adjusted_rand_score, silhouette_score
ari_score = adjusted_rand_score(y_true, cluster_labels)
silhouette_avg = silhouette_score(X, cluster_labels)
print(f"聚类中心数量: {n_centers}")
print(f"调整兰德指数: {ari_score:.4f}")
print(f"轮廓系数: {silhouette_avg:.4f}")
# 聚类中心
print(f"聚类中心:\n{kmeans.cluster_centers_}")
return {
'ari_score': ari_score,
'silhouette_score': silhouette_avg,
'cluster_centers': kmeans.cluster_centers_,
'cluster_labels': cluster_labels,
'true_labels': y_true
}
# 使用示例
ml_basics = MachineLearningBasics()
# 测试各种机器学习任务
classification_results = ml_basics.classification_example()
regression_results = ml_basics.regression_example()
clustering_results = ml_basics.clustering_example()
---
b.RNN/LSTM基础
a.循环神经网络原理
理解RNN的基本结构和工作原理
b.梯度消失与爆炸
了解训练中的数值稳定性问题
c.LSTM网络结构
掌握长短期记忆网络的门控机制
d.实际应用经验
有使用RNN处理序列数据的实践经验
e.RNN基础代码
---
import torch
import torch.nn as nn
import numpy as np
class RNNBasics:
"""RNN基础实现类"""
def __init__(self):
pass
def simple_rnn_implementation(self):
"""简单RNN实现"""
print("=== 简单RNN实现 ===")
class SimpleRNN(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(SimpleRNN, self).__init__()
self.hidden_size = hidden_size
# RNN层
self.rnn = nn.RNN(
input_size=input_size,
hidden_size=hidden_size,
batch_first=True
)
# 输出层
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x):
# 初始化隐藏状态
batch_size = x.size(0)
h0 = torch.zeros(1, batch_size, self.hidden_size)
# RNN前向传播
out, _ = self.rnn(x, h0)
# 使用最后一个时间步的输出
out = self.fc(out[:, -1, :])
return out
# 参数设置
input_size = 10
hidden_size = 20
output_size = 5
seq_length = 15
batch_size = 32
# 创建模型
model = SimpleRNN(input_size, hidden_size, output_size)
# 模拟输入
x = torch.randn(batch_size, seq_length, input_size)
# 前向传播
output = model(x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")
print(f"模型参数数量: {sum(p.numel() for p in model.parameters()):,}")
return model, output
def lstm_implementation(self):
"""LSTM实现"""
print("\n=== LSTM实现 ===")
class LSTMModel(nn.Module):
def __init__(self, input_size, hidden_size, num_layers, output_size):
super(LSTMModel, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
# LSTM层
self.lstm = nn.LSTM(
input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
batch_first=True,
dropout=0.3
)
# 输出层
self.fc = nn.Linear(hidden_size, output_size)
self.dropout = nn.Dropout(0.5)
def forward(self, x):
batch_size = x.size(0)
# 初始化隐藏状态和细胞状态
h0 = torch.zeros(self.num_layers, batch_size, self.hidden_size)
c0 = torch.zeros(self.num_layers, batch_size, self.hidden_size)
# LSTM前向传播
out, (hn, cn) = self.lstm(x, (h0, c0))
# 使用最后一个时间步的输出
out = self.dropout(out[:, -1, :])
out = self.fc(out)
return out
def get_last_hidden_state(self, x):
"""获取最后的隐藏状态"""
batch_size = x.size(0)
h0 = torch.zeros(self.num_layers, batch_size, self.hidden_size)
c0 = torch.zeros(self.num_layers, batch_size, self.hidden_size)
_, (hn, cn) = self.lstm(x, (h0, c0))
return hn, cn
# 参数设置
input_size = 10
hidden_size = 32
num_layers = 2
output_size = 3
# 创建模型
model = LSTMModel(input_size, hidden_size, num_layers, output_size)
# 模拟输入
batch_size = 16
seq_length = 20
x = torch.randn(batch_size, seq_length, input_size)
# 前向传播
output = model(x)
# 获取隐藏状态
last_hidden, last_cell = model.get_last_hidden_state(x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")
print(f"最后隐藏状态形状: {last_hidden.shape}")
print(f"最后细胞状态形状: {last_cell.shape}")
return model, output, last_hidden
def gradient_check(self):
"""梯度消失/爆炸检查"""
print("\n=== 梯度检查 ===")
# 创建深层RNN
deep_rnn = nn.RNN(
input_size=10,
hidden_size=20,
num_layers=5, # 深层网络
batch_first=True
)
deep_lstm = nn.LSTM(
input_size=10,
hidden_size=20,
num_layers=5,
batch_first=True
)
# 模拟长序列
seq_length = 100
x = torch.randn(1, seq_length, 10)
def check_gradients(model, model_name):
"""检查梯度大小"""
x.requires_grad_(True)
# 前向传播
output, _ = model(x)
loss = output.sum()
# 反向传播
loss.backward()
# 检查梯度
grad_norms = []
for name, param in model.named_parameters():
if param.grad is not None:
grad_norm = param.grad.norm().item()
grad_norms.append(grad_norm)
print(f"{model_name} 梯度范数:")
print(f" 最大梯度: {max(grad_norms):.6f}")
print(f" 最小梯度: {min(grad_norms):.6f}")
print(f" 平均梯度: {np.mean(grad_norms):.6f}")
return grad_norms
rnn_grads = check_gradients(deep_rnn, "深层RNN")
lstm_grads = check_gradients(deep_lstm, "深层LSTM")
return rnn_grads, lstm_grads
# 使用示例
rnn_basics = RNNBasics()
# 测试各种RNN实现
simple_rnn_result = rnn_basics.simple_rnn_implementation()
lstm_result = rnn_basics.lstm_implementation()
gradient_result = rnn_basics.gradient_check()
---
c.英文技术阅读能力
a.学术论文阅读
能够阅读和理解NLP领域的学术论文
b.技术文档理解
熟练阅读英文技术文档和API文档
c.代码注释理解
能理解英文代码注释和说明
d.专业术语掌握
熟悉NLP领域的英文专业术语
e.技术阅读资源
提供推荐的技术博客、论文、教程等资源列表
04.学习建议与准备
a.基础知识巩固
a.制定学习计划
根据个人情况制定针对性的基础知识复习计划
b.实践练习
通过编程实践巩固理论知识
c.概念理解
重视核心概念的深入理解而非死记硬背
b.环境搭建准备
a.开发环境
安装Python、PyTorch、Jupyter等必要工具
b.硬件要求
确保有足够的计算资源运行深度学习模型
c.数据准备
准备一些基础的文本数据集用于实验
c.学习态度调整
a.耐心与毅力
NLP技术复杂，需要长期坚持学习
b.实践导向
理论学习与代码实践并重
c.持续学习
跟上技术发展的最新动态
1.4 学习时长
01.总体学习规划
a.建议学习周期
a.标准学习路径
完整学习周期为8-12周，确保充分理解和实践每个知识点
b.每周学习投入
建议每周投入10-15小时学习时间，包括理论学习、代码实践和项目开发
c.学习强度调整
根据个人基础和学习目标可适当调整学习周期，但不应少于6周
d.时间分配原则
理论学习占40%，代码实践占50%，复习总结占10%
e.学习进度管理
a.里程碑设置
每完成一个章节设置学习里程碑，进行阶段性评估
b.进度跟踪
建立学习日志，记录每日学习内容和收获
c.灵活调整
根据学习效果和时间安排动态调整学习计划
f.学习时间规划代码
---
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta
import pandas as pd
class LearningPlanner:
"""学习时间规划管理器"""
def __init__(self, total_weeks=10, hours_per_week=12):
self.total_weeks = total_weeks
self.hours_per_week = hours_per_week
self.total_hours = total_weeks * hours_per_week
self.plan = None
def create_study_plan(self):
"""创建学习计划"""
# 各章节学习时间分配（小时）
chapters = {
'NLP基础': {'weeks': 2, 'hours': 24, 'difficulty': 2},
'序列模型': {'weeks': 2, 'hours': 24, 'difficulty': 3},
'Transformer': {'weeks': 3, 'hours': 36, 'difficulty': 4},
'预训练模型': {'weeks': 2, 'hours': 24, 'difficulty': 4},
'大语言模型': {'weeks': 1.5, 'hours': 18, 'difficulty': 3},
'微调技术': {'weeks': 1.5, 'hours': 18, 'difficulty': 5}
}
self.plan = pd.DataFrame(chapters).T
self.plan['cumulative_hours'] = self.plan['hours'].cumsum()
self.plan['week_percentage'] = (self.plan['hours'] / self.total_hours * 100).round(1)
return self.plan
def visualize_study_plan(self):
"""可视化学习计划"""
if self.plan is None:
self.create_study_plan()
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
# 学习时间分配饼图
ax1.pie(self.plan['hours'], labels=self.plan.index, autopct='%1.1f%%',
startangle=90, explode=[0.05] * len(self.plan))
ax1.set_title('各章节学习时间分配', fontsize=14, fontweight='bold')
# 学习进度条形图
bars = ax2.bar(self.plan.index, self.plan['hours'],
color=plt.cm.viridis(np.linspace(0, 1, len(self.plan))))
# 添加数值标签
for bar, hours in zip(bars, self.plan['hours']):
height = bar.get_height()
ax2.text(bar.get_x() + bar.get_width()/2., height + 0.5,
f'{hours}h', ha='center', va='bottom')
ax2.set_title('各章节学习时长', fontsize=14, fontweight='bold')
ax2.set_xlabel('章节', fontsize=12)
ax2.set_ylabel('学习时长（小时）', fontsize=12)
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return fig
def generate_weekly_schedule(self, current_week=1):
"""生成周学习计划"""
weekly_structure = {
'周一': ['理论学习', '代码实践'],
'周二': ['理论学习', '代码实践'],
'周三': ['项目实战', '问题解决'],
'周四': ['理论学习', '代码实践'],
'周五': ['项目实战', '代码复习'],
'周六': ['综合实践', '知识总结'],
'周日': ['休息', '补充学习']
}
daily_hours = {
'周一': 2.5,
'周二': 2.5,
'周三': 2.0,
'周四': 2.5,
'周五': 1.5,
'周六': 1.0,
'周日': 0.5
}
print(f"=== 第{current_week}周学习计划 ===")
total_week_hours = 0
for day, activities in weekly_structure.items():
hours = daily_hours[day]
total_week_hours += hours
print(f"{day}: {hours}小时 - {' + '.join(activities)}")
print(f"\n本周总学习时间: {total_week_hours}小时")
return weekly_structure, daily_hours
def track_progress(self, completed_hours, current_chapter):
"""跟踪学习进度"""
if self.plan is None:
self.create_study_plan()
# 计算总体进度
overall_progress = (completed_hours / self.total_hours) * 100
# 计算当前章节进度
if current_chapter in self.plan.index:
chapter_hours = self.plan.loc[current_chapter, 'hours']
# 假设当前章节已完成60%
chapter_progress = 60 # 可以根据实际情况调整
else:
chapter_progress = 0
print(f"=== 学习进度报告 ===")
print(f"总体进度: {overall_progress:.1f}% ({completed_hours}/{self.total_hours}小时)")
print(f"当前章节: {current_chapter}")
print(f"章节进度: {chapter_progress}% (估算)")
# 计算剩余时间
remaining_hours = self.total_hours - completed_hours
remaining_weeks = remaining_hours / self.hours_per_week
print(f"剩余学习时间: {remaining_hours:.1f}小时 (约{remaining_weeks:.1f}周)")
return overall_progress, chapter_progress
# 使用示例
planner = LearningPlanner(total_weeks=10, hours_per_week=12)
# 创建学习计划
study_plan = planner.create_study_plan()
print("学习计划总览:")
print(study_plan)
# 生成周计划
weekly_schedule = planner.generate_weekly_schedule(current_week=1)
# 跟踪进度
progress = planner.track_progress(completed_hours=15, current_chapter="NLP基础")
---
02.各模块详细时间规划
a.NLP基础模块（2周，24小时）
a.第一周：文本预处理技术（12小时）
a.理论学习（4小时）
数据清洗原理和常用技术
文本标准化方法和最佳实践
中英文分词技术的对比分析
b.代码实践（6小时）
实现完整的文本预处理流水线
使用jieba、spaCy等工具进行分词
构建自定义停用词表
c.项目实战（2小时）
对真实新闻数据集进行预处理
实现中英文混合文本处理
b.第二周：词向量技术（12小时）
a.理论学习（4小时）
词嵌入的数学原理
Word2Vec、GloVe、FastText算法对比
词向量评估方法和指标
b.代码实践（6小时）
从零实现Word2Vec的CBOW和Skip-gram
使用gensim库训练和评估词向量
可视化词向量和词类比关系
c.项目实战（2小时）
训练领域特定词向量模型
实现词相似度计算和类比推理
d.NLP基础学习时间分配
---
class NLPBasicsScheduler:
"""NLP基础模块时间安排"""
def __init__(self):
self.total_hours = 24
self.topics = [
{
'name': '文本预处理',
'theory_hours': 4,
'practice_hours': 6,
'project_hours': 2,
'subtopics': [
'数据清洗与标准化',
'中文分词技术',
'停用词处理',
'文本向量化基础'
]
},
{
'name': '词向量技术',
'theory_hours': 4,
'practice_hours': 6,
'project_hours': 2,
'subtopics': [
'Word2Vec算法原理',
'GloVe模型实现',
'FastText技术',
'词向量评估与应用'
]
}
]
def create_detailed_schedule(self):
"""创建详细学习时间表"""
schedule = {}
current_hour = 0
for topic in self.topics:
topic_schedule = {
'total_hours': topic['theory_hours'] + topic['practice_hours'] + topic['project_hours'],
'time_allocation': {
'theory': topic['theory_hours'],
'practice': topic['practice_hours'],
'project': topic['project_hours']
},
'daily_breakdown': []
}
# 按天分配时间（假设每周学习6天）
daily_hours = topic_schedule['total_hours'] / 6
subtopics = topic['subtopics']
for day in range(6):
if day < len(subtopics):
current_topic = subtopics[day]
else:
current_topic = f"综合练习与复习第{day+1}天"
day_schedule = {
'day': day + 1,
'topic': current_topic,
'hours': daily_hours,
'activities': self._get_daily_activities(day, topic)
}
topic_schedule['daily_breakdown'].append(day_schedule)
schedule[topic['name']] = topic_schedule
return schedule
def _get_daily_activities(self, day, topic):
"""获取每日学习活动"""
if day < 2: # 前两天偏重理论
return ['概念学习', '原理解析', '简单实践']
elif day < 4: # 中间两天偏重实践
return ['代码实现', '算法练习', '效果验证']
else: # 后两天偏重项目
return ['项目实战', '问题解决', '结果优化']
def generate_study_tips(self):
"""生成学习建议"""
tips = {
'学习策略': [
'理论与实践结合，每个概念都要动手实现',
'重视数学原理，理解算法背后的数学推导',
'多做练习，通过不同数据集验证学习效果'
],
'时间管理': [
'每天保证2-3小时专注学习时间',
'利用碎片时间复习和思考',
'定期回顾已学内容，防止遗忘'
],
'实践建议': [
'从简单例子开始，逐步增加复杂度',
'记录学习过程中遇到的问题和解决方案',
'尝试将不同技术组合使用'
]
}
return tips
# 使用示例
nlp_scheduler = NLPBasicsScheduler()
nlp_schedule = nlp_scheduler.create_detailed_schedule()
study_tips = nlp_scheduler.generate_study_tips()
print("=== NLP基础模块学习安排 ===")
for topic, schedule in nlp_schedule.items():
print(f"\n{topic} (总计{schedule['total_hours']}小时)")
print(f"理论:{schedule['time_allocation']['theory']}h "
f"实践:{schedule['time_allocation']['practice']}h "
f"项目:{schedule['time_allocation']['project']}h")
for day in schedule['daily_breakdown'][:3]: # 显示前3天
print(f" 第{day['day']}天: {day['topic']} ({day['hours']:.1f}h) - {', '.join(day['activities'])}")
---
b.序列模型模块（2周，24小时）
a.第一周：RNN/LSTM基础（12小时）
a.理论学习（4小时）
RNN架构原理和数学推导
LSTM门控机制详解
梯度消失和爆炸问题分析
b.代码实践（6小时）
从零实现简单RNN和LSTM单元
使用PyTorch构建多层LSTM网络
实现文本分类和序列标注任务
c.项目实战（2小时）
情感分析项目实现
命名实体识别项目开发
b.第二周：Seq2Seq和注意力机制（12小时）
a.理论学习（4小时）
编码器-解码器架构设计
注意力机制数学原理
Beam Search算法详解
b.代码实践（6小时）
实现基础的Seq2Seq模型
添加注意力机制的改进版本
实现机器翻译任务
c.项目实战（2小时）
对话系统原型开发
文本摘要生成任务
c.Transformer模块（3周，36小时）
a.第一周：自注意力机制（12小时）
a.理论学习（4小时）
自注意力数学原理深入理解
Query、Key、Value计算过程
多头注意力机制设计
b.代码实践（6小时）
从零实现自注意力计算
多头注意力层实现
注意力可视化技术
c.项目实战（2小时）
注意力机制在文本分类中的应用
可解释性分析项目
b.第二周：Transformer架构（12小时）
a.理论学习（4小时）
完整Transformer架构设计
位置编码原理和实现
残差连接和层归一化
b.代码实践（6小时）
完整Transformer模型实现
训练和推理流程优化
模型性能调试技巧
c.项目实战（2小时）
文本生成任务实现
Transformer在问答系统中的应用
b.第三周：Transformer应用与优化（12小时）
a.理论学习（4小时）
Transformer变体架构学习
性能优化技术
分布式训练方法
b.代码实践（6小时）
不同Transformer架构实现对比
模型压缩和加速技术
多GPU训练实践
c.项目实战（2小时）
大规模文本处理系统设计
实时NLP服务部署
03.学习时间优化策略
a.高效学习方法
a.主动学习
带着问题学习，主动思考和提问
及时实践和验证理论知识
定期总结和反思学习内容
b.间隔重复
使用间隔重复算法安排复习
第1天、第3天、第7天、第15天、第30天进行关键概念复习
建立个人知识管理系统
c.项目驱动学习
通过实际项目巩固理论知识
从简单到复杂的项目序列设计
每个模块都配备相应的实战项目
d.学习效率优化代码
---
import time
import random
from datetime import datetime, timedelta
import numpy as np
import matplotlib.pyplot as plt
class StudyEfficiencyOptimizer:
"""学习效率优化器"""
def __init__(self):
self.study_sessions = []
self.focus_scores = []
self.learning_curve = []
def record_study_session(self, topic, duration, focus_score=8, concepts_learned=0):
"""记录学习会话"""
session = {
'timestamp': datetime.now(),
'topic': topic,
'duration': duration, # 分钟
'focus_score': focus_score, # 1-10分
'concepts_learned': concepts_learned,
'efficiency': concepts_learned / duration * 60 if duration > 0 else 0
}
self.study_sessions.append(session)
self.focus_scores.append(focus_score)
return session
def calculate_optimal_study_time(self):
"""计算最优学习时间"""
if len(self.focus_scores) < 5:
return 120 # 默认2小时
# 分析学习效率曲线
efficiency_by_time = {}
for session in self.study_sessions:
hour = session['timestamp'].hour
if hour not in efficiency_by_time:
efficiency_by_time[hour] = []
efficiency_by_time[hour].append(session['efficiency'])
# 计算每个时间段的平均效率
avg_efficiency = {}
for hour, efficiencies in efficiency_by_time.items():
avg_efficiency[hour] = np.mean(efficiencies)
# 找出效率最高的时间段
if avg_efficiency:
best_hour = max(avg_efficiency, key=avg_efficiency.get)
return best_hour
else:
return 9 # 默认上午9点
def pomodoro_technique(self, total_minutes=120):
"""番茄工作法实现"""
work_duration = 25 # 工作时长（分钟）
short_break = 5 # 短休息（分钟）
long_break = 15 # 长休息（分钟）
sessions_per_long_break = 4
schedule = []
remaining_time = total_minutes
session_count = 0
while remaining_time > 0:
session_count += 1
# 工作时间
work_time = min(work_duration, remaining_time)
schedule.append({
'type': 'work',
'duration': work_time,
'session': session_count
})
remaining_time -= work_time
if remaining_time <= 0:
break
# 休息时间
if session_count % sessions_per_long_break == 0:
break_time = min(long_break, remaining_time)
break_type = 'long_break'
else:
break_time = min(short_break, remaining_time)
break_type = 'short_break'
schedule.append({
'type': break_type,
'duration': break_time,
'session': session_count
})
remaining_time -= break_time
return schedule
def spaced_repetition_scheduler(self, concepts, mastery_levels):
"""间隔重复调度器"""
# 艾宾浩斯遗忘曲线复习间隔
intervals = [1, 3, 7, 15, 30] # 天数
schedule = {}
current_day = 0
for concept, mastery in zip(concepts, mastery_levels):
# 根据掌握程度确定复习间隔
if mastery >= 0.9: # 掌握度很高
next_review = 30
elif mastery >= 0.7: # 掌握度较高
next_review = 15
elif mastery >= 0.5: # 掌握度一般
next_review = 7
else: # 掌握度较低
next_review = 3
review_day = current_day + next_review
if review_day not in schedule:
schedule[review_day] = []
schedule[review_day].append(concept)
return schedule
def analyze_learning_pattern(self):
"""分析学习模式"""
if not self.study_sessions:
return "暂无数据"
# 计算学习时长分布
durations = [s['duration'] for s in self.study_sessions]
avg_duration = np.mean(durations)
std_duration = np.std(durations)
# 计算效率分布
efficiencies = [s['efficiency'] for s in self.study_sessions if s['efficiency'] > 0]
avg_efficiency = np.mean(efficiencies) if efficiencies else 0
# 时间分布分析
hourly_distribution = {}
for session in self.study_sessions:
hour = session['timestamp'].hour
if hour not in hourly_distribution:
hourly_distribution[hour] = 0
hourly_distribution[hour] += session['duration']
# 找出最高效的学习时间段
best_hour = max(hourly_distribution, key=hourly_distribution.get) if hourly_distribution else 9
analysis = {
'avg_session_duration': avg_duration,
'session_duration_std': std_duration,
'avg_efficiency': avg_efficiency,
'most_productive_hour': best_hour,
'total_study_time': sum(durations),
'total_concepts_learned': sum(s['concepts_learned'] for s in self.study_sessions)
}
return analysis
def generate_study_recommendations(self):
"""生成学习建议"""
analysis = self.analyze_learning_pattern()
recommendations = []
# 学习时长建议
if analysis['avg_session_duration'] < 45:
recommendations.append("建议增加单次学习时长到45-60分钟")
elif analysis['avg_session_duration'] > 120:
recommendations.append("单次学习时长过长，建议拆分为多个短会话")
# 效率建议
if analysis['avg_efficiency'] < 0.5:
recommendations.append("学习效率偏低，建议调整学习方法和环境")
# 时间建议
best_hour = analysis['most_productive_hour']
recommendations.append(f"你在{best_hour}:00时学习效率最高，建议安排重要内容")
# 总体建议
if analysis['total_study_time'] < 720: # 12小时
recommendations.append("总学习时间偏少，建议增加每日学习时间")
return recommendations
# 使用示例
optimizer = StudyEfficiencyOptimizer()
# 模拟一些学习会话
topics = ['文本预处理', 'Word2Vec', 'LSTM', 'Transformer']
for i, topic in enumerate(topics):
optimizer.record_study_session(
topic=topic,
duration=random.randint(60, 120),
focus_score=random.randint(6, 10),
concepts_learned=random.randint(2, 8)
)
# 生成番茄工作法时间表
pomodoro_schedule = optimizer.pomodoro_technique(120)
print("=== 番茄工作法时间安排 ===")
for item in pomodoro_schedule:
item_type = "学习" if item['type'] == 'work' else ("长休息" if item['type'] == 'long_break' else "短休息")
print(f"{item_type}: {item['duration']}分钟")
# 分析学习模式
analysis = optimizer.analyze_learning_pattern()
print(f"\n=== 学习模式分析 ===")
print(f"平均学习时长: {analysis['avg_session_duration']:.1f}分钟")
print(f"平均学习效率: {analysis['avg_efficiency']:.2f}")
print(f"最高效时段: {analysis['most_productive_hour']}:00")
# 生成学习建议
recommendations = optimizer.generate_study_recommendations()
print(f"\n=== 学习建议 ===")
for rec in recommendations:
print(f"• {rec}")
---
b.知识管理体系
a.笔记系统建立
使用Notion、Obsidian等工具建立知识库
按照模块和主题组织笔记结构
建立概念之间的链接关系
b.代码管理
使用Git管理学习代码
建立项目模板和代码规范
定期备份和整理代码库
c.资源收集
建立论文、博客、教程资源库
使用标签和分类管理资源
定期更新和整理资源列表
04.学习效果评估与调整
a.阶段性评估方法
a.知识掌握度测试
每周进行理论知识测试
通过代码实现验证理解程度
项目完成情况评估
b.学习进度跟踪
建立学习进度跟踪表
设置检查点和里程碑
定期回顾和总结
c.效果评估指标
理论测试得分（目标>80%）
代码实现完成度（目标>90%）
项目质量评分（目标>85%）
学习时间利用率（目标>75%）
d.评估系统代码
---
class LearningAssessment:
"""学习效果评估系统"""
def __init__(self):
self.assessments = []
self.milestones = []
def add_knowledge_test(self, topic, score, max_score=100):
"""记录知识测试结果"""
test_result = {
'type': 'knowledge',
'topic': topic,
'score': score,
'max_score': max_score,
'percentage': score / max_score * 100,
'timestamp': datetime.now()
}
self.assessments.append(test_result)
return test_result
def add_code_assessment(self, project, completion_rate, quality_score, code_lines):
"""记录代码评估结果"""
code_result = {
'type': 'code',
'project': project,
'completion_rate': completion_rate, # 0-1
'quality_score': quality_score, # 0-10
'code_lines': code_lines,
'timestamp': datetime.now()
}
self.assessments.append(code_result)
return code_result
def add_milestone(self, milestone_name, target_date, description=""):
"""添加学习里程碑"""
milestone = {
'name': milestone_name,
'target_date': target_date,
'description': description,
'completed': False,
'completion_date': None
}
self.milestones.append(milestone)
return milestone
def complete_milestone(self, milestone_name):
"""标记里程碑完成"""
for milestone in self.milestones:
if milestone['name'] == milestone_name:
milestone['completed'] = True
milestone['completion_date'] = datetime.now()
return milestone
return None
def calculate_overall_progress(self):
"""计算总体学习进度"""
if not self.assessments:
return 0
knowledge_scores = [a['percentage'] for a in self.assessments if a['type'] == 'knowledge']
code_scores = [a['completion_rate'] * 10 for a in self.assessments if a['type'] == 'code']
all_scores = knowledge_scores + code_scores
if not all_scores:
return 0
return np.mean(all_scores)
def generate_progress_report(self):
"""生成学习进度报告"""
overall_progress = self.calculate_overall_progress()
completed_milestones = sum(1 for m in self.milestones if m['completed'])
total_milestones = len(self.milestones)
# 按类型统计评估结果
knowledge_tests = [a for a in self.assessments if a['type'] == 'knowledge']
code_projects = [a for a in self.assessments if a['type'] == 'code']
avg_knowledge_score = np.mean([t['percentage'] for t in knowledge_tests]) if knowledge_tests else 0
avg_code_quality = np.mean([p['quality_score'] for p in code_projects]) if code_projects else 0
report = {
'overall_progress': overall_progress,
'milestone_progress': completed_milestones / total_milestones * 100 if total_milestones > 0 else 0,
'knowledge_assessments': len(knowledge_tests),
'code_assessments': len(code_projects),
'avg_knowledge_score': avg_knowledge_score,
'avg_code_quality': avg_code_quality,
'total_assessments': len(self.assessments)
}
return report
def generate_recommendations(self):
"""生成改进建议"""
report = self.generate_progress_report()
recommendations = []
# 基于总体进度的建议
if report['overall_progress'] < 60:
recommendations.append("整体学习进度偏慢，建议增加学习时间和强度")
elif report['overall_progress'] < 80:
recommendations.append("学习进度良好，继续保持当前节奏")
# 基于知识掌握的建议
if report['avg_knowledge_score'] < 80:
recommendations.append("理论知识掌握需要加强，建议多做题和复习")
elif report['avg_knowledge_score'] > 95:
recommendations.append("理论知识掌握很好，可以增加实践难度")
# 基于代码质量的建议
if report['avg_code_quality'] < 7:
recommendations.append("代码实现质量需要提升，注意代码规范和最佳实践")
elif report['avg_code_quality'] > 9:
recommendations.append("代码质量优秀，可以尝试更复杂的项目")
# 基于里程碑的建议
if report['milestone_progress'] < 50:
recommendations.append("里程碑完成率偏低，需要调整学习计划")
return recommendations
# 使用示例
assessor = LearningAssessment()
# 添加里程碑
assessor.add_milestone("完成NLP基础学习", datetime.now() + timedelta(days=14))
assessor.add_milestone("完成Transformer实现", datetime.now() + timedelta(days=35))
# 模拟一些评估结果
assessor.add_knowledge_test("文本预处理", 85, 100)
assessor.add_knowledge_test("Word2Vec", 78, 100)
assessor.add_code_assessment("文本分类器", 0.9, 8.5, 150)
assessor.add_code_assessment("词向量训练", 0.85, 7.8, 200)
# 完成一个里程碑
assessor.complete_milestone("完成NLP基础学习")
# 生成报告
progress_report = assessor.generate_progress_report()
print("=== 学习进度报告 ===")
print(f"总体进度: {progress_report['overall_progress']:.1f}%")
print(f"里程碑进度: {progress_report['milestone_progress']:.1f}%")
print(f"知识测试平均分: {progress_report['avg_knowledge_score']:.1f}")
print(f"代码项目平均质量: {progress_report['avg_code_quality']:.1f}/10")
# 生成建议
recommendations = assessor.generate_recommendations()
print(f"\n=== 改进建议 ===")
for rec in recommendations:
print(f"• {rec}")
---
b.学习计划调整
a.动态调整策略
根据评估结果调整学习计划
识别薄弱环节，增加相应练习
优化时间分配，提高学习效率
b.个性化定制
根据个人学习特点定制方法
调整学习节奏和难度
选择最适合的学习资源和工具
c.长期规划
制定长期职业发展目标
将课程学习与实际应用结合
建立持续学习的习惯和体系
1.5 岗位关联
01.NLP工程师岗位分析
a.核心技能要求
a.技术能力要求
a.文本处理技术
熟练掌握文本预处理、分词、特征提取等基础技术
能够处理中文、英文、多语言混合文本数据
掌握正则表达式、数据清洗等数据预处理技能
b.机器学习基础
理解分类、回归、聚类等机器学习算法
掌握特征工程、模型选择、超参数调优
熟悉模型评估指标和交叉验证方法
c.深度学习框架
精通PyTorch或TensorFlow深度学习框架
能够实现RNN、LSTM、Transformer等神经网络模型
掌握模型训练、优化、部署的完整流程
d.NLP专业知识
深入理解词向量、序列模型、注意力机制等核心概念
熟悉BERT、GPT等预训练模型的原理和使用
掌握文本分类、命名实体识别、机器翻译等NLP任务
b.工程能力要求
a.编程能力
精通Python编程，熟悉常用的数据科学生态
具备良好的代码规范和工程实践
能够进行代码重构和性能优化
b.系统设计
能够设计NLP系统的整体架构
理解分布式系统和微服务架构
掌握API设计和接口规范
c.数据处理
熟练处理大规模文本数据
掌握数据存储、查询、索引等技术
能够设计高效的数据处理流水线
d.模型部署
熟悉模型服务化和API部署
掌握Docker、Kubernetes等容器化技术
了解模型监控和性能优化
c.业务理解能力
a.需求分析
能够深入理解业务需求和用户场景
将业务问题转化为技术解决方案
设计符合业务需求的NLP系统
b.效果评估
建立有效的模型评估体系
能够从业务角度评估模型效果
持续优化模型性能和用户体验
c.技术沟通
能够向非技术人员解释复杂的技术概念
参与产品设计和技术方案讨论
与其他团队有效协作
b.薪资水平分析
a.初级NLP工程师（0-2年经验）
技术要求：掌握基础NLP技术，能够独立完成简单任务
薪资范围：15-25K/月，年薪18-30万
主要职责：文本预处理、基础模型实现、数据标注和质量控制
发展方向：积累项目经验，提升技术深度，承担更多责任
b.中级NLP工程师（2-5年经验）
技术要求：熟悉主流NLP模型，能够独立设计和实现复杂系统
薪资范围：25-40K/月，年薪30-48万
主要职责：核心算法研发、系统架构设计、技术方案制定
发展方向：技术专家或团队管理，负责重要项目和技术决策
c.高级NLP工程师（5年以上经验）
技术要求：深入理解NLP前沿技术，能够引领技术发展方向
薪资范围：40K+/月，年薪48万以上，优秀者可达百万
主要职责：技术架构设计、团队管理、技术创新
发展方向：技术总监、首席科学家等高级技术管理职位
d.薪资影响因素
a.技术深度
对核心算法的理解深度直接影响薪资水平
掌握前沿技术如大语言模型的工程师薪资更高
具备算法优化和创新能力的人才稀缺度高
b.项目经验
有大型项目经验的工程师薪资竞争力强
成功项目案例是薪资谈判的重要筹码
跨领域项目经验增加人才价值
c.行业背景
互联网、金融、医疗等高价值行业薪资水平更高
有行业know-how的工程师更受青睐
数据安全和合规经验在某些行业很重要
d.地域因素
一线城市（北京、上海、深圳、杭州）薪资水平最高
新一线城市（成都、武汉、南京等）发展潜力大
远程工作机会增加，地域限制逐步减弱
c.职业发展路径
a.技术专家路线
初级工程师 → 高级工程师 → 首席工程师 → 技术专家
专注于技术深度和创新能力
在某一细分领域建立专业影响力
b.技术管理路线
工程师 → 技术主管 → 技术经理 → 技术总监
在技术基础上发展管理能力
负责团队建设和项目规划
c.产品技术路线
技术工程师 → 产品技术专家 → AI产品经理
结合技术和产品思维
专注于AI产品的设计和落地
d.创业路线
积累足够经验后自主创业
利用NLP技术开发创新产品或服务
需要补充商业和管理知识
d.NLP工程师技能评估代码
---
class NLPEngineerSkillAssessment:
"""NLP工程师技能评估系统"""
def __init__(self):
self.skill_categories = {
'text_processing': {
'name': '文本处理',
'skills': [
'数据清洗与预处理',
'中文分词技术',
'特征提取',
'数据标注'
],
'weight': 0.2
},
'machine_learning': {
'name': '机器学习',
'skills': [
'传统ML算法',
'特征工程',
'模型评估',
'超参数优化'
],
'weight': 0.2
},
'deep_learning': {
'name': '深度学习',
'skills': [
'神经网络基础',
'PyTorch/TensorFlow',
'模型训练与优化',
'模型部署'
],
'weight': 0.25
},
'nlp_knowledge': {
'name': 'NLP专业知识',
'skills': [
'词向量技术',
'序列模型',
'Transformer',
'预训练模型'
],
'weight': 0.25
},
'engineering_skills': {
'name': '工程能力',
'skills': [
'Python编程',
'系统设计',
'API开发',
'性能优化'
],
'weight': 0.1
}
}
def assess_skills(self, skill_scores):
"""评估技能水平"""
category_scores = {}
total_score = 0
for category, config in self.skill_categories.items():
if category in skill_scores:
# 计算类别平均分
scores = skill_scores[category]
avg_score = np.mean(scores)
weighted_score = avg_score * config['weight']
category_scores[category] = {
'name': config['name'],
'avg_score': avg_score,
'weighted_score': weighted_score,
'skills': dict(zip(config['skills'], scores))
}
total_score += weighted_score
return {
'total_score': total_score,
'category_scores': category_scores,
'level': self._determine_level(total_score)
}
def _determine_level(self, score):
"""确定技能等级"""
if score >= 90:
return '专家级'
elif score >= 80:
return '高级'
elif score >= 70:
return '中级'
elif score >= 60:
return '初级'
else:
return '入门'
def generate_skill_gap_analysis(self, current_scores, target_level='高级'):
"""生成技能差距分析"""
target_scores = {
'初级': 65,
'中级': 75,
'高级': 85,
'专家级': 95
}
target_score = target_scores.get(target_level, 75)
current_assessment = self.assess_skills(current_scores)
gaps = {}
for category, scores in current_scores.items():
if category in self.skill_categories:
current_avg = np.mean(scores)
gap = max(0, target_score - current_avg)
if gap > 0:
gaps[category] = {
'name': self.skill_categories[category]['name'],
'current_score': current_avg,
'target_score': target_score,
'gap': gap,
'priority': 'high' if gap > 20 else 'medium' if gap > 10 else 'low'
}
return {
'current_level': current_assessment['level'],
'target_level': target_level,
'gaps': gaps,
'recommendations': self._generate_learning_recommendations(gaps)
}
def _generate_learning_recommendations(self, gaps):
"""生成学习建议"""
recommendations = []
for category, gap_info in gaps.items():
rec = {
'category': gap_info['name'],
'priority': gap_info['priority'],
'suggestions': []
}
if category == 'text_processing':
if gap_info['gap'] > 15:
rec['suggestions'].extend([
'系统学习jieba、spaCy等分词工具',
'实践真实数据集的预处理任务',
'学习数据清洗和标准化技术'
])
else:
rec['suggestions'].extend([
'优化现有预处理流程',
'学习高级特征提取技术'
])
elif category == 'deep_learning':
if gap_info['gap'] > 15:
rec['suggestions'].extend([
'深入学习PyTorch或TensorFlow',
'实践RNN、LSTM、Transformer模型',
'完成深度学习专项课程'
])
else:
rec['suggestions'].extend([
'学习模型优化技巧',
'实践复杂的模型架构'
])
# 为其他类别添加建议...
recommendations.append(rec)
return recommendations
def estimate_salary_range(self, skill_assessment):
"""估算薪资范围"""
score = skill_assessment['total_score']
level = skill_assessment['level']
# 基础薪资范围（月薪，单位：千元）
base_ranges = {
'入门': (12, 18),
'初级': (15, 25),
'中级': (25, 40),
'高级': (40, 65),
'专家级': (65, 100)
}
base_min, base_max = base_ranges.get(level, (15, 25))
# 根据具体分数调整
score_factor = (score - 50) / 50 # 归一化到0-1
adjusted_min = base_min + (base_max - base_min) * score_factor * 0.3
adjusted_max = base_max + (base_max - base_min) * score_factor * 0.5
# 地域调整因子
location_factors = {
'北京': 1.2,
'上海': 1.2,
'深圳': 1.15,
'杭州': 1.1,
'成都': 0.9,
'武汉': 0.9,
'其他': 1.0
}
return {
'monthly_range': (adjusted_min, adjusted_max),
'annual_range': (adjusted_min * 12, adjusted_max * 12),
'level': level,
'location_adjustments': location_factors
}
# 使用示例
assessor = NLPEngineerSkillAssessment()
# 模拟技能评分（1-100分）
current_skills = {
'text_processing': [85, 80, 75, 70],
'machine_learning': [75, 70, 80, 65],
'deep_learning': [70, 75, 65, 60],
'nlp_knowledge': [80, 75, 70, 65],
'engineering_skills': [80, 75, 70, 65]
}
# 评估当前技能水平
skill_assessment = assessor.assess_skills(current_skills)
print("=== NLP工程师技能评估 ===")
print(f"总分: {skill_assessment['total_score']:.1f}")
print(f"等级: {skill_assessment['level']}\n")
print("各技能类别评分:")
for category, info in skill_assessment['category_scores'].items():
print(f" {info['name']}: {info['avg_score']:.1f}分 (权重: {info['weighted_score']:.2f})")
# 薪资估算
salary_estimate = assessor.estimate_salary_range(skill_assessment)
print(f"\n=== 薪资估算 ===")
print(f"月薪范围: {salary_estimate['monthly_range'][0]:.0f}K - {salary_estimate['monthly_range'][1]:.0f}K")
print(f"年薪范围: {salary_estimate['annual_range'][0]:.0f}万 - {salary_estimate['annual_range'][1]:.0f}万")
# 技能差距分析
gap_analysis = assessor.generate_skill_gap_analysis(current_skills, '高级')
print(f"\n=== 技能提升建议 ===")
print(f"当前水平: {gap_analysis['current_level']} → 目标水平: {gap_analysis['target_level']}")
for gap in gap_analysis['gaps']:
print(f"\n{gap['name']} (差距: {gap['gap']:.1f}分, 优先级: {gap['priority']}):")
for suggestion in gap['suggestions']:
print(f" • {suggestion}")
---
02.算法工程师岗位分析
a.与NLP工程师的异同
a.工作重点差异
NLP工程师：专注于自然语言处理技术的应用和落地
算法工程师：更广泛地涉及各类机器学习和深度学习算法
NLP工程师更注重文本数据的特殊性，算法工程师更注重算法的通用性
b.技术栈差异
NLP工程师：深度掌握NLP专用技术和工具
算法工程师：需要掌握更广泛的算法类型和数学基础
NLP工程师更偏向应用层，算法工程师更偏向算法层
c.职业发展差异
NLP工程师：更专业化，在NLP领域深耕
算法工程师：更通用化，可以在不同AI领域发展
d.薪资对比分析
初级阶段：两者薪资水平相近，算法工程师略高
中级阶段：NLP工程师在大模型时代薪资上涨较快
高级阶段：顶级专家薪资水平相当，都可达百万级别
b.算法工程师核心要求
a.数学基础要求
a.线性代数
深入理解矩阵运算、特征值分解、奇异值分解
掌握向量空间、正交性、投影等概念
能够从数学角度理解机器学习算法
b.概率统计
熟练掌握概率分布、贝叶斯推断、假设检验
理解最大似然估计、最大后验估计等方法
能够设计和分析实验结果
c.优化理论
理解梯度下降、牛顿法、拟牛顿法等优化算法
掌握凸优化理论，能够分析算法收敛性
了解随机优化和在线优化方法
d.信息论
理解熵、交叉熵、KL散度等概念
能够分析信息瓶颈和表示学习
掌握互信息和特征选择
b.算法设计能力
a.问题建模
能够将实际问题抽象为数学模型
选择合适的损失函数和评估指标
设计有效的特征表示方法
b.算法改进
在现有算法基础上进行创新和改进
分析算法的复杂度和性能瓶颈
针对特定场景优化算法表现
c.新算法研发
理解最新研究成果，实现新算法
结合多个算法的优点进行融合
发表高质量的研究论文
c.系统实现能力
a.高效实现
编写高效、可扩展的算法代码
优化算法的计算复杂度和内存使用
利用并行计算和GPU加速
b.系统集成
将算法集成到实际系统中
设计合理的API接口和数据流
保证系统的稳定性和可维护性
c.性能监控
建立算法性能监控体系
及时发现和解决性能问题
持续优化算法效果
c.算法工程师职业路径
a.技术研究方向
a.学术路线
博士毕业 → 博士后 → 助理教授 → 副教授 → 教授
专注于学术研究和人才培养
在顶级会议和期刊发表研究成果
b.研究院路线
研究员 → 高级研究员 → 首席研究员 → 研究总监
在企业研究院从事前沿技术研究
将研究成果转化为实际产品
c.算法专家路线
算法工程师 → 高级算法工程师 → 算法专家 → 首席算法科学家
专注于特定领域的算法研发
成为技术权威和思想领袖
b.技术应用方向
a.工程实现路线
算法工程师 → 高级算法工程师 → 算法架构师
专注于算法的工程实现和系统优化
负责大规模算法系统的设计和实现
b.产品技术路线
算法工程师 → 算法产品经理 → AI产品总监
结合算法技术和产品思维
负责AI产品的规划和管理
c.创业路线
技术积累 → 自主创业 → 技术创始人
利用算法技术开发创新产品
建立技术驱动的创业公司
03.大语言模型工程师岗位
a.新兴岗位特点
a.市场需求爆发
随着ChatGPT等大模型的兴起，LLM工程师需求激增
企业急需能够开发和应用大语言模型的专业人才
岗位数量增长迅速，竞争相对较小
b.技术门槛较高
需要深厚的深度学习和NLP基础
要求掌握大模型训练和调优技术
需要大量计算资源和实践经验
c.薪资水平领先
由于人才稀缺，薪资水平普遍较高
优秀人才可获得股票期权等长期激励
职业发展前景广阔
d.快速发展的领域
技术更新速度快，需要持续学习
研究和应用并重，理论与实践结合
跨学科知识要求高
b.核心技术能力
a.大模型架构理解
a.Transformer深入理解
深入理解自注意力机制和多头注意力
掌握位置编码和残差连接的作用
理解不同规模模型的设计权衡
b.模型训练技术
掌握分布式训练和混合精度训练
理解梯度累积和学习率调度
熟悉各种正则化和稳定训练技术
c.模型优化方法
了解知识蒸馏、模型量化、剪枝等技术
掌握参数高效微调方法
理解模型压缩和部署优化
b.微调技术掌握
a.全参数微调
理解传统微调方法的优缺点
掌握不同任务上的微调策略
熟悉微调过程中的超参数调优
b.参数高效微调
深入理解LoRA、QLoRA等技术原理
能够实现和优化各种PEFT方法
掌握适配器设计和调优技术
c.Prompt工程
理解Prompt设计原理和最佳实践
掌握上下文学习（In-Context Learning）
熟悉思维链（Chain-of-Thought）等高级技术
c.工程实现能力
a.模型部署
掌握大模型服务化和API部署
熟悉模型推理优化和加速技术
理解负载均衡和弹性扩缩容
b.资源管理
有效管理GPU资源和使用成本
优化模型推理延迟和吞吐量
实现模型版本管理和A/B测试
c.监控系统
建立模型性能监控和告警系统
监控模型输出的质量和安全性
实现实时异常检测和处理
c.大语言模型工程师技能要求
a.基础技能要求
a.编程能力
精通Python，熟悉异步编程和并发处理
掌握C++/CUDA等高性能编程语言
熟悉云计算平台和容器技术
b.深度学习基础
深入理解神经网络和反向传播
熟悉各种优化器和训练技巧
掌握模型评估和调试方法
c.数学基础
扎实的线性代数和概率统计基础
理解信息论和优化理论
能够阅读和理解技术论文
b.专业技能要求
a.大模型训练
有大规模模型训练经验
熟悉分布式训练框架
掌握训练稳定性和收敛优化
b.模型微调
丰富的微调项目经验
能够针对不同任务设计微调策略
熟悉各种PEFT方法的使用
c.模型评估
建立完善的模型评估体系
设计自动化的评估流程
能够分析模型失败案例并改进
c.软技能要求
a.研究能力
能够快速学习和理解新技术
具备独立研究和问题解决能力
有论文阅读和复现经验
b.沟通能力
能够向非技术人员解释复杂概念
良好的团队协作和项目管理能力
清晰的技术文档编写能力
c.创新思维
能够提出创新的技术解决方案
具备产品思维和用户洞察
勇于尝试新技术和方法
d.大语言模型工程师发展路径
a.技术专家路线
初级LLM工程师 → 高级LLM工程师 → LLM技术专家 → 首席LLM科学家
专注于大模型技术研发和创新
在某一细分领域建立技术权威
b.产品技术路线
LLM工程师 → LLM产品专家 → AI产品经理 → 产品总监
结合技术能力和产品思维
负责LLM产品的规划和管理
c.创业路线
技术积累 → 技术合伙人 → 技术创始人
利用大模型技术开发创新产品
建立技术驱动的创业公司
04.AI产品经理岗位
a.岗位特色分析
a.技术与产品结合
需要既懂技术又懂产品的复合型人才
能够理解技术可行性并转化为产品需求
在技术团队和业务团队之间搭建桥梁
b.市场洞察力
深入了解AI技术发展趋势和市场机会
能够识别有价值的应用场景
具备商业敏感度和用户洞察力
c.跨领域知识
需要理解多个行业和领域的业务逻辑
能够将AI技术与具体业务场景结合
具备产品设计和用户体验思维
d.沟通协调能力
与技术团队、业务团队、设计团队等多方协作
能够有效传达产品愿景和需求
具备项目管理和资源协调能力
b.核心能力要求
a.技术理解能力
a.AI技术基础
理解机器学习、深度学习的基本原理
了解NLP、计算机视觉等AI技术特点
能够评估技术可行性和开发成本
b.技术趋势跟踪
持续关注AI技术发展动态
理解新技术对产品的影响
能够预判技术发展方向
c.技术沟通
能够与工程师进行有效技术沟通
理解技术限制和挑战
协调技术方案和产品需求
b.产品设计能力
a.需求分析
深入理解用户需求和痛点
能够设计产品功能和使用流程
制定产品路线图和迭代计划
b.用户体验
关注产品的易用性和用户满意度
能够设计直观的用户界面
收集用户反馈并持续改进
c.商业化思维
理解产品的商业价值和盈利模式
能够制定产品定价和营销策略
关注产品的市场竞争力
c.项目管理能力
a.团队协调
有效管理跨职能团队
协调技术、设计、测试等各方资源
确保项目按时交付和质量
b.风险管理
识别项目风险和潜在问题
制定应对方案和应急预案
平衡技术复杂度和产品价值
c.数据驱动
建立产品数据监控体系
基于数据分析优化产品决策
持续改进产品性能和用户体验
c.AI产品经理发展路径
a.产品专家路线
产品专员 → 产品经理 → 高级产品经理 → 产品总监
在AI产品领域深耕，成为产品专家
负责重要产品线的产品规划和执行
b.技术管理路线
产品经理 → 技术产品经理 → 技术总监
在产品基础上发展技术管理能力
负责技术产品的战略规划和管理
c.创业路线
产品经验积累 → 产品合伙人 → 产品创始人
利用产品经验和市场洞察创业
建立产品驱动的创业公司
05.就业方向与机会分析
a.互联网科技公司
a.大型科技公司
腾讯、阿里巴巴、字节跳动、百度等
提供完整的AI技术栈和应用场景
薪资待遇优厚，发展空间大
主要岗位：NLP工程师、算法工程师、AI研究员
b.独角兽企业
商汤、旷视、依图等AI独角兽
技术前沿性强，成长速度快
股权激励机会多
主要岗位：深度学习工程师、计算机视觉工程师
c.创业公司
AI领域创业公司
技术挑战大，责任重
成长空间不确定但潜力大
主要岗位：全栈AI工程师、技术合伙人
b.AI技术服务公司
a.AI解决方案提供商
提供行业AI解决方案和咨询服务
接触不同行业的应用场景
项目经验丰富
主要岗位：AI顾问、解决方案架构师
b.语音识别公司
科大讯飞、云知声等语音技术公司
专注于语音识别和语音合成技术
技术专业化程度高
主要岗位：语音算法工程师、语音产品经理
c.机器学习平台公司
提供机器学习平台和工具服务
技术门槛高，标准化程度高
商业模式成熟
主要岗位：ML平台工程师、DevOps工程师
c.传统行业AI部门
a.金融行业
银行、证券、保险等金融机构
风险控制、投资分析、客户服务等应用
数据安全和合规要求高
主要岗位：金融AI工程师、量化分析师
b.医疗健康
医院、医疗器械公司、医疗AI公司
医疗影像、药物研发、健康管理等应用
专业性强，社会责任重大
主要岗位：医疗AI工程师、生物信息工程师
c.制造业
智能制造、工业自动化等
质量检测、预测维护、生产优化等应用
与传统工业技术结合
主要岗位：工业AI工程师、智能制造专家
d.教育行业
在线教育、教育科技公司
智能辅导、个性化学习、教育内容生成等应用
教育与技术结合
主要岗位：教育AI工程师、教育产品经理
d.研究与学术机构
a.高校和研究机构
清华、北大、中科院等顶尖院校
从事前沿AI研究
学术氛围浓厚
主要岗位：研究员、博士后、教授
b.国际科技公司研究院
Google AI、Microsoft Research、Facebook AI等
国际顶级研究环境
机会接触前沿技术
主要岗位：研究科学家、访问学者
c.国家研究机构
中科院自动化所、信通所等
国家重大科研项目
稳定性高
主要岗位：副研究员、助理研究员
e.职业选择建议
a.个人兴趣导向
技术研究型：选择研究机构或大公司研究院
工程实现型：选择互联网公司或AI服务公司
产品导向型：选择产品公司或创业公司
b.发展空间考虑
技术深度：选择专业化程度高的公司和岗位
广度发展：选择技术栈完整的综合性公司
管理路线：选择有一定规模和发展成熟的公司
c.薪资待遇平衡
初期发展：可选择有成长空间的创业公司
稳定发展：选择薪资福利好的大公司
长期收益：考虑股权激励和职业发展
d.工作生活平衡
快节奏：互联网公司和创业公司
稳定节奏：传统企业和研究机构
灵活工作：一些国际化公司和远程工作机会
2 NLP基础
2.1 文本预处理
01.文本清洗与标准化
a.数据清洗原理
文本清洗是NLP处理的第一步，目的是去除无关信息、统一格式、提高数据质量。清洗的好坏直接影响后续模型的性能。清洗过程包括去除HTML标签、特殊字符、标准化格式等操作。
b.基础清洗技术
a.去除HTML标签和特殊字符
---
import re
import html
from typing import List, Optional, Dict, Any
import unicodedata
class TextCleaner:
"""文本清洗器 - 提供全面的文本清洗功能"""
def __init__(self):
# 常用的HTML标签
self.html_pattern = re.compile(r'<[^>]+>')
# URL模式
self.url_pattern = re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')
# 邮箱模式
self.email_pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')
# 电话号码模式
self.phone_pattern = re.compile(r'(\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}')
# 数字模式
self.number_pattern = re.compile(r'\b\d+\.?\d*\b')
# 特殊字符模式
self.special_char_pattern = re.compile(r'[^\w\s\u4e00-\u9fff]')
# 多余空格模式
self.space_pattern = re.compile(r'\s+')
def remove_html_tags(self, text: str) -> str:
"""移除HTML标签"""
# 先解码HTML实体
text = html.unescape(text)
# 移除HTML标签
text = self.html_pattern.sub(' ', text)
return text.strip()
def remove_urls(self, text: str) -> str:
"""移除URL"""
return self.url_pattern.sub(' ', text)
def remove_emails(self, text: str) -> str:
"""移除邮箱地址"""
return self.email_pattern.sub(' ', text)
def remove_phone_numbers(self, text: str) -> str:
"""移除电话号码"""
return self.phone_pattern.sub(' ', text)
def remove_numbers(self, text: str, keep_digit_words: bool = False) -> str:
"""移除数字"""
if keep_digit_words:
# 保留数字词汇如"一千"、"二十"等中文数字
chinese_numbers = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十',
'百', '千', '万', '亿', '两', '廿', '卅']
def replace_number(match):
num = match.group()
# 检查是否包含中文数字字符
if any(cn in text for cn in chinese_numbers):
return num
return ' '
return self.number_pattern.sub(replace_number, text)
else:
return self.number_pattern.sub(' ', text)
def remove_special_characters(self, text: str, keep_punctuation: bool = True) -> str:
"""移除特殊字符"""
if keep_punctuation:
# 保留基本标点符号
allowed_chars = '.,!?;:()[\]{}"\''
pattern = re.compile(r'[^\w\s\u4e00-\u9fff' + re.escape(allowed_chars) + ']')
return pattern.sub(' ', text)
else:
return self.special_char_pattern.sub(' ', text)
def normalize_whitespace(self, text: str) -> str:
"""标准化空白字符"""
# 替换各种空白字符为空格
text = re.sub(r'[\r\n\t\f\v]+', ' ', text)
# 去除多余空格
text = self.space_pattern.sub(' ', text)
return text.strip()
def normalize_unicode(self, text: str, form: str = 'NFKC') -> str:
"""Unicode标准化"""
return unicodedata.normalize(form, text)
def clean_text(self, text: str, **kwargs) -> str:
"""完整的文本清洗流程"""
# 默认参数
config = {
'remove_html': True,
'remove_urls': True,
'remove_emails': True,
'remove_phones': True,
'remove_numbers': False,
'keep_digit_words': True,
'remove_special_chars': True,
'keep_punctuation': False,
'normalize_whitespace': True,
'normalize_unicode': True
}
config.update(kwargs)
if not isinstance(text, str):
text = str(text)
# Unicode标准化
if config['normalize_unicode']:
text = self.normalize_unicode(text)
# 逐步清洗
if config['remove_html']:
text = self.remove_html_tags(text)
if config['remove_urls']:
text = self.remove_urls(text)
if config['remove_emails']:
text = self.remove_emails(text)
if config['remove_phones']:
text = self.remove_phone_numbers(text)
if config['remove_numbers']:
text = self.remove_numbers(text, config['keep_digit_words'])
if config['remove_special_chars']:
text = self.remove_special_characters(text, config['keep_punctuation'])
if config['normalize_whitespace']:
text = self.normalize_whitespace(text)
return text
def batch_clean(self, texts: List[str], **kwargs) -> List[str]:
"""批量清洗文本"""
return [self.clean_text(text, **kwargs) for text in texts]
# 使用示例
cleaner = TextCleaner()
# 测试文本
test_text = """
<html>
<body>
<h1>测试文本清洗</h1>
<p>访问我们的网站: https://example.com</p>
<p>联系我们: [email protected] 或 +1-555-123-4567</p>
<p>价格: $99.99, 数量: 100个</p>
<p>中文数字: 一千二百三十五, 阿拉伯数字: 1235</p>
<p>特殊字符: @#$%^&*()_+-=[]{}|;':",./<>?</p>
</body>
</html>
"""
# 基础清洗
basic_cleaned = cleaner.clean_text(test_text)
print("=== 基础清洗结果 ===")
print(basic_cleaned)
# 自定义清洗配置
custom_cleaned = cleaner.clean_text(
test_text,
remove_numbers=False,
keep_punctuation=True,
keep_digit_words=True
)
print("\n=== 自定义清洗结果 ===")
print(custom_cleaned)
# 批量清洗
texts = [
"这是第一个测试文本！包含一些数字123。",
"<p>第二个文本有HTML标签和URL: http://test.com</p>",
"第三个文本：联系电话138-0000-0000，邮箱[email protected]"
]
batch_cleaned = cleaner.batch_clean(texts)
print("\n=== 批量清洗结果 ===")
for i, text in enumerate(batch_cleaned):
print(f"文本{i+1}: {text}")
---
b.大小写转换与标准化
---
class TextNormalizer:
"""文本标准化器"""
def __init__(self):
pass
def to_lowercase(self, text: str) -> str:
"""转换为小写"""
return text.lower()
def to_uppercase(self, text: str) -> str:
"""转换为大写"""
return text.upper()
def to_title_case(self, text: str) -> str:
"""转换为标题格式（首字母大写）"""
return text.title()
def capitalize_sentences(self, text: str) -> str:
"""句子首字母大写"""
sentences = re.split(r'[.!?]+', text)
capitalized_sentences = [s.strip().capitalize() for s in sentences if s.strip()]
return '. '.join(capitalized_sentences)
def normalize_case(self, text: str, style: str = 'lower') -> str:
"""统一大小写格式"""
style_map = {
'lower': self.to_lowercase,
'upper': self.to_uppercase,
'title': self.to_title_case,
'sentence': lambda x: self.capitalize_sentences(x.lower())
}
return style_map.get(style, self.to_lowercase)(text)
def expand_contractions(self, text: str) -> str:
"""展开英文缩写（如don't -> do not）"""
contractions = {
"won't": "will not",
"can't": "cannot",
"n't": " not",
"'re": " are",
"'ve": " have",
"'ll": " will",
"'d": " would",
"'m": " am"
}
for contraction, expansion in contractions.items():
text = re.sub(contraction, expansion, text)
return text
def normalize_chinese_punctuation(self, text: str) -> str:
"""标准化中文标点符号"""
# 英文标点转中文标点
punctuation_map = {
',': '，',
'.': '。',
'?': '？',
'!': '！',
':': '：',
';': '；',
'"': '"',
"'": ''',
'(': '（',
')': '）',
'[': '【',
']': '】',
'{': '｛',
'}': '｝'
}
for en_punct, zh_punct in punctuation_map.items():
text = text.replace(en_punct, zh_punct)
return text
def fullwidth_to_halfwidth(self, text: str) -> str:
"""全角字符转半角"""
result = []
for char in text:
code = ord(char)
if 0xFF00 <= code <= 0xFF5F: # 全角字符范围
result.append(chr(code - 0xFEE0))
elif code == 0x3000: # 全角空格
result.append(' ')
else:
result.append(char)
return ''.join(result)
def normalize_text(self, text: str, config: Optional[Dict[str, Any]] = None) -> str:
"""完整的文本标准化"""
if config is None:
config = {
'case_style': 'lower',
'expand_contractions': True,
'normalize_chinese_punct': True,
'fullwidth_to_halfwidth': True
}
# 全角转半角
if config.get('fullwidth_to_halfwidth', True):
text = self.fullwidth_to_halfwidth(text)
# 展开英文缩写
if config.get('expand_contractions', True):
text = self.expand_contractions(text)
# 标准化中文标点
if config.get('normalize_chinese_punct', True):
text = self.normalize_chinese_punctuation(text)
# 大小写标准化
case_style = config.get('case_style', 'lower')
text = self.normalize_case(text, case_style)
return text
# 使用示例
normalizer = TextNormalizer()
# 测试文本
test_text = "Hello, World! 这是一篇TEST文档。don't worry, it's easy！全角：，。；"
print("=== 原始文本 ===")
print(test_text)
# 不同的大小写标准化
print("\n=== 大小写标准化 ===")
print(f"小写: {normalizer.normalize_case(test_text, 'lower')}")
print(f"大写: {normalizer.normalize_case(test_text, 'upper')}")
print(f"标题: {normalizer.normalize_case(test_text, 'title')}")
# 完整标准化
print("\n=== 完整标准化 ===")
normalized = normalizer.normalize_text(test_text)
print(normalized)
---
02.文本分词与标记化
a.分词基础理论
分词是将连续的文本序列切分成有意义的词汇单元的过程。对于中文等没有明显词分隔符的语言，分词是NLP的基础步骤。英文分词相对简单，主要基于空格和标点符号。
b.英文分词技术
a.基础分词方法
---
from nltk.tokenize import word_tokenize, sent_tokenize, TreebankWordTokenizer
from nltk.tokenize import TweetTokenizer, RegexpTokenizer
import spacy
import re
from typing import List, Tuple
class EnglishTokenizer:
"""英文分词器"""
def __init__(self):
# 加载spacy模型
try:
self.nlp = spacy.load("en_core_web_sm")
except OSError:
print("请安装spacy英语模型: python -m spacy download en_core_web_sm")
self.nlp = None
def basic_tokenize(self, text: str) -> List[str]:
"""基础分词（基于空格和标点）"""
# 简单的基于空格和标点的分词
tokens = re.findall(r'\b\w+\b', text.lower())
return tokens
def nltk_word_tokenize(self, text: str) -> List[str]:
"""使用NLTK的word_tokenize"""
try:
tokens = word_tokenize(text.lower())
return tokens
except:
print("请下载NLTK数据: nltk.download('punkt')")
return self.basic_tokenize(text)
def nltk_sentence_tokenize(self, text: str) -> List[str]:
"""句子级分词"""
try:
sentences = sent_tokenize(text)
return sentences
except:
print("请下载NLTK数据: nltk.download('punkt')")
return [text]
def treebank_tokenize(self, text: str) -> List[str]:
"""Treebank分词器"""
tokenizer = TreebankWordTokenizer()
tokens = tokenizer.tokenize(text.lower())
return tokens
def tweet_tokenize(self, text: str) -> List[str]:
"""适用于社交媒体的分词"""
tokenizer = TweetTokenizer(preserve_case=False, strip_handles=True, reduce_len=True)
tokens = tokenizer.tokenize(text)
return tokens
def regex_tokenize(self, text: str, pattern: str = r'\b\w+\b') -> List[str]:
"""正则表达式分词"""
tokenizer = RegexpTokenizer(pattern)
tokens = tokenizer.tokenize(text.lower())
return tokens
def spacy_tokenize(self, text: str) -> List[str]:
"""使用spaCy进行分词"""
if self.nlp is None:
return self.basic_tokenize(text)
doc = self.nlp(text.lower())
tokens = [token.text for token in doc if not token.is_space]
return tokens
def spacy_tokenize_with_info(self, text: str) -> List[Tuple[str, str, str, bool]]:
"""spacy分词并返回词性、词形等信息"""
if self.nlp is None:
return [(token, 'UNKNOWN', 'UNKNOWN', False) for token in self.basic_tokenize(text)]
doc = self.nlp(text.lower())
token_info = []
for token in doc:
if not token.is_space:
token_info.append((
token.text,
token.pos_, # 词性
token.lemma_, # 词元
token.is_stop # 是否停用词
))
return token_info
def compare_tokenizers(self, text: str) -> Dict[str, List[str]]:
"""比较不同分词器的结果"""
results = {
'basic': self.basic_tokenize(text),
'nltk': self.nltk_word_tokenize(text),
'treebank': self.treebank_tokenize(text),
'tweet': self.tweet_tokenize(text),
'spacy': self.spacy_tokenize(text)
}
return results
# 使用示例
tokenizer = EnglishTokenizer()
test_text = "Natural Language Processing (NLP) is amazing! It helps computers understand human language. Can't wait to learn more! :)"
print("=== 英文分词比较 ===")
print(f"原始文本: {test_text}\n")
# 基础分词
basic_tokens = tokenizer.basic_tokenize(test_text)
print(f"基础分词: {basic_tokens}")
# NLTK分词
nltk_tokens = tokenizer.nltk_word_tokenize(test_text)
print(f"NLTK分词: {nltk_tokens}")
# Treebank分词
treebank_tokens = tokenizer.treebank_tokenize(test_text)
print(f"Treebank分词: {treebank_tokens}")
# Tweet分词（适用于社交媒体）
tweet_tokens = tokenizer.tweet_tokenize(test_text)
print(f"Tweet分词: {tweet_tokens}")
# spaCy分词
spacy_tokens = tokenizer.spacy_tokenize(test_text)
print(f"spaCy分词: {spacy_tokens}")
# spaCy详细分词信息
spacy_info = tokenizer.spacy_tokenize_with_info(test_text)
print(f"\n=== spaCy详细分词信息 ===")
for token, pos, lemma, is_stop in spacy_info[:10]: # 只显示前10个
print(f"词: {token:12} | 词性: {pos:6} | 词元: {lemma:8} | 停用词: {is_stop}")
---
b.中文分词技术
---
import jieba
import jieba.posseg as pseg
from typing import List, Tuple, Dict, Any
class ChineseTokenizer:
"""中文分词器"""
def __init__(self):
# 加载自定义词典（如果有）
self.custom_words = []
self.stop_words = set()
def add_custom_words(self, words: List[str]) -> None:
"""添加自定义词汇"""
for word in words:
jieba.add_word(word)
self.custom_words.append(word)
def set_dictionary(self, dict_path: str) -> None:
"""设置自定义词典路径"""
jieba.load_userdict(dict_path)
def精确模式(self, text: str) -> List[str]:
"""精确模式分词"""
return list(jieba.cut(text, cut_all=False))
def全模式(self, text: str) -> List[str]:
"""全模式分词"""
return list(jieba.cut(text, cut_all=True))
def搜索引擎模式(self, text: str) -> List[str]:
"""搜索引擎模式分词"""
return list(jieba.cut_for_search(text))
def paddle模式(self, text: str) -> List[str]:
"""Paddle模式分词（需要安装paddlepaddle）"""
try:
jieba.enable_paddle()
return list(jieba.cut(text, use_paddle=True))
except:
print("Paddle模式需要安装paddlepaddle: pip install paddlepaddle")
return self.精确模式(text)
def带词性分词(self, text: str) -> List[Tuple[str, str]]:
"""带词性标注的分词"""
words = pseg.cut(text)
return [(word, flag) for word, flag in words]
def并行分词(self, texts: List[str], processes: int = 4) -> List[List[str]]:
"""并行分词"""
jieba.enable_parallel(processes)
results = [list(jieba.cut(text)) for text in texts]
jieba.disable_parallel()
return results
def调整词频(self, word: str, freq: int) -> None:
"""调整词频，影响分词结果"""
jieba.suggest_freq(word, freq)
def获取词频(self, text: str) -> Dict[str, int]:
"""获取词频统计"""
words = self.精确模式(text)
return dict(Counter(words))
def分词统计(self, text: str) -> Dict[str, Any]:
"""获取分词统计信息"""
精确结果 = self.精确模式(text)
全模式结果 = self.全模式(text)
搜索结果 = self.搜索引擎模式(text)
return {
'原文长度': len(text),
'精确模式词数': len(精确结果),
'全模式词数': len(全模式结果),
'搜索引擎模式词数': len(搜索结果),
'精确模式结果': 精确结果,
'全模式结果': 全模式结果,
'搜索引擎模式结果': 搜索结果
}
def批量分词(self, texts: List[str], mode: str = '精确') -> List[List[str]]:
"""批量分词"""
mode_map = {
'精确': self.精确模式,
'全模式': self.全模式,
'搜索引擎': self.搜索引擎模式,
'paddle': self.paddle模式
}
tokenizer_func = mode_map.get(mode, self.精确模式)
return [tokenizer_func(text) for text in texts]
def比较分词模式(self, text: str) -> None:
"""比较不同分词模式的结果"""
print(f"原文: {text}")
print(f"精确模式: {' / '.join(self.精确模式(text))}")
print(f"全模式: {' / '.join(self.全模式(text))}")
print(f"搜索引擎模式: {' / '.join(self.搜索引擎模式(text))}")
# 带词性分词
words_with_pos = self.带词性分词(text)
print(f"带词性分词: {' / '.join([f'{word}({flag})' for word, flag in words_with_pos])}")
# 使用示例
tokenizer = ChineseTokenizer()
# 添加自定义词汇
tokenizer.add_custom_words(['自然语言处理', '深度学习', '机器学习'])
# 测试文本
test_text = "自然语言处理是人工智能的重要分支，它包括深度学习、机器学习等技术。"
print("=== 中文分词比较 ===")
tokenizer.比较分词模式(test_text)
# 获取分词统计
stats = tokenizer.分词统计(test_text)
print(f"\n=== 分词统计 ===")
for key, value in stats.items():
if key not in ['精确模式结果', '全模式结果', '搜索引擎模式结果']:
print(f"{key}: {value}")
# 批量分词
texts = [
"我爱自然语言处理技术",
"深度学习是机器学习的分支",
"中文分词是NLP的基础任务"
]
batch_results = tokenizer.批量分词(texts, mode='精确')
print(f"\n=== 批量分词结果 ===")
for i, result in enumerate(batch_results):
print(f"文本{i+1}: {' / '.join(result)}")
---
03.停用词处理
a.停用词理论
停用词是指在信息检索中通常被过滤掉的词，因为它们出现频率很高但信息量很低。常见的停用词包括"的"、"是"、"在"、"and"、"the"等。移除停用词可以减少噪声，提高模型效率，但在某些任务中保留停用词可能更重要。
b.停用词处理实现
---
from collections import Counter
from typing import Set, List, Dict, Optional
class StopwordsHandler:
"""停用词处理器"""
def __init__(self):
self.english_stopwords = self._load_english_stopwords()
self.chinese_stopwords = self._load_chinese_stopwords()
self.custom_stopwords = set()
def _load_english_stopwords(self) -> Set[str]:
"""加载英文停用词"""
return {
'i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', 'your', 'yours',
'he', 'him', 'his', 'himself', 'she', 'her', 'hers', 'herself', 'it', 'its', 'itself',
'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom',
'this', 'that', 'these', 'those', 'am', 'is', 'are', 'was', 'were', 'be', 'been',
'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'a', 'an',
'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at',
'by', 'for', 'with', 'through', 'during', 'before', 'after', 'above', 'below',
'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further',
'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any',
'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor',
'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can',
'will', 'just', 'don', 'should', 'now'
}
def _load_chinese_stopwords(self) -> Set[str]:
"""加载中文停用词"""
return {
# 助词
'的', '了', '着', '过', '啊', '吧', '呢', '吗', '哦', '呀', '啦', '嘛',
# 介词
'在', '从', '到', '于', '对', '向', '往', '沿', '按', '照', '根据',
# 连词
'和', '与', '及', '并', '而', '或', '但', '可是', '然而', '不过',
# 副词
'很', '太', '最', '更', '比较', '非常', '特别', '尤其', '格外',
'也', '还', '又', '再', '就', '才', '刚', '已经', '曾经', '马上',
# 代词
'我', '你', '他', '她', '它', '我们', '你们', '他们', '她们', '它们',
'这', '那', '这个', '那个', '这些', '那些', '这里', '那里',
# 动词
'是', '有', '在', '说', '进行', '发生', '存在', '出现', '达到', '实现',
# 数量词
'一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '百', '千', '万',
'个', '只', '条', '件', '种', '类', '次', '遍', '番', '些', '点',
# 其他常用词
'什么', '怎么', '为什么', '哪里', '哪个', '多少', '几个', '第一', '第二'
}
def add_custom_stopwords(self, words: List[str]) -> None:
"""添加自定义停用词"""
self.custom_stopwords.update([word.lower() for word in words])
def get_all_stopwords(self) -> Set[str]:
"""获取所有停用词"""
return self.english_stopwords.union(self.chinese_stopwords, self.custom_stopwords)
def remove_english_stopwords(self, tokens: List[str]) -> List[str]:
"""移除英文停用词"""
return [token for token in tokens if token.lower() not in self.english_stopwords]
def remove_chinese_stopwords(self, tokens: List[str]) -> List[str]:
"""移除中文停用词"""
return [token for token in tokens if token not in self.chinese_stopwords]
def remove_all_stopwords(self, tokens: List[str]) -> List[str]:
"""移除所有停用词"""
all_stopwords = self.get_all_stopwords()
return [token for token in tokens if token.lower() not in all_stopwords]
def detect_language(self, token: str) -> str:
"""检测词汇的语言类型"""
if any('\u4e00' <= char <= '\u9fff' for char in token):
return 'chinese'
elif token.isalpha():
return 'english'
else:
return 'other'
def remove_stopwords_by_language(self, tokens: List[str]) -> List[str]:
"""根据语言类型移除停用词"""
filtered_tokens = []
for token in tokens:
lang = self.detect_language(token)
if lang == 'chinese':
if token not in self.chinese_stopwords:
filtered_tokens.append(token)
elif lang == 'english':
if token.lower() not in self.english_stopwords:
filtered_tokens.append(token)
else:
# 其他语言的词汇保留
filtered_tokens.append(token)
return filtered_tokens
# 使用示例
stopword_handler = StopwordsHandler()
# 测试中英文混合文本
test_text = "我是一名自然语言处理工程师，我正在学习NLP技术。This is a very interesting and challenging job!"
tokens = re.findall(r'[\u4e00-\u9fff]+|[a-zA-Z]+', test_text) # 中文和英文分词
print("=== 停用词处理 ===")
print(f"原始分词: {tokens}")
# 移除停用词
filtered_tokens = stopword_handler.remove_stopwords_by_language(tokens)
print(f"移除停用词后: {filtered_tokens}")
# 添加自定义停用词
stopword_handler.add_custom_stopwords(['工程师', '技术', 'job'])
filtered_tokens_custom = stopword_handler.remove_stopwords_by_language(tokens)
print(f"添加自定义停用词后: {filtered_tokens_custom}")
---
04.词形还原与词干提取
a.理论基础
词干提取（Stemming）和词形还原（Lemmatization）都是将词汇还原为其基本形式的技术。词干提取是启发式的，可能产生不存在的词；词形还原是词汇学上的，确保结果是有效的词汇。
b.实现方法
---
from nltk.stem import PorterStemmer, SnowballStemmer
from nltk.stem import WordNetLemmatizer
class MorphologicalProcessor:
"""形态学处理器"""
def __init__(self):
self.porter_stemmer = PorterStemmer()
self.snowball_stemmer = SnowballStemmer('english')
self.wordnet_lemmatizer = WordNetLemmatizer()
def porter_stem(self, words: List[str]) -> List[str]:
"""Porter词干提取"""
return [self.porter_stemmer.stem(word) for word in words]
def snowball_stem(self, words: List[str]) -> List[str]:
"""Snowball词干提取"""
return [self.snowball_stemmer.stem(word) for word in words]
def wordnet_lemmatize(self, words: List[str]) -> List[str]:
"""WordNet词形还原"""
return [self.wordnet_lemmatizer.lemmatize(word) for word in words]
def compare_methods(self, words: List[str]) -> Dict[str, List[str]]:
"""比较不同方法的处理结果"""
return {
'original': words,
'porter_stem': self.porter_stem(words),
'snowball_stem': self.snowball_stem(words),
'wordnet_lemmatize': self.wordnet_lemmatize(words)
}
# 使用示例
morph_processor = MorphologicalProcessor()
test_words = [
'running', 'runs', 'ran', 'runner', 'easily', 'fairly',
'studies', 'studying', 'studied', 'organization', 'organizational'
]
results = morph_processor.compare_methods(test_words)
print("=== 词形处理比较 ===")
print(f"{'原词':<15} {'Porter':<15} {'Snowball':<15} {'Lemmatize':<15}")
print("-" * 65)
for word in test_words:
porter = results['porter_stem'][test_words.index(word)]
snowball = results['snowball_stem'][test_words.index(word)]
lemmatized = results['wordnet_lemmatize'][test_words.index(word)]
print(f"{word:<15} {porter:<15} {snowball:<15} {lemmatized:<15}")
---
05.文本预处理完整流水线
a.流水线设计
将上述所有预处理步骤整合为一个完整的流水线，支持灵活配置和批处理，提供端到端的文本预处理解决方案。
b.完整流水线实现
---
from enum import Enum
from dataclasses import dataclass
from typing import Optional, Dict, Any, List
class TextPreprocessingPipeline:
"""文本预处理流水线"""
def __init__(self, config: Optional[Dict[str, Any]] = None):
self.config = config or {}
self.cleaner = TextCleaner()
self.normalizer = TextNormalizer()
self.stopword_handler = StopwordsHandler()
self.morph_processor = MorphologicalProcessor()
def process_text(self, text: str) -> str | List[str]:
"""处理单个文本"""
if not isinstance(text, str):
text = str(text)
# 1. 文本清洗
text = self.cleaner.clean_text(text, **self.config.get('cleaning', {}))
# 2. 文本标准化
text = self.normalizer.normalize_text(text, self.config.get('normalization', {}))
# 3. 分词
language = self.config.get('language', 'auto')
if language == 'auto':
if any('\u4e00' <= char <= '\u9fff' for char in text):
# 中文文本
import jieba
tokens = list(jieba.cut(text))
else:
# 英文文本
tokens = re.findall(r'\b\w+\b', text.lower())
else:
# 指定语言
if language == 'chinese':
import jieba
tokens = list(jieba.cut(text))
else:
tokens = re.findall(r'\b\w+\b', text.lower())
# 4. 移除停用词
if self.config.get('remove_stopwords', True):
tokens = self.stopword_handler.remove_stopwords_by_language(tokens)
# 5. 词形处理
if self.config.get('morphological_processing', False):
if self.config.get('use_lemmatization', True):
tokens = self.morph_processor.wordnet_lemmatize(tokens)
else:
tokens = self.morph_processor.porter_stem(tokens)
# 6. 输出格式处理
if self.config.get('return_tokens', True):
return tokens
else:
return ' '.join(tokens)
def batch_process(self, texts: List[str]) -> List[str | List[str]]:
"""批量处理文本"""
return [self.process_text(text) for text in texts]
# 使用示例
# 配置
config = {
'cleaning': {
'remove_html': True,
'remove_urls': True,
'remove_special_chars': True
},
'normalization': {
'case_style': 'lower',
'expand_contractions': True
},
'language': 'auto',
'remove_stopwords': True,
'morphological_processing': True,
'use_lemmatization': True,
'return_tokens': True
}
# 创建流水线
pipeline = TextPreprocessingPipeline(config)
# 测试文本
test_texts = [
"<html>NLP processing is amazing! I love working with text data.</html>",
"自然语言处理是人工智能的重要分支，它帮助计算机理解人类语言。",
"Running, running, ran... The organization was studying organizational behavior."
]
# 处理文本
processed_texts = pipeline.batch_process(test_texts)
print("=== 文本预处理流水线结果 ===")
for i, (original, processed) in enumerate(zip(test_texts, processed_texts)):
print(f"\n文本{i+1}:")
print(f"原始: {original}")
print(f"处理后: {processed}")
---
2.2 分词技术
01.分词技术基础理论
a.分词的重要性
分词是自然语言处理的基础步骤，特别是对中文、日文、泰文等没有明显词分隔符的语言。分词质量直接影响后续任务的性能，包括机器翻译、情感分析、命名实体识别等。一个好的分词器需要考虑语法结构、语义信息、上下文关系等多重因素。
b.分词的基本概念
分词是指将连续的文本序列切分成有意义的词汇单元的过程。不同的语言有不同的分词挑战：英文主要基于空格和标点符号，而中文需要复杂的算法来识别词边界。分词结果的质量通常通过精确率、召回率和F1分数等指标来评估。
c.中文分词的特殊性
中文没有类似英文的空格分隔符，词与词之间没有明确的边界标记。这导致了分词的歧义性问题，同样的字符串可能有多种分词结果。例如"中国银行"可以分词为"中国/银行"，也可以分词为"中/国银行"。这种歧义性需要通过上下文信息和统计模型来解决。
02.基于规则的分词方法
a.正向最大匹配算法
正向最大匹配是从左到右，每次尝试匹配最长的可能词。这种方法的简单高效，但可能会忽略全局最优解。
---
class MaxMatchSegmenter:
"""正向最大匹配分词器"""
def __init__(self, dictionary: set, max_word_length: int = 10):
"""
初始化分词器
Args:
dictionary: 词典集合
max_word_length: 最大词长
"""
self.dictionary = set(word.strip() for word in dictionary)
self.max_word_length = max_word_length
self.segmentation_log = [] # 记录分词过程
def segment(self, text: str, return_details: bool = False) -> list:
"""
对文本进行正向最大匹配分词
Args:
text: 待分词文本
return_details: 是否返回详细分词过程
Returns:
分词结果列表
"""
if not text or not text.strip():
return [] if not return_details else []
text = text.strip()
words = []
position = 0
self.segmentation_log = []
while position < len(text):
# 尝试匹配从当前位置开始的最长词
matched = False
max_possible_length = min(self.max_word_length, len(text) - position)
# 从最长可能的长度开始尝试匹配
for length in range(max_possible_length, 0, -1):
candidate = text[position:position + length]
if candidate in self.dictionary:
words.append(candidate)
log_entry = {
'position': position,
'matched_word': candidate,
'length': length,
'action': 'matched'
}
self.segmentation_log.append(log_entry)
position += length
matched = True
break
# 如果没有匹配到任何词典词，则单字切分
if not matched:
single_char = text[position]
words.append(single_char)
log_entry = {
'position': position,
'matched_word': single_char,
'length': 1,
'action': 'single_char'
}
self.segmentation_log.append(log_entry)
position += 1
if return_details:
return words, self.segmentation_log
return words
def get_segmentation_stats(self, text: str) -> dict:
"""获取分词统计信息"""
words, log = self.segment(text, return_details=True)
matched_words = [entry['matched_word'] for entry in log if entry['action'] == 'matched']
single_chars = [entry['matched_word'] for entry in log if entry['action'] == 'single_char']
stats = {
'original_text': text,
'total_chars': len(text),
'total_words': len(words),
'matched_words_count': len(matched_words),
'single_char_count': len(single_chars),
'matched_words': matched_words,
'single_chars': single_chars,
'avg_word_length': sum(len(word) for word in words) / len(words) if words else 0,
'coverage_rate': len(matched_words) / len(words) if words else 0
}
return stats
def visualize_segmentation(self, text: str) -> str:
"""可视化分词结果"""
words = self.segment(text)
return ' / '.join(words)
# 使用示例
# 创建词典
dictionary = {
'自然语言处理', '自然', '语言', '处理', '是', '人工', '智能', '的',
'重要', '分支', '深度', '学习', '机器', '技术', '算法', '模型'
}
# 创建分词器
segmenter = MaxMatchSegmenter(dictionary, max_word_length=6)
# 测试文本
test_text = "自然语言处理是人工智能的重要分支"
# 进行分词
words = segmenter.segment(test_text)
print(f"原始文本: {test_text}")
print(f"分词结果: {words}")
print(f"可视化: {segmenter.visualize_segmentation(test_text)}")
# 获取详细统计
stats = segmenter.get_segmentation_stats(test_text)
print(f"\n=== 分词统计 ===")
print(f"总字符数: {stats['total_chars']}")
print(f"分词数量: {stats['total_words']}")
print(f"匹配词数量: {stats['matched_words_count']}")
print(f"单字数量: {stats['single_char_count']}")
print(f"平均词长: {stats['avg_word_length']:.2f}")
print(f"覆盖率: {stats['coverage_rate']:.2f}")
# 批量分词测试
test_sentences = [
"深度学习是机器学习的分支",
"自然语言处理包含很多算法",
"这个模型表现很好"
]
print(f"\n=== 批量分词结果 ===")
for i, sentence in enumerate(test_sentences):
words = segmenter.segment(sentence)
visualization = segmenter.visualize_segmentation(sentence)
print(f"{i+1}. {visualization}")
---
b.逆向最大匹配算法
逆向最大匹配从右向左进行分词，可以与正向最大匹配结合使用来提高分词质量。
---
class ReverseMaxMatchSegmenter:
"""逆向最大匹配分词器"""
def __init__(self, dictionary: set, max_word_length: int = 10):
"""
初始化逆向最大匹配分词器
Args:
dictionary: 词典集合
max_word_length: 最大词长
"""
self.dictionary = set(word.strip() for word in dictionary)
self.max_word_length = max_word_length
def segment(self, text: str) -> list:
"""
对文本进行逆向最大匹配分词
Args:
text: 待分词文本
Returns:
分词结果列表（从后向前分词）
"""
if not text or not text.strip():
return []
text = text.strip()
words = []
position = len(text)
while position > 0:
# 计算起始位置
start = max(0, position - self.max_word_length)
matched = False
# 从当前位置向左尝试匹配最长词
for length in range(position - start, 0, -1):
candidate = text[position - length:position]
if candidate in self.dictionary:
words.append(candidate)
position -= length
matched = True
break
# 如果没有匹配到任何词典词，则单字切分
if not matched:
single_char = text[position - 1:position]
words.append(single_char)
position -= 1
# 反转列表得到正确的顺序
return list(reversed(words))
def visualize_segmentation(self, text: str) -> str:
"""可视化分词结果"""
words = self.segment(text)
return ' / '.join(words)
# 使用示例
reverse_segmenter = ReverseMaxMatchSegmenter(dictionary, max_word_length=6)
# 测试逆向最大匹配
words_reverse = reverse_segmenter.segment(test_text)
print(f"\n=== 逆向最大匹配 ===")
print(f"原始文本: {test_text}")
print(f"分词结果: {words_reverse}")
print(f"可视化: {reverse_segmenter.visualize_segmentation(test_text)}")
# 比较正向和逆向最大匹配的结果
print(f"\n=== 正向 vs 逆向最大匹配对比 ===")
for sentence in test_sentences:
forward_result = segmenter.visualize_segmentation(sentence)
reverse_result = reverse_segmenter.visualize_segmentation(sentence)
print(f"原文: {sentence}")
print(f"正向: {forward_result}")
print(f"逆向: {reverse_result}")
print()
---
c.双向最大匹配算法
双向最大匹配结合正向和逆向匹配的结果，通过一定的策略选择最优的分词方案。
---
class BidirectionalMaxMatchSegmenter:
"""双向最大匹配分词器"""
def __init__(self, dictionary: set, max_word_length: int = 10):
"""
初始化双向最大匹配分词器
Args:
dictionary: 词典集合
max_word_length: 最大词长
"""
self.forward_segmenter = MaxMatchSegmenter(dictionary, max_word_length)
self.reverse_segmenter = ReverseMaxMatchSegmenter(dictionary, max_word_length)
def segment(self, text: str) -> list:
"""
对文本进行双向最大匹配分词
Args:
text: 待分词文本
Returns:
最优分词结果
"""
forward_result = self.forward_segmenter.segment(text)
reverse_result = self.reverse_segmenter.segment(text)
# 如果正向和逆向结果相同，直接返回
if forward_result == reverse_result:
return forward_result
# 否则选择分词数量较少的结果
if len(forward_result) <= len(reverse_result):
return forward_result
else:
return reverse_result
def detailed_comparison(self, text: str) -> dict:
"""
详细比较正向和逆向匹配结果
Args:
text: 待分词文本
Returns:
包含详细比较信息的字典
"""
forward_result = self.forward_segmenter.segment(text)
reverse_result = self.reverse_segmenter.segment(text)
bidirectional_result = self.segment(text)
return {
'text': text,
'forward': forward_result,
'reverse': reverse_result,
'bidirectional': bidirectional_result,
'forward_count': len(forward_result),
'reverse_count': len(reverse_result),
'bidirectional_count': len(bidirectional_result),
'same_result': forward_result == reverse_result,
'chosen_forward': len(forward_result) <= len(reverse_result)
}
# 使用示例
bidirectional_segmenter = BidirectionalMaxMatchSegmenter(dictionary, max_word_length=6)
# 测试双向最大匹配
print(f"\n=== 双向最大匹配 ===")
for sentence in test_sentences:
comparison = bidirectional_segmenter.detailed_comparison(sentence)
print(f"原文: {comparison['text']}")
print(f"正向: {' / '.join(comparison['forward'])} ({comparison['forward_count']}词)")
print(f"逆向: {' / '.join(comparison['reverse'])} ({comparison['reverse_count']}词)")
print(f"选择: {' / '.join(comparison['bidirectional'])} ({comparison['bidirectional_count']}词)")
print(f"策略: {'正向' if comparison['chosen_forward'] else '逆向'}")
print()
---
03.基于统计的分词方法
a.HMM（隐马尔可夫模型）分词
HMM将分词问题转化为序列标注问题，每个字符被标注为B（词首）、M（词中）、E（词尾）、S（单字词）四种状态之一。
---
import numpy as np
from collections import defaultdict
import math
class HMMSegmenter:
"""基于HMM的中文分词器"""
def __init__(self):
# 状态标签: B(词首), M(词中), E(词尾), S(单字词)
self.states = ['B', 'M', 'E', 'S']
self.state_to_idx = {state: idx for idx, state in enumerate(self.states)}
self.idx_to_state = {idx: state for state, idx in self.state_to_idx.items()}
# 初始化概率矩阵
self.initial_prob = np.array([0.6, 0.0, 0.0, 0.4]) # 初始状态概率
self.transition_prob = np.array([
[0.0, 0.7, 0.3, 0.0], # B -> [B,M,E,S]
[0.0, 0.7, 0.3, 0.0], # M -> [B,M,E,S]
[0.5, 0.0, 0.0, 0.5], # E -> [B,M,E,S]
[0.5, 0.0, 0.0, 0.5] # S -> [B,M,E,S]
])
self.emission_prob = {} # 观测概率: P(字符|状态)
def train(self, corpus: list):
"""
训练HMM模型
Args:
corpus: 训练语料，每个元素是分好词的句子列表
"""
print("开始训练HMM分词器...")
# 统计参数
state_count = defaultdict(int)
transition_count = defaultdict(lambda: defaultdict(int))
emission_count = defaultdict(lambda: defaultdict(int))
total_sentences = 0
for sentence in corpus:
if not sentence:
continue
total_sentences += 1
state_sequence = self._word_to_state_sequence(sentence)
chars = ''.join(sentence)
# 统计初始状态
if state_sequence:
initial_state = state_sequence[0]
state_count[initial_state] += 1
# 统计转移和发射概率
for i, (char, state) in enumerate(zip(chars, state_sequence)):
state_count[state] += 1
emission_count[state][char] += 1
if i < len(state_sequence) - 1:
next_state = state_sequence[i + 1]
transition_count[state][next_state] += 1
# 计算概率
num_states = len(self.states)
self.initial_prob = np.zeros(num_states)
self.transition_prob = np.zeros((num_states, num_states))
# 初始概率
for state in self.states:
self.initial_prob[self.state_to_idx[state]] = (
state_count[state] / total_sentences if total_sentences > 0 else 0
)
# 转移概率
for from_state in self.states:
from_idx = self.state_to_idx[from_state]
total_transitions = sum(transition_count[from_state].values())
if total_transitions > 0:
for to_state in self.states:
to_idx = self.state_to_idx[to_state]
self.transition_prob[from_idx][to_idx] = (
transition_count[from_state][to_state] / total_transitions
)
# 发射概率
for state in self.states:
state_idx = self.state_to_idx[state]
total_emissions = sum(emission_count[state].values())
if total_emissions > 0:
self.emission_prob[state] = {
char: count / total_emissions
for char, count in emission_count[state].items()
}
print(f"训练完成，使用了{total_sentences}个句子")
def _word_to_state_sequence(self, words: list) -> list:
"""将词序列转换为状态序列"""
state_sequence = []
for word in words:
if len(word) == 1:
state_sequence.append('S')
else:
state_sequence.extend(['B'] + ['M'] * (len(word) - 2) + ['E'])
return state_sequence
def _get_emission_prob(self, char: str, state_idx: int) -> float:
"""获取发射概率，未知字符使用平滑处理"""
state = self.idx_to_state[state_idx]
if state in self.emission_prob and char in self.emission_prob[state]:
return self.emission_prob[state][char]
else:
# 使用很小的概率处理未知字符
return 1e-10
def viterbi(self, text: str) -> list:
"""
使用Viterbi算法进行状态序列解码
Args:
text: 待分词文本
Returns:
最优状态序列
"""
if not text:
return []
n = len(text)
num_states = len(self.states)
# 初始化Viterbi矩阵和回溯指针
viterbi = np.zeros((num_states, n))
backpointers = np.zeros((num_states, n), dtype=int)
# 初始化第一步
for state_idx in range(num_states):
char = text[0]
viterbi[state_idx, 0] = (
np.log(self.initial_prob[state_idx] + 1e-10) +
np.log(self._get_emission_prob(char, state_idx))
)
# 递推计算
for t in range(1, n):
char = text[t]
for current_state in range(num_states):
max_prob = -np.inf
best_prev_state = 0
for prev_state in range(num_states):
prob = (
viterbi[prev_state, t - 1] +
np.log(self.transition_prob[prev_state, current_state] + 1e-10) +
np.log(self._get_emission_prob(char, current_state))
)
if prob > max_prob:
max_prob = prob
best_prev_state = prev_state
viterbi[current_state, t] = max_prob
backpointers[current_state, t] = best_prev_state
# 回溯找到最优路径
best_path = []
best_last_state = np.argmax(viterbi[:, -1])
for t in range(n - 1, -1, -1):
best_path.append(best_last_state)
if t > 0:
best_last_state = backpointers[best_last_state, t]
return list(reversed(best_path))
def segment(self, text: str) -> list:
"""
对文本进行分词
Args:
text: 待分词文本
Returns:
分词结果
"""
if not text:
return []
state_sequence = self.viterbi(text)
return self._state_to_words(text, state_sequence)
def _state_to_words(self, text: str, state_sequence: list) -> list:
"""将状态序列转换为词序列"""
words = []
current_word = ""
for char, state_idx in zip(text, state_sequence):
state = self.idx_to_state[state_idx]
if state in ['B', 'M']: # 词的开始或中间部分
current_word += char
elif state == 'E': # 词的结束
current_word += char
if current_word:
words.append(current_word)
current_word = ""
else: # S 单字词
if current_word:
words.append(current_word)
words.append(char)
current_word = ""
# 处理最后一个词
if current_word:
words.append(current_word)
return words
def visualize_segmentation(self, text: str) -> str:
"""可视化分词结果"""
words = self.segment(text)
return ' / '.join(words)
# 使用示例
print("=== HMM分词器演示 ===")
# 创建训练语料
training_corpus = [
['自然', '语言', '处理', '是', '人工', '智能', '的', '重要', '分支'],
['深度', '学习', '是', '机器', '学习', '的', '子', '领域'],
['这个', '模型', '在', '测试', '中', '表现', '很', '好'],
['我们', '需要', '更多', '的', '训练', '数据'],
['中文', '分词', '技术', '已经', '发展', '了', '很', '多', '年']
]
# 训练HMM分词器
hmm_segmenter = HMMSegmenter()
hmm_segmenter.train(training_corpus)
# 测试文本
test_texts = [
"自然语言处理技术很重要",
"深度学习模型表现很好",
"我们需要更多的中文数据",
"这个分词器效果不错"
]
print("\n=== HMM分词结果 ===")
for text in test_texts:
result = hmm_segmenter.visualize_segmentation(text)
print(f"原文: {text}")
print(f"分词: {result}")
print()
---
b.CRF（条件随机场）分词
CRF考虑了整个序列的全局最优性，比HMM有更好的性能。
---
try:
from sklearn_crfsuite import CRF
class CRFSegmenter:
"""基于CRF的中文分词器"""
def __init__(self):
self.model = CRF(
algorithm='lbfgs',
c1=0.1,
c2=0.1,
max_iterations=100,
all_possible_transitions=True
)
def _extract_features(self, sentence: str, i: int) -> dict:
"""提取字符特征"""
char = sentence[i]
features = {
'char': char,
'is_digit': char.isdigit(),
'is_alpha': char.isalpha(),
'is_upper': char.isupper(),
'is_lower': char.islower(),
'is_punctuation': char in '，。！？；：""''（）【】《》',
}
# 前一个字符的特征
if i > 0:
prev_char = sentence[i-1]
features.update({
'prev_char': prev_char,
'prev_is_digit': prev_char.isdigit(),
'prev_is_alpha': prev_char.isalpha(),
'prev_is_punctuation': prev_char in '，。！？；：""''（）【】《》',
})
else:
features['BOS'] = True # 句子开始
# 后一个字符的特征
if i < len(sentence) - 1:
next_char = sentence[i+1]
features.update({
'next_char': next_char,
'next_is_digit': next_char.isdigit(),
'next_is_alpha': next_char.isalpha(),
'next_is_punctuation': next_char in '，。！？；：""''（）【】《》',
})
else:
features['EOS'] = True # 句子结束
# 当前字符位置特征
features['position'] = i
features['relative_position'] = i / len(sentence) if len(sentence) > 0 else 0
# 字符的Unicode特征
features['unicode_category'] = char.encode('utf-8')[0] if char else 0
return features
def _sentence_to_features(self, sentence: str) -> list:
"""将句子转换为特征序列"""
return [self._extract_features(sentence, i) for i in range(len(sentence))]
def _word_to_labels(self, words: list) -> list:
"""将词序列转换为标签序列"""
labels = []
for word in words:
if len(word) == 1:
labels.append('S') # 单字词
else:
labels.extend(['B'] + ['M'] * (len(word) - 2) + ['E'])
return labels
def _labels_to_words(self, sentence: str, labels: list) -> list:
"""将标签序列转换为词序列"""
words = []
current_word = ""
for char, label in zip(sentence, labels):
if label in ['B', 'M']:
current_word += char
elif label == 'E':
current_word += char
words.append(current_word)
current_word = ""
else: # 'S'
if current_word:
words.append(current_word)
current_word = ""
words.append(char)
if current_word:
words.append(current_word)
return words
def train(self, training_corpus: list):
"""
训练CRF分词器
Args:
training_corpus: 训练语料，每个元素是分好词的句子列表
"""
print("开始训练CRF分词器...")
X_train = []
y_train = []
for words in training_corpus:
sentence = ''.join(words)
features = self._sentence_to_features(sentence)
labels = self._word_to_labels(words)
X_train.append(features)
y_train.append(labels)
# 训练模型
self.model.fit(X_train, y_train)
print("CRF分词器训练完成")
def segment(self, text: str) -> list:
"""
对文本进行分词
Args:
text: 待分词文本
Returns:
分词结果
"""
if not text:
return []
features = self._sentence_to_features(text)
labels = self.model.predict([features])[0]
return self._labels_to_words(text, labels)
def visualize_segmentation(self, text: str) -> str:
"""可视化分词结果"""
words = self.segment(text)
return ' / '.join(words)
def get_label_probabilities(self, text: str) -> dict:
"""获取标签概率分布"""
features = self._sentence_to_features(text)
marginals = self.model.predict_marginals([features])[0]
result = {}
for i, (char, char_marginals) in enumerate(zip(text, marginals)):
char_probs = {label: prob for label, prob in char_marginals}
result[f'{i}:{char}'] = char_probs
return result
# 使用示例
print("=== CRF分词器演示 ===")
# 创建训练语料
crf_training_corpus = [
['自然', '语言', '处理', '是', '人工', '智能', '的', '重要', '分支'],
['深度', '学习', '是', '机器', '学习', '的', '核心', '技术'],
['这个', '模型', '在', '实际', '应用', '中', '表现', '很', '好'],
['我们', '需要', '收集', '更多', '的', '中文', '数据'],
['现代', '中文', '分词', '技术', '已经', '相当', '成熟']
]
# 训练CRF分词器
crf_segmenter = CRFSegmenter()
crf_segmenter.train(crf_training_corpus)
# 测试文本
crf_test_texts = [
"自然语言处理技术",
"深度学习算法很好",
"这个模型表现很棒",
"我们需要中文数据"
]
print("\n=== CRF分词结果 ===")
for text in crf_test_texts:
result = crf_segmenter.visualize_segmentation(text)
print(f"原文: {text}")
print(f"分词: {result}")
print()
except ImportError:
print("CRF分词器需要安装sklearn-crfsuite: pip install sklearn-crfsuite")
# 简化的CRF模拟实现
class SimpleCRFSegmenter:
"""简化的CRF模拟分词器"""
def __init__(self):
# 简化的规则分词
self.dictionary = {
'自然', '语言', '处理', '是', '人工', '智能', '的', '重要', '分支',
'深度', '学习', '机器', '核心', '技术', '这个', '模型', '实际',
'应用', '中', '表现', '很', '好', '我们', '需要', '收集', '更多',
'中文', '数据', '现代', '已经', '相当', '成熟'
}
def segment(self, text: str) -> list:
"""简化的分词实现"""
words = []
i = 0
n = len(text)
while i < n:
# 尝试匹配词典中最长的词
matched = False
for length in range(min(6, n - i), 0, -1):
candidate = text[i:i+length]
if candidate in self.dictionary:
words.append(candidate)
i += length
matched = True
break
if not matched:
words.append(text[i])
i += 1
return words
def visualize_segmentation(self, text: str) -> str:
"""可视化分词结果"""
words = self.segment(text)
return ' / '.join(words)
# 使用简化版本
simple_crf = SimpleCRFSegmenter()
print("\n=== 简化CRF分词器演示 ===")
for text in crf_test_texts:
result = simple_crf.visualize_segmentation(text)
print(f"原文: {text}")
print(f"分词: {result}")
print()
---
04.基于深度学习的分词方法
a.BiLSTM-CRF分词模型
BiLSTM-CRF结合了双向LSTM的序列建模能力和CRF的全局优化特性，是目前主流的分词方法之一。
---
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np
from collections import Counter
import random
class BiLSTMCRFSegmenter:
"""基于BiLSTM-CRF的中文分词器"""
def __init__(self, vocab_size: int, tagset_size: int, embedding_dim: int = 100,
hidden_dim: int = 128, num_layers: int = 1, dropout: float = 0.3):
"""
初始化BiLSTM-CRF分词器
Args:
vocab_size: 词汇表大小
tagset_size: 标签集大小 (B, M, E, S)
embedding_dim: 词嵌入维度
hidden_dim: LSTM隐藏层维度
num_layers: LSTM层数
dropout: Dropout比率
"""
self.vocab_size = vocab_size
self.tagset_size = tagset_size
self.embedding_dim = embedding_dim
self.hidden_dim = hidden_dim
# 字符嵌入层
self.char_embeddings = nn.Embedding(vocab_size, embedding_dim)
# BiLSTM层
self.lstm = nn.LSTM(
input_size=embedding_dim,
hidden_size=hidden_dim // 2, # 双向LSTM，每个方向 hidden_dim//2
num_layers=num_layers,
bidirectional=True,
batch_first=True,
dropout=dropout if num_layers > 1 else 0
)
# 线性层
self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
# CRF层
self.crf = CRF(tagset_size)
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.to(self.device)
def forward(self, char_ids: torch.Tensor, mask: torch.Tensor = None):
"""
前向传播
Args:
char_ids: 字符ID张量 [batch_size, seq_len]
mask: 掩码张量 [batch_size, seq_len]
Returns:
CRF层的输出
"""
# 字符嵌入 [batch_size, seq_len, embedding_dim]
char_embeds = self.char_embeddings(char_ids)
# BiLSTM [batch_size, seq_len, hidden_dim]
lstm_out, _ = self.lstm(char_embeds)
# 线性变换 [batch_size, seq_len, tagset_size]
tag_scores = self.hidden2tag(lstm_out)
return tag_scores
def loss_fn(self, char_ids: torch.Tensor, tag_ids: torch.Tensor,
mask: torch.Tensor = None) -> torch.Tensor:
"""计算损失函数"""
emissions = self.forward(char_ids, mask)
return -self.crf(emissions, tag_ids, mask=mask, reduction='mean')
def predict(self, char_ids: torch.Tensor, mask: torch.Tensor = None) -> list:
"""预测标签序列"""
emissions = self.forward(char_ids, mask)
return self.crf.decode(emissions, mask=mask)
class CRF(nn.Module):
"""简化的CRF层实现"""
def __init__(self, num_tags: int):
super(CRF, self).__init__()
self.num_tags = num_tags
self.transitions = nn.Parameter(torch.randn(num_tags, num_tags))
# 约束：不可能从其他状态转移到B状态
self.transitions.data[:, 0] -= 10000
# 约束：不可能从B或M状态转移到S状态
self.transitions.data[0:2, 3] -= 10000
def forward(self, emissions: torch.Tensor, tags: torch.Tensor,
mask: torch.Tensor = None, reduction: str = 'sum') -> torch.Tensor:
"""计算CRF损失"""
if mask is None:
mask = torch.ones_like(tags, dtype=torch.uint8)
numerator = self._compute_score(emissions, tags, mask)
denominator = self._compute_normalizer(emissions, mask)
llh = denominator - numerator
if reduction == 'sum':
return llh.sum()
elif reduction == 'mean':
return llh.sum() / mask.float().sum()
else:
return llh
def _compute_score(self, emissions: torch.Tensor, tags: torch.Tensor,
mask: torch.Tensor) -> torch.Tensor:
"""计算路径得分"""
batch_size, seq_len = tags.size()
score = torch.zeros(batch_size).to(emissions.device)
# 转移分数
score += self.transitions[tags[:, 0], 0] # 从开始状态到第一个标签
for i in range(seq_len - 1):
score += self.transitions[tags[:, i + 1], tags[:, i]]
# 发射分数
score += emissions.gather(2, tags.unsqueeze(2)).squeeze(2).sum(1)
return score
def _compute_normalizer(self, emissions: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
"""计算归一化因子"""
batch_size, seq_len, num_tags = emissions.size()
# 初始化前向变量
alpha = self.transitions[:, 0].unsqueeze(0) + emissions[:, 0]
alpha = alpha.transpose(0, 1) # [num_tags, batch_size]
for i in range(1, seq_len):
# 广播转移分数
emit_score = emissions[:, i].unsqueeze(1) # [batch_size, 1, num_tags]
trans_score = self.transitions.unsqueeze(0) # [1, num_tags, num_tags]
# 计算下一步的得分
next_alpha = alpha.unsqueeze(2) + trans_score + emit_score
next_alpha = torch.logsumexp(next_alpha, dim=1).transpose(0, 1)
# 应用mask
mask_i = mask[:, i].unsqueeze(1).float()
alpha = next_alpha * mask_i + alpha * (1 - mask_i)
return torch.logsumexp(alpha, dim=0)
def decode(self, emissions: torch.Tensor, mask: torch.Tensor = None) -> list:
"""使用维特比算法解码最优路径"""
if mask is None:
mask = torch.ones(emissions.size()[:2], dtype=torch.uint8).to(emissions.device)
batch_size, seq_len, num_tags = emissions.size()
paths = []
for i in range(batch_size):
seq_emissions = emissions[i, :mask[i].sum()]
path = self._viterbi_decode(seq_emissions)
paths.append(path)
return paths
def _viterbi_decode(self, emissions: torch.Tensor) -> list:
"""维特比解码"""
seq_len, num_tags = emissions.size()
# 初始化
viterbi = self.transitions[:, 0] + emissions[0]
backpointers = []
for i in range(1, seq_len):
# 计算转移分数
viterbi_t = viterbi.unsqueeze(1) + self.transitions.unsqueeze(0) + emissions[i].unsqueeze(0)
best_tags = torch.argmax(viterbi_t, dim=2)
viterbi = torch.max(viterbi_t, dim=2)[0]
backpointers.append(best_tags)
# 回溯
best_path = [torch.argmax(viterbi).item()]
for bp in reversed(backpointers):
best_path.append(bp[best_path[-1]].item())
return list(reversed(best_path))
# 使用示例
print("=== BiLSTM-CRF分词器演示 ===")
# 准备数据
def prepare_data(corpus):
"""准备训练数据"""
# 构建字符到ID的映射
all_chars = set(''.join([''.join(words) for words in corpus]))
char_to_id = {char: idx + 2 for idx, char in enumerate(all_chars)} # 0: PAD, 1: UNK
char_to_id['<PAD>'] = 0
char_to_id['<UNK>'] = 1
# 标签映射
tag_to_id = {'B': 0, 'M': 1, 'E': 2, 'S': 3}
id_to_tag = {v: k for k, v in tag_to_id.items()}
# 准备训练样本
training_data = []
for words in corpus:
sentence = ''.join(words)
char_ids = []
tag_ids = []
mask = []
for word in words:
if len(word) == 1:
char_ids.append(char_to_id.get(word, 1))
tag_ids.append(tag_to_id['S'])
else:
char_ids.extend([char_to_id.get(c, 1) for c in word])
tag_ids.extend([tag_to_id['B']] + [tag_to_id['M']] * (len(word) - 2) + [tag_to_id['E']])
mask = [1] * len(char_ids)
training_data.append({
'char_ids': char_ids,
'tag_ids': tag_ids,
'mask': mask,
'sentence': sentence
})
return training_data, char_to_id, tag_to_id, id_to_tag
# 训练语料
bilstm_corpus = [
['自然', '语言', '处理', '是', '人工', '智能', '的', '重要', '分支'],
['深度', '学习', '是', '机器', '学习', '的', '核心', '技术'],
['这个', '模型', '在', '实际', '应用', '中', '表现', '很', '好'],
['我们', '需要', '收集', '更多', '的', '中文', '数据'],
['现代', '中文', '分词', '技术', '已经', '相当', '成熟']
]
# 准备数据
training_data, char_to_id, tag_to_id, id_to_tag = prepare_data(bilstm_corpus)
# 创建模型
model = BiLSTMCRFSegmenter(
vocab_size=len(char_to_id),
tagset_size=len(tag_to_id),
embedding_dim=50,
hidden_dim=64
)
# 训练循环
print("开始训练BiLSTM-CRF模型...")
optimizer = optim.Adam(model.parameters(), lr=0.01)
num_epochs = 50
for epoch in range(num_epochs):
total_loss = 0
model.train()
for sample in training_data:
optimizer.zero_grad()
# 准备批次数据
char_ids = torch.tensor([sample['char_ids']], dtype=torch.long).to(model.device)
tag_ids = torch.tensor([sample['tag_ids']], dtype=torch.long).to(model.device)
mask = torch.tensor([sample['mask']], dtype=torch.uint8).to(model.device)
# 前向传播和损失计算
loss = model.loss_fn(char_ids, tag_ids, mask)
# 反向传播
loss.backward()
optimizer.step()
total_loss += loss.item()
if (epoch + 1) % 10 == 0:
print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {total_loss / len(training_data):.4f}')
# 测试模型
print("\n=== BiLSTM-CRF分词结果 ===")
model.eval()
def segment_text(text, model, char_to_id, id_to_tag):
"""使用训练好的模型进行分词"""
# 准备输入
char_ids = [char_to_id.get(char, 1) for char in text]
char_ids_tensor = torch.tensor([char_ids], dtype=torch.long).to(model.device)
mask = torch.tensor([[1] * len(char_ids)], dtype=torch.uint8).to(model.device)
# 预测
with torch.no_grad():
predicted_tags = model.predict(char_ids_tensor, mask)[0]
# 转换为词
words = []
current_word = ""
for char, tag_idx in zip(text, predicted_tags):
tag = id_to_tag[tag_idx]
if tag in ['B', 'M']:
current_word += char
elif tag == 'E':
current_word += char
words.append(current_word)
current_word = ""
else: # 'S'
if current_word:
words.append(current_word)
current_word = ""
words.append(char)
if current_word:
words.append(current_word)
return words
# 测试文本
test_texts = [
"自然语言处理技术",
"深度学习算法很好",
"这个模型表现很棒"
]
for text in test_texts:
try:
segmented = segment_text(text, model, char_to_id, id_to_tag)
result = ' / '.join(segmented)
print(f"原文: {text}")
print(f"分词: {result}")
except Exception as e:
print(f"分词出错: {e}")
# 使用简单的字符级分词作为后备
result = ' / '.join(text)
print(f"原文: {text}")
print(f分词: {result}")
print()
---
05.分词性能评估与比较
a.评估指标
分词性能通常使用精确率（Precision）、召回率（Recall）和F1分数来评估。精确率衡量分词结果的准确性，召回率衡量分词结果的完整性，F1分数是两者的调和平均。
b.性能评估代码
---
from collections import defaultdict
import numpy as np
from typing import List, Tuple, Dict
class SegmentationEvaluator:
"""分词性能评估器"""
def __init__(self):
self.reset()
def reset(self):
"""重置评估指标"""
self.true_positive = 0
self.false_positive = 0
self.false_negative = 0
self.total_words = 0
self.predicted_words = 0
self.details = []
def _word_to_boundaries(self, sentence: str, words: List[str]) -> set:
"""将词列表转换为边界位置集合"""
boundaries = set()
pos = 0
for word in words:
boundaries.add(pos)
pos += len(word)
return boundaries
def evaluate_sentence(self, text: str, true_words: List[str], pred_words: List[str]) -> Dict:
"""评估单个句子的分词性能"""
true_boundaries = self._word_to_boundaries(text, true_words)
pred_boundaries = self._word_to_boundaries(text, pred_words)
# 计算TP, FP, FN
tp = len(true_boundaries & pred_boundaries)
fp = len(pred_boundaries - true_boundaries)
fn = len(true_boundaries - pred_boundaries)
# 更新全局统计
self.true_positive += tp
self.false_positive += fp
self.false_negative += fn
self.total_words += len(true_words)
self.predicted_words += len(pred_words)
# 计算当前句子的指标
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
sentence_result = {
'text': text,
'true_words': true_words,
'pred_words': pred_words,
'true_boundaries': true_boundaries,
'pred_boundaries': pred_boundaries,
'tp': tp,
'fp': fp,
'fn': fn,
'precision': precision,
'recall': recall,
'f1': f1
}
self.details.append(sentence_result)
return sentence_result
def get_overall_metrics(self) -> Dict:
"""获取总体评估指标"""
precision = self.true_positive / (self.true_positive + self.false_positive) if (self.true_positive + self.false_positive) > 0 else 0
recall = self.true_positive / (self.true_positive + self.false_negative) if (self.true_positive + self.false_negative) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return {
'total_sentences': len(self.details),
'total_words': self.total_words,
'predicted_words': self.predicted_words,
'true_positive': self.true_positive,
'false_positive': self.false_positive,
'false_negative': self.false_negative,
'precision': precision,
'recall': recall,
'f1': f1,
'error_rate': 1 - f1
}
def print_detailed_report(self):
"""打印详细的评估报告"""
metrics = self.get_overall_metrics()
print("=== 分词性能评估报告 ===")
print(f"评估句子数量: {metrics['total_sentences']}")
print(f"真实词数: {metrics['total_words']}")
print(f"预测词数: {metrics['predicted_words']}")
print()
print("总体指标:")
print(f" 精确率 (Precision): {metrics['precision']:.4f}")
print(f" 召回率 (Recall): {metrics['recall']:.4f}")
print(f" F1分数: {metrics['f1']:.4f}")
print(f" 错误率: {metrics['error_rate']:.4f}")
print()
# 显示错误案例
print("=== 错误案例 ===")
for i, detail in enumerate(self.details[:5]): # 显示前5个错误案例
if detail['fp'] > 0 or detail['fn'] > 0:
print(f"案例 {i+1}:")
print(f" 文本: {detail['text']}")
print(f" 真实: {' / '.join(detail['true_words'])}")
print(f" 预测: {' / '.join(detail['pred_words'])}")
print(f" 精确率: {detail['precision']:.4f}")
print(f" 召回率: {detail['recall']:.4f}")
print(f" F1分数: {detail['f1']:.4f}")
print()
def compare_segmenters(self, test_data: List[Tuple[str, List[str]], Dict[str, List[str]]]) -> Dict:
"""
比较多个分词器的性能
Args:
test_data: 测试数据，格式为 [(文本, 真实分词, {分词器名: 预测分词})]
Returns:
比较结果
"""
segmenter_names = list(test_data[0][2].keys())
segmenter_metrics = {name: SegmentationEvaluator() for name in segmenter_names}
for text, true_words, pred_results in test_data:
for name, pred_words in pred_results.items():
segmenter_metrics[name].evaluate_sentence(text, true_words, pred_words)
# 收集结果
comparison_results = {}
for name, evaluator in segmenter_metrics.items():
comparison_results[name] = evaluator.get_overall_metrics()
# 打印比较结果
print("=== 分词器性能比较 ===")
print(f"{'分词器':<15} {'精确率':<8} {'召回率':<8} {'F1分数':<8} {'错误率':<8}")
print("-" * 55)
for name, metrics in comparison_results.items():
print(f"{name:<15} {metrics['precision']:<8.4f} {metrics['recall']:<8.4f} "
f"{metrics['f1']:<8.4f} {metrics['error_rate']:<8.4f}")
return comparison_results
# 使用示例
print("=== 分词性能评估演示 ===")
# 创建评估器
evaluator = SegmentationEvaluator()
# 测试数据 (文本, 真实分词, 多个分词器的结果)
test_data = [
("自然语言处理是人工智能的重要分支",
["自然", "语言", "处理", "是", "人工", "智能", "的", "重要", "分支"],
{
"正向最大匹配": ["自然", "语言", "处理", "是", "人工", "智能", "的", "重要", "分支"],
"逆向最大匹配": ["自然", "语言", "处理", "是", "人工", "智能", "的", "重要", "分支"],
"简化分词器": ["自然", "语言", "处理", "是", "人工", "智能", "的", "重要", "分支"]
}),
("深度学习模型表现很好",
["深度", "学习", "模型", "表现", "很", "好"],
{
"正向最大匹配": ["深度", "学习", "模型", "表现", "很", "好"],
"逆向最大匹配": ["深度", "学习", "模型", "表现", "很", "好"],
"简化分词器": ["深度", "学习", "模型", "表", "现", "很", "好"]
}),
("我们需要更多的中文数据",
["我们", "需要", "更多", "的", "中文", "数据"],
{
"正向最大匹配": ["我们", "需要", "更多", "的", "中文", "数据"],
"逆向最大匹配": ["我们", "需要", "更多", "的", "中文", "数据"],
"简化分词器": ["我们", "需要", "更", "多", "的", "中文", "数据"]
})
]
# 比较不同分词器
comparison = evaluator.compare_segmenters(test_data)
---
c.性能优化策略
提高分词性能的方法包括增加词典覆盖率、使用机器学习模型、结合多种分词策略等。实际应用中通常采用多种方法的组合来达到最佳效果。
---
class OptimizedSegmenter:
"""优化的分词器，结合多种策略"""
def __init__(self, dictionary_path: str = None):
"""
初始化优化分词器
Args:
dictionary_path: 词典文件路径
"""
self.load_dictionary(dictionary_path)
self.setup_models()
def load_dictionary(self, dictionary_path: str):
"""加载词典"""
if dictionary_path and os.path.exists(dictionary_path):
with open(dictionary_path, 'r', encoding='utf-8') as f:
self.dictionary = set(line.strip() for line in f)
else:
# 默认词典
self.dictionary = {
'自然', '语言', '处理', '是', '人工', '智能', '的', '重要', '分支',
'深度', '学习', '机器', '模型', '算法', '数据', '技术', '方法',
'我们', '需要', '更多', '很好', '表现', '实际', '应用', '中文'
}
def setup_models(self):
"""设置不同的分词模型"""
self.forward_segmenter = MaxMatchSegmenter(self.dictionary)
self.reverse_segmenter = ReverseMaxMatchSegmenter(self.dictionary)
self.bidirectional_segmenter = BidirectionalMaxMatchSegmenter(self.dictionary)
def ensemble_segment(self, text: str, weights: dict = None) -> list:
"""
集成多个分词器的结果
Args:
text: 待分词文本
weights: 不同分词器的权重
Returns:
集成分词结果
"""
if weights is None:
weights = {
'forward': 0.3,
'reverse': 0.3,
'bidirectional': 0.4
}
# 获取各分词器结果
forward_result = self.forward_segmenter.segment(text)
reverse_result = self.reverse_segmenter.segment(text)
bidirectional_result = self.bidirectional_segmenter.segment(text)
# 简单的集成策略：选择出现频率最高的分词方案
results = [forward_result, reverse_result, bidirectional_result]
result_counts = defaultdict(int)
for result in results:
result_key = '/'.join(result)
result_counts[result_key] += 1
# 选择出现次数最多的结果
if result_counts:
best_result_key = max(result_counts, key=result_counts.get)
return best_result_key.split('/')
else:
return forward_result
def segment_with_confidence(self, text: str) -> tuple:
"""
带置信度的分词
Args:
text: 待分词文本
Returns:
(分词结果, 置信度)
"""
# 使用双向分词作为主要方法
forward_result = self.forward_segmenter.segment(text)
reverse_result = self.reverse_segmenter.segment(text)
# 计算一致性
consistency = len(set(forward_result) & set(reverse_result)) / max(len(forward_result), len(reverse_result))
# 使用bidirectional作为最终结果
final_result = self.bidirectional_segmenter.segment(text)
return final_result, consistency
def adaptive_segment(self, text: str) -> list:
"""
自适应分词，根据文本特征选择最佳策略
Args:
text: 待分词文本
Returns:
自适应分词结果
"""
# 分析文本特征
text_length = len(text)
digit_ratio = sum(c.isdigit() for c in text) / text_length
alpha_ratio = sum(c.isalpha() for c in text) / text_length
# 根据特征选择策略
if digit_ratio > 0.3: # 数字较多
return self.forward_segmenter.segment(text)
elif alpha_ratio > 0.8: # 字母较多
return self.forward_segmenter.segment(text)
elif text_length < 10: # 短文本
return self.bidirectional_segmenter.segment(text)
else: # 长文本
return self.ensemble_segment(text)
def benchmark(self, test_data: list) -> dict:
"""
对分词器进行基准测试
Args:
test_data: 测试数据 [(文本, 真实分词), ...]
Returns:
基准测试结果
"""
methods = {
'forward': self.forward_segmenter.segment,
'reverse': self.reverse_segmenter.segment,
'bidirectional': self.bidirectional_segmenter.segment,
'ensemble': lambda x: self.ensemble_segment(x),
'adaptive': lambda x: self.adaptive_segment(x)
}
results = {}
for method_name, method_func in methods.items():
evaluator = SegmentationEvaluator()
for text, true_words in test_data:
pred_words = method_func(text)
evaluator.evaluate_sentence(text, true_words, pred_words)
results[method_name] = evaluator.get_overall_metrics()
# 找出最佳方法
best_method = max(results, key=lambda x: results[x]['f1'])
return {
'results': results,
'best_method': best_method,
'best_score': results[best_method]['f1']
}
# 使用示例
print("=== 优化分词器演示 ===")
# 创建优化分词器
optimizer = OptimizedSegmenter()
# 测试数据
benchmark_data = [
("自然语言处理技术", ["自然", "语言", "处理", "技术"]),
("深度学习模型表现很好", ["深度", "学习", "模型", "表现", "很", "好"]),
("我们需要更多的中文数据", ["我们", "需要", "更多", "的", "中文", "数据"])
]
# 基准测试
benchmark_results = optimizer.benchmark(benchmark_data)
print("基准测试结果:")
for method, metrics in benchmark_results['results'].items():
print(f"{method:<12} F1: {metrics['f1']:.4f}")
print(f"\n最佳方法: {benchmark_results['best_method']}")
print(f"最佳得分: {benchmark_results['best_score']:.4f}")
# 演示自适应分词
print("\n=== 自适应分词演示 ===")
test_texts = [
"短文本",
"这是一个很长的中文文本，包含了多种不同的词汇类型和语言特征",
"123456789数字内容",
"EnglishTextAnd中文混合"
]
for text in test_texts:
result = optimizer.adaptive_segment(text)
confidence = 0.0 # 简化处理
print(f"原文: {text}")
print(f"分词: {' / '.join(result)}")
print()
---
2.3 词向量
01.词向量基础理论
a.词向量的定义与意义
词向量是将词汇映射到低维、稠密的向量空间中的技术。这种表示方式使得具有相似语义的词在向量空间中距离更近，从而能够捕捉词汇之间的语义关系。相比传统的独热编码，词向量能够有效解决维度灾难问题，并且能够编码丰富的语义信息。
b.分布式假说
分布式假说是词向量的理论基础，该假说认为一个词的含义可以通过其上下文词汇来表示。具体来说，出现在相似上下文中的词具有相似的语义表示。这一假说为现代词向量算法如Word2Vec、GloVe等提供了理论基础。
c.词向量的优势
a.语义相似性度量
可以通过计算向量间的余弦相似度来衡量词义的相似程度
b.维度压缩
将高维稀疏的词汇表示转换为低维稠密的向量表示
c.关系推理
支持词类比运算，如king - man + woman = queen
d.预训练表示
可以预训练获得通用语言表示，迁移到下游任务
d.词向量的应用领域
文本分类、情感分析、机器翻译、问答系统、文本摘要、命名实体识别、关系抽取等NLP任务都广泛使用词向量作为特征表示。
02.词向量表示方法分类
a.基于统计的表示方法
a.功能说明
这些方法主要基于大规模语料的统计信息来学习词向量，不需要人工标注。
b.代码示例
---
class StatisticalEmbeddingMethods:
"""基于统计的词向量方法概述"""
def __init__(self):
self.methods = {
'count_based': '基于词频的方法',
'cooccurrence_based': '基于共现的方法',
'pca_reduction': 'PCA降维方法',
'svd_reduction': 'SVD降维方法'
}
def describe_method(self, method_name: str) -> str:
"""描述指定的统计方法"""
descriptions = {
'count_based': """
基于词频的方法利用词汇在语料中的出现频率信息。
常见的实现包括TF-IDF加权、PMI（点互信息）等。
虽然简单，但无法捕捉深层语义关系。
""",
'cooccurrence_based': """
基于共现的方法通过统计词汇在窗口内共同出现的频率来构建关系。
共现矩阵通常很大且稀疏，需要降维处理。
能够捕捉词汇间的统计关联性。
""",
'pca_reduction': """
主成分分析（PCA）是一种无监督降维技术，通过线性变换将高维数据
投影到低维空间，保留最大方差方向。
在词向量中，PCA可以用于对词向量进行降维或可视化。
""",
'svd_reduction': """
奇异值分解（SVD）将矩阵分解为三个矩阵的乘积：A = UΣV^T。
在NLP中，SVD常用于降维、矩阵近似和主题模型。
能够有效处理稀疏的共现矩阵。
"""
}
return descriptions.get(method_name, "未知方法")
def create_comparison_matrix(self):
"""创建方法对比矩阵"""
import pandas as pd
import numpy as np
comparison_data = {
'方法': ['TF-IDF', 'PMI', 'LSA', 'Word2Vec', 'GloVe'],
'理论基础': ['信息论', '信息论', '线性代数', '神经网络', '矩阵分解'],
'训练方式': ['无监督', '无监督', '无监督', '监督/无监督', '无监督'],
'向量维度': ['高维稀疏', '高维稀疏', '低维稠密', '低维稠密', '低维稠密'],
'语义关系': ['有限', '有限', '中等', '丰富', '丰富'],
'计算复杂度': ['低', '中等', '中等', '高', '中等'],
'内存需求': ['高', '高', '中等', '中等', '中等']
}
return pd.DataFrame(comparison_data)
# 使用示例
statistical_methods = StatisticalEmbeddingMethods()
print("=== 基于统计的词向量方法 ===")
for method in statistical_methods.methods:
print(f"\n{statistical_methods.methods[method]}:")
print(statistical_methods.describe_method(method))
comparison_df = statistical_methods.create_comparison_matrix()
print(f"\n=== 方法对比矩阵 ===")
print(comparison_df)
---
b.基于神经网络的方法
a.功能说明
神经网络方法通过端到端训练直接学习词向量，能够捕捉更复杂的语义关系。
b.代码示例
---
class NeuralEmbeddingMethods:
"""基于神经网络的词向量方法概述"""
def __init__(self):
self.architectures = {
'cbow': '连续词袋模型',
'skip_gram': '跳字模型',
'fasttext': '子词向量模型',
'glove': '全局向量模型',
'elmo': '上下文相关词向量',
'bert': '双向编码器表示'
}
def describe_architecture(self, arch_name: str) -> str:
"""描述指定的神经网络架构"""
descriptions = {
'cbow': """
连续词袋模型通过上下文词汇预测中心词。
输入：上下文词汇
输出：中心词
优点：训练速度快，对小语料友好
缺点：对语序信息不敏感
""",
'skip_gram': """
跳字模型通过中心词预测上下文词汇。
输入：中心词
输出：上下文词汇
优点：对罕见词表现更好，能捕捉更多语义关系
缺点：训练速度较慢
""",
'fasttext': """
FastText将每个词表示为其字符n-gram向量的和。
优势：能够处理未登录词，适合形态丰富语言
子词信息：使用字符级n-gram增强词表示
""",
'glove': """
全局向量结合了全局统计矩阵和局部上下文信息。
训练目标：学习词向量使其与全局共现统计一致
优势：能够利用全局统计信息，训练相对快速
""",
'elmo': """
ELMo使用双向LSTM生成上下文相关的词向量。
深度双向：能够捕捉深层次的语法和语义信息
动态表示：同一个词在不同上下文中有不同的向量表示
""",
'bert': """
BERT使用Transformer编码器生成深度上下文相关的词向量。
注意力机制：能够建模长距离依赖关系
预训练微调：大规模预训练加下游任务微调
"""
}
return descriptions.get(arch_name, "未知架构")
def create_architecture_flowchart(self):
"""创建架构流程图"""
flowchart = """
神经网络词向量架构演进：
Word2Vec (2013)
├── CBOW: context → target
└── Skip-gram: target → context
GloVe (2014)
├── 共现矩阵统计
├── 矩阵分解训练
└── 向量生成
FastText (2016)
├── 字符n-gram提取
├── 子词向量学习
└── 词汇向量聚合
ELMo (2018)
├── 字符CNN编码
├── 双向LSTM处理
└── 深度上下文表示
BERT (2018)
├── Transformer编码器
├── 多头注意力机制
└── 深度上下文表示
"""
return flowchart
# 使用示例
neural_methods = NeuralEmbeddingMethods()
print("=== 基于神经网络的词向量方法 ===")
for arch in neural_methods.architectures:
print(f"\n{neural_methods.architectures[arch]}:")
print(neural_methods.describe_architecture(arch))
print(f"\n=== 架构演进流程图 ===")
print(neural_methods.create_architecture_flowchart())
---
03.One-Hot编码与局限性
a.One-Hot编码原理与实现
One-Hot编码是最简单的词汇表示方法，将每个词映射到一个维度等于词汇表大小的向量，其中只有一个元素为1，其余为0。
---
import numpy as np
from typing import List, Dict, Any
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.metrics.pairwise import cosine_similarity
import seaborn as sns
class OneHotEncoder:
"""One-Hot编码器实现"""
def __init__(self, vocabulary: List[str] = None):
"""
初始化One-Hot编码器
Args:
vocabulary: 词汇表，如果为None则从训练数据中构建
"""
if vocabulary is not None:
self.vocabulary = vocabulary
self.word_to_idx = {word: idx for idx, word in enumerate(vocabulary)}
else:
self.vocabulary = []
self.word_to_idx = {}
self.idx_to_word = {}
self.vocab_size = 0
self.encoding_matrix = None
def fit(self, corpus: List[List[str]]) -> 'OneHotEncoder':
"""
从语料中构建词汇表
Args:
corpus: 语料列表，每个元素是分好词的句子
Returns:
自身实例
"""
# 收集所有唯一词汇
all_words = set()
for sentence in corpus:
all_words.update(sentence)
self.vocabulary = sorted(list(all_words))
self.word_to_idx = {word: idx for idx, word in enumerate(self.vocabulary)}
self.idx_to_word = {idx: word for word, idx in self.word_to_idx.items()}
self.vocab_size = len(self.vocabulary)
print(f"词汇表大小: {self.vocab_size}")
print(f"词汇表前10个词: {self.vocabulary[:10]}")
return self
def transform(self, words: List[str]) -> np.ndarray:
"""
将词汇转换为One-Hot编码
Args:
words: 词汇列表
Returns:
One-Hot编码矩阵 [len(words), vocab_size]
"""
if self.vocab_size == 0:
raise ValueError("请先调用fit方法构建词汇表")
encoding_matrix = np.zeros((len(words), self.vocab_size), dtype=np.float32)
for i, word in enumerate(words):
if word in self.word_to_idx:
encoding_matrix[i, self.word_to_idx[word]] = 1.0
else:
# 处理未知词汇
encoding_matrix[i, 0] = 1.0 # 使用第一个位置表示未知词
print(f"警告: 未知词 '{word}' 使用未知词表示")
self.encoding_matrix = encoding_matrix
return encoding_matrix
def fit_transform(self, corpus: List[List[str]]) -> np.ndarray:
"""训练并转换"""
all_words = []
for sentence in corpus:
all_words.extend(sentence)
return self.transform(all_words)
def decode(self, encoded_vector: np.ndarray) -> str:
"""将One-Hot编码解码为词汇"""
if self.vocab_size == 0:
return "未知"
if encoded_vector.ndim == 1:
idx = np.argmax(encoded_vector)
return self.idx_to_word.get(idx, "未知")
else:
words = []
for vec in encoded_vector:
idx = np.argmax(vec)
words.append(self.idx_to_word.get(idx, "未知"))
return ' '.join(words)
def get_sparsity(self) -> float:
"""计算编码矩阵的稀疏度"""
if self.encoding_matrix is None:
return 0.0
total_elements = self.encoding_matrix.size
non_zero_elements = np.count_nonzero(self.encoding_matrix)
sparsity = 1.0 - (non_zero_elements / total_elements)
return sparsity
def visualize_encoding(self, words: List[str] = None, sample_size: int = 10):
"""可视化One-Hot编码"""
if words is None:
words = self.vocabulary[:sample_size] if self.vocabulary else []
encoded = self.transform(words)
plt.figure(figsize=(12, 6))
plt.imshow(encoded.T, cmap='Blues', aspect='auto')
plt.colorbar(label='编码值')
plt.yticks(range(len(words)), words)
plt.xlabel('词汇索引')
plt.title('One-Hot编码可视化')
plt.tight_layout()
plt.show()
return encoded
def analyze_properties(self):
"""分析One-Hot编码的性质"""
if self.encoding_matrix is None:
print("没有编码矩阵，请先调用transform方法")
return
properties = {
'vocab_size': self.vocab_size,
'matrix_shape': self.encoding_matrix.shape,
'sparsity': self.get_sparsity(),
'mean_nonzero': np.mean(self.encoding_matrix[self.encoding_matrix > 0]),
'storage_efficiency': self.vocab_size / np.prod(self.encoding_matrix.shape)
}
print("=== One-Hot编码性质分析 ===")
for key, value in properties.items():
print(f"{key}: {value}")
return properties
# 使用示例
print("=== One-Hot编码演示 ===")
# 示例语料
corpus = [
["自然", "语言", "处理", "是", "人工", "智能", "的", "重要", "分支"],
["深度", "学习", "模型", "表现", "很", "好"],
["我们", "需要", "更多", "的", "数据"]
]
# 创建并训练编码器
encoder = OneHotEncoder()
encoder.fit(corpus)
# 转换测试词汇
test_words = ["自然", "处理", "模型", "数据", "未知词"]
encoded = encoder.transform(test_words)
print(f"\nOne-Hot编码结果:")
for i, word in enumerate(test_words):
encoded_vector = encoded[i]
non_zero_indices = np.where(encoded_vector > 0)[0]
print(f" {word}: 稀疏位置 {non_zero_indices}")
# 可视化编码
encoder.visualize_encoding(sample_size=8)
# 分析性质
properties = encoder.analyze_properties()
---
b.One-Hot编码的局限性分析
One-Hot编码虽然简单直接，但存在严重的维度灾难和语义表示能力有限的问题。
---
class OneHotLimitations:
"""One-Hot编码局限性分析"""
def __init__(self):
self.issues = {
'dimensional_catastrophe': '维度灾难',
'semantic_ga': '语义鸿沟',
'oov_problem': '未登录词问题',
'computational_inefficiency': '计算效率问题',
'memory_usage': '内存使用问题',
'no_similarity_metric': '缺乏相似性度量',
'context_insensitivity': '上下文不敏感'
}
def analyze_issue(self, issue_name: str) -> Dict[str, Any]:
"""分析特定问题"""
analyses = {
'dimensional_catastrophe': {
'description': '词汇表越大，向量维度越高',
'mathematical_explanation': '维度 = |V|，其中V是词汇表大小',
'practical_impact': '对于大型词汇表（10万+词），向量维度极高',
'consequences': [
'存储空间爆炸',
'计算复杂度增加',
'模型过拟合风险'
]
},
'semantic_ga': {
'description': '无法捕捉词汇间的语义关系',
'mathematical_explanation': '任意两个不同词向量的点积为0',
'practical_impact': '语义相似的词距离相等',
'examples': ['king-man ≈ queen-princess', 'computer-calc ≈ king-queen'],
'consequences': [
'无法进行语义推理',
'词类比运算失败',
'下游任务性能受限'
]
},
'oov_problem': {
'description': '无法处理训练时未见的词汇',
'mathematical_explanation': '未知词只能映射到未知向量或零向量',
'practical_impact': '新词、新术语、拼写错误无法正确表示',
'solutions': ['使用子词方法', '动态扩展词汇表'],
'consequences': [
'泛化能力差',
'需要频繁更新模型',
'对新领域适应性差'
]
},
'computational_inefficiency': {
'description': '存储和计算效率低下',
'mathematical_explanation': '矩阵运算O(n²)，其中n为词汇表大小',
'practical_impact': '训练和推理速度慢',
'benchmarks': {
'10K词汇表': '存储需要40MB，计算需要10⁸次运算',
'100K词汇表': '存储需要400MB，计算需要10¹⁰次运算'
},
'consequences': [
'训练时间长',
'推理速度慢',
'硬件资源消耗大'
]
},
'no_similarity_metric': {
'description': '缺乏有效的相似性度量方法',
'mathematical_explanation': '点积恒为0，余弦相似度无意义',
'practical_impact': '无法量化词汇相似度',
'alternatives': ['余弦相似度', '欧氏距离', '曼哈顿距离'],
'consequences': [
'无法进行语义搜索',
'聚类效果差',
'相似词发现困难'
]
},
'context_insensitivity': {
'description': '同一词汇在不同上下文中表示相同',
'mathematical_explanation': '每个词只有唯一向量表示',
'practical_impact': '无法捕捉一词多义现象',
'examples': ['bank(银行/河岸)', 'apple(公司/水果)'],
'consequences': [
'一词多义处理能力差',
'上下文理解受限',
'下游任务精度低'
]
}
}
return analyses.get(issue_name, {})
def demonstrate_limitations(self):
"""演示One-Hot编码的局限性"""
print("=== One-Hot编码局限性演示 ===\n")
for issue_name in self.issues:
analysis = self.analyze_issue(issue_name)
print(f"### {analysis['description']}")
print(f"数学解释: {analysis['mathematical_explanation']}")
print(f"实际影响: {analysis['practical_impact']}")
if 'examples' in analysis:
print(f"示例: {analysis['examples']}")
if 'solutions' in analysis:
print(f"解决方案: {', '.join(analysis['solutions'])}")
print(f"后果: {', '.join(analysis['consequences'])}\n")
return True
def create_comparison_table(self):
"""创建与词向量的对比表"""
import pandas as pd
comparison_data = {
'特性': ['维度大小', '语义表示', '未登录词', '相似性度量', '上下文感知', '计算效率', '存储效率', '迁移能力'],
'One-Hot': ['|V| (高)', '无', '不支持', '不支持', '不支持', '低', '低', '无'],
'Word2Vec': ['50-300 (低)', '强', '部分支持', '支持', '部分支持', '中等', '高', '强'],
'GloVe': ['50-300 (低)', '强', '部分支持', '支持', '部分支持', '高', '高', '强'],
'ELMo': ['1024 (中)', '很强', '支持', '支持', '强', '低', '中等', '强'],
'BERT': ['768-1024 (中)', '极强', '支持', '支持', '极强', '低', '中等', '极强']
}
return pd.DataFrame(comparison_data)
# 使用示例
limitations = OneHotLimitations()
limitations.demonstrate_limitations()
# 创建对比表
comparison_table = limitations.create_comparison_table()
print("=== One-Hot编码与词向量对比 ===")
print(comparison_table)
---
c.维度灾难可视化演示
通过可视化展示One-Hot编码的维度灾难问题。
---
class DimensionalCatastropheDemo:
"""维度灾难可视化演示"""
def __init__(self):
self.vocab_sizes = [100, 1000, 10000, 100000, 1000000]
self.vector_dims = self.vocab_sizes # One-Hot: 维度 = 词汇表大小
def calculate_storage_requirements(self):
"""计算存储需求"""
storage_data = []
for vocab_size, vector_dim in zip(self.vocab_sizes, self.vector_dims):
# 假设使用float32 (4 bytes per value)
storage_mb = (vocab_size * vector_dim * 4) / (1024 * 1024)
storage_data.append({
'Vocabulary Size': vocab_size,
'Vector Dimension': vector_dim,
'Storage (MB)': storage_mb,
'Storage (GB)': storage_mb / 1024
})
return storage_data
def calculate_computational_complexity(self):
"""计算计算复杂度"""
complexity_data = []
for vocab_size in self.vocab_sizes:
# 矩阵乘法复杂度 O(n²)
operations_per_forward_pass = vocab_size ** 2
operations_per_second = 10⁹ # 假设每秒10亿次运算
complexity_data.append({
'Vocabulary Size': vocab_size,
'Operations per Forward Pass': operations_per_forward_pass,
'Time per Forward Pass (s)': operations_per_forward_pass / operations_per_second,
'Time per Forward Pass (ms)': (operations_per_forward_pass / operations_per_second) * 1000
})
return complexity_data
def create_visualization(self):
"""创建可视化图表"""
import matplotlib.pyplot as plt
import numpy as np
# 计算数据
storage_data = self.calculate_storage_requirements()
complexity_data = self.calculate_computational_complexity()
# 创建子图
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
# 1. 存储需求增长
ax1.loglog(self.vocab_sizes, [d['Storage (MB)'] for d in storage_data], 'b-', linewidth=2)
ax1.set_xlabel('词汇表大小')
ax1.set_ylabel('存储需求 (MB)')
ax1.set_title('One-Hot编码存储需求增长')
ax1.grid(True, alpha=0.3)
# 添加对数趋势线
x = np.array(self.vocab_sizes)
y = x * 4 / (1024 * 1024) # MB
ax1.plot(x, y, 'r--', alpha=0.7, label='理论线性增长')
ax1.legend()
# 2. 计算复杂度
ax2.loglog(self.vocab_sizes, [d['Time per Forward Pass (s)'] for d in complexity_data], 'g-', linewidth=2)
ax2.set_xlabel('词汇表大小')
ax2.set_ylabel('前向传播时间 (秒)')
ax2.set_title('One-Hot编码计算复杂度')
ax2.grid(True, alpha=0.3)
# 3. 存储效率对比
memory_efficiency = [d['Storage (MB)'] / (d['Vocabulary Size'] / 1000) for d in storage_data]
ax3.semilogx(self.vocab_sizes, memory_efficiency, 'r-', linewidth=2)
ax3.set_xlabel('词汇表大小')
ax3.set_ylabel('每个词的存储效率 (KB/千词)')
ax3.set_title('存储效率分析')
ax3.grid(True, alpha=0.3)
# 4. 实际应用案例
real_world_data = {
'小型词汇表': {'size': 5000, 'storage_mb': 19, 'description': '特定领域术语'},
'中型词汇表': {'size': 50000, 'storage_mb': 190, 'description': '通用英语'},
'大型词汇表': {'size': 200000, '存储_mb': 763, 'description': '多语言支持'},
'超大型词汇表': {'size': 1000000, 'storage_mb': 3815, 'description': '互联网规模'}
}
names = list(real_world_data.keys())
sizes = [data['size'] for data in real_world_data.values()]
storage = [data['storage_mb'] for data in real_world_data.values()]
descriptions = [data['description'] for data in real_world_data.values()]
colors = plt.cm.Set3(np.linspace(0, 1, len(names)))
bars = ax4.bar(names, storage, color=colors)
ax4.set_xlabel('应用类型')
ax4.set_ylabel('存储需求 (MB)')
ax4.set_title('实际应用中的存储需求')
# 添加数值标签
for bar, storage_val in zip(bars, storage):
height = bar.get_height()
ax4.text(bar.get_x() + bar.get_width()/2, height,
f'{storage_val}MB', ha='center', va='bottom')
plt.tight_layout()
plt.show()
return fig, storage_data, complexity_data
def analyze_scalability(self):
"""分析可扩展性问题"""
print("=== One-Hot编码可扩展性分析 ===")
storage_data = self.calculate_storage_requirements()
complexity_data = self.calculate_computational_complexity()
print("1. 存储可扩展性问题:")
for data in storage_data[-3:]: # 显示最大的3个案例
print(f" 词汇表{data['Vocabulary_size']:,>}: {data['Storage (GB)']:.2f}GB "
f"({data['Storage (MB) * 1024:.0f}MB)")
print(f"\n2. 计算可扩展性问题:")
for data in complexity_data[-3:]: # 显示最大的3个案例
print(f" 词汇表{data['Vocabulary_size']:,>}: "
f"前向传播 {data['Time per Forward Pass (s)']:.2f}秒")
print(f"\n3. 实际影响:")
print(" - 大型NLP项目无法使用One-Hot编码")
print(" - 模型训练和推理速度极慢")
print(" - 内存占用过高，硬件成本巨大")
print(" - 无法支持在线实时应用")
return storage_data, complexity_data
# 使用示例
demo = DimensionalCatastropheDemo()
# 创建可视化
fig, storage_data, complexity_data = demo.create_visualization()
# 分析可扩展性
demo.analyze_scalability()
# 创建影响总结
print("\n=== 维度灾难影响总结 ===")
print("1. 限制模型规模和词汇表大小")
print("2. 增加训练和推理时间")
print("3. 提高硬件成本和维护难度")
print("4. 限制在工业界的实际应用")
print("5. 推动了更高效的词向量技术发展")
---
04.基础词向量技术
a.TF-IDF加权词向量
TF-IDF（词频-逆文档频率）结合了局部和全局统计信息，为每个词生成权重向量。
---
import numpy as np
from collections import Counter, defaultdict
from sklearn.feature_extraction.text import TfidfVectorizer
import math
from typing import List, Dict, Tuple, Any
class TFIDFWordEmbedding:
"""基于TF-IDF的词向量实现"""
def __init__(self):
self.vocabulary = {}
self.document_frequency = defaultdict(int)
self.inverse_document_frequency = {}
self.term_frequency = defaultdict(lambda: defaultdict(int))
self.tfidf_scores = {}
self.idf_values = {}
self.vocab_size = 0
self.num_documents = 0
def fit(self, documents: List[List[str]]) -> 'TFIDFWordEmbedding':
"""
训练TF-IDF模型
Args:
documents: 文档列表，每个文档是词汇列表
Returns:
自身实例
"""
self.documents = documents
self.num_documents = len(documents)
# 1. 构建词汇表
self._build_vocabulary()
# 2. 计算文档频率 (DF)
self._calculate_document_frequency()
# 3. 计算逆文档频率 (IDF)
self._calculate_inverse_document_frequency()
# 4. 计算词频 (TF)
self._calculate_term_frequency()
# 5. 计算TF-IDF权重
self._calculate_tfidf_scores()
print(f"TF-IDF模型训练完成")
print(f"词汇表大小: {self.vocab_size}")
print(f"文档数量: {self.num_documents}")
return self
def _build_vocabulary(self):
"""构建词汇表"""
word_count = Counter()
for document in self.documents:
word_count.update(document)
self.vocabulary = dict(word_count.most_common())
self.vocab_size = len(self.vocabulary)
self.word_to_idx = {word: idx for idx, word in enumerate(self.vocabulary)}
def _calculate_document_frequency(self):
"""计算文档频率"""
for word in self.vocabulary:
df_count = 0
for document in self.documents:
if word in document:
df_count += 1
self.document_frequency[word] = df_count
def _calculate_inverse_document_frequency(self):
"""计算逆文档频率"""
for word, df in self.document_frequency.items():
# 平滑处理避免除零错误
idf = math.log((self.num_documents + 1) / (df + 1)) + 1
self.inverse_document_frequency[word] = idf
self.idf_values[word] = idf
def _calculate_term_frequency(self):
"""计算词频"""
for doc_idx, document in enumerate(self.documents):
word_count = Counter(document)
for word in word_count:
self.term_frequency[word][doc_idx] = word_count[word]
def _calculate_tfidf_scores(self):
"""计算TF-IDF权重"""
for word in self.vocabulary:
tfidf_scores = []
for doc_idx in range(self.num_documents):
tf = self.term_frequency[word][doc_idx]
idf = self.inverse_document_frequency[word]
tfidf = tf * idf
tfidf_scores.append(tfidf)
self.tfidf_scores[word] = tfidf_scores
def get_word_vector(self, word: str) -> np.ndarray:
"""获取词汇的TF-IDF向量"""
if word not in self.tfidf_scores:
# 返回零向量
return np.zeros(self.num_documents)
return np.array(self.tfidf_scores[word])
def get_document_vector(self, document: List[str]) -> np.ndarray:
"""获取文档的TF-IDF向量（所有词向量的平均）"""
doc_vector = np.zeros(self.num_documents)
word_count = Counter(document)
total_words = len(document)
for word, count in word_count.items():
if word in self.tfidf_scores:
word_vector = self.get_word_vector(word)
# 使用词频加权的平均
doc_vector += (count / total_words) * word_vector
return doc_vector
def get_similarity_matrix(self, words: List[str] = None) -> np.ndarray:
"""获取词汇相似度矩阵"""
if words is None:
words = list(self.vocabulary.keys())[:20] # 默认前20个词
n = len(words)
similarity_matrix = np.zeros((n, n))
for i in range(n):
for j in range(n):
if words[i] in self.vocabulary and words[j] in self.vocabulary:
vec1 = self.get_word_vector(words[i])
vec2 = self.get_word_vector(words[j])
# 使用余弦相似度
norm1 = np.linalg.norm(vec1)
norm2 = np.linalg.norm(vec2)
if norm1 > 0 and norm2 > 0:
similarity_matrix[i, j] = np.dot(vec1, vec2) / (norm1 * norm2)
return similarity_matrix
def analyze_vocabulary_statistics(self):
"""分析词汇统计信息"""
print("=== 词汇统计信息 ===")
# 词频分布
word_freqs = [self.term_frequency[word].values() for word in self.vocabulary]
avg_tf_per_doc = np.mean([sum(freqs) / len(freqs) if freqs else 0 for freqs in word_freqs])
# IDF分布
idf_values = list(self.idf_values.values())
avg_idf = np.mean(idf_values)
# 文档频率分布
df_values = list(self.document_frequency.values())
avg_df = np.mean(df_values)
print(f"词汇表大小: {self.vocab_size}")
f"文档数量: {self.num_documents}")
print(f"平均每文档词频: {avg_tf_per_doc:.2f}")
print(f"平均IDF值: {avg_idf:.4f}")
print(f"平均文档频率: {avg_df:.2f}")
# 高频词和低频词
high_freq_words = [word for word, freq in self.document_frequency.items() if freq > avg_df * 1.5]
low_freq_words = [word for word, freq in self.document_frequency.items() if freq < avg_df * 0.5]
print(f"\n高频词 (> {avg_df * 1.5:.0f} 词): {len(high_freq_words)}")
print(f"中频词: {len([w for w in self.vocabulary if w not in high_freq_words and w not in low_freq_words])}")
print(f"低频词 (< {avg_df * 0.5:.0f} 词): {len(low_freq_words)}")
if len(high_freq_words) <= 10:
print(f"高频词示例: {high_freq_words[:10]}")
if len(low_freq_words) <= 10:
print(f"低频词示例: {low_freq_words[:10]}")
return {
'vocab_size': self.vocab_size,
'num_documents': self.num_documents,
'avg_tf_per_doc': avg_tf_per_doc,
'avg_idf': avg_idf,
'avg_df': avg_df,
'high_freq_words': high_freq_words,
'low_freq_words': low_freq_words
}
# 使用示例
print("=== TF-IDF词向量演示 ===")
# 示例文档
documents = [
["自然", "语言", "处理", "是", "人工", "智能", "重要", "分支"],
["深度", "学习", "模型", "训练", "数据", "很好", "表现", "能力"],
["我们", "需要", "更多", "优质", "数据", "提升", "模型", "效果"],
["Python", "编程", "语言", "在", "机器", "学习", "领域", "应用", "广泛"],
["算法", "优化", "模型", "性能", "数据", "处理", "效率", "关键"]
]
# 训练TF-IDF模型
tfidf_embedding = TFIDFWordEmbedding()
tfidf_embedding.fit(documents)
# 分析统计信息
stats = tfidf_embedding.analyze_vocabulary()
# 获取示例词汇的向量
test_words = ["自然", "学习", "算法", "Python", "未知词"]
print(f"\n=== 词向量示例 ===")
for word in test_words:
vector = tfidf_embedding.get_word_vector(word)
non_zero_indices = np.where(vector > 0)[0]
print(f" {word}: 非零位置 {non_zero_indices[:5]} "
f"向量范数: {np.linalg.norm(vector):.4f}")
# 计算文档向量
test_document = documents[0]
doc_vector = tfidf_embedding.get_document_vector(test_document)
print(f"\n文档向量示例 (' '.join(test_document[:5]) + '...'):")
print(f" 向量范数: {np.linalg.norm(doc_vector):.4f}")
# 计算词汇相似度矩阵
similarity_matrix = tfidf_embedding.get_similarity_matrix()
# 可视化相似度矩阵
plt.figure(figsize=(10, 8))
sns.heatmap(similarity_matrix,
xticklabels=tfidf_embedding.vocabulary[:similarity_matrix.shape[0]],
yticklabels=tfidf_embedding.vocabulary[:similarity_matrix[1]],
cmap='coolwarm', annot=True, fmt='.3f')
plt.title('TF-IDF词汇相似度矩阵')
plt.tight_layout()
plt.show()
# 使用sklearn的TfidfVectorizer进行对比
print(f"\n=== 与sklearn对比 ===")
vectorizer = TfidfVectorizer()
sklearn_tfidf = vectorizer.fit_transform([' '.join(doc) for doc in documents])
print(f"sklearn Tfidf矩阵形状: {sklearn_tfidf.shape}")
print(f"自定义TF-IDF矩阵形状: {len(documents)} x {tfidf_embedding.vocab_size}")
---
b.PMI（点互信息）词向量
点互信息衡量两个词共同出现的程度，能够识别有意义的词汇关联。
---
class PMIWordEmbedding:
"""基于点互信息的词向量实现"""
def __init__(self, window_size: int = 5, min_count: int = 1):
"""
初始化PMI词向量器
Args:
window_size: 上下文窗口大小
min_count: 最小出现次数
"""
self.window_size = window_size
self.min_count = min_count
self.word_count = Counter()
self.cooccurrence_count = defaultdict(lambda: defaultdict(int))
self.pmi_values = {}
self.word_to_idx = {}
self.idx_to_word = {}
self.embedding_dim = 0
def fit(self, documents: List[List[str]]) -> 'PMIWordEmbedding':
"""
训练PMI模型
Args:
documents: 文档列表，每个文档是词汇列表
Returns:
自身实例
"""
print("开始训练PMI模型...")
# 1. 统计词频和共现频率
self._count_cooccurrences(documents)
# 2. 计算点互信息
self._calculate_pmi()
# 3. 构建词汇表和索引
self._build_vocabulary_index()
print(f"PMI模型训练完成")
print(f"词汇表大小: {self.embedding_dim}")
return self
def _count_cooccurrences(self, documents: List[List[str]]):
"""统计词频和共现频率"""
print("统计词频和共现频率...")
# 统计词频
for document in documents:
word_count = Counter(document)
self.word_count.update(word_count)
# 统计共现频率
total_cooccurrences = 0
for document in documents:
n = len(document)
for i in range(n):
for j in range(max(0, i - self.window_size), min(n, i + self.window_size + 1)):
if i != j:
word1, word2 = document[i], document[j]
self.cooccurrence_count[word1][word2] += 1
total_cooccurrences += 1
print(f"总词汇数: {len(self.word_count)}")
print(f"总共现对数: {total_cooccurrences}")
def _calculate_pmi(self):
"""计算点互信息"""
print("计算点互信息...")
for word1, cooccurrences in self.cooccurrence_count.items():
for word2, count in cooccurrences.items():
# PMI(word1, word2) = log(P(word1, word2) / (P(word1) * P(word2))
# 使用拉普拉斯平滑
p_word1 = self.word_count[word1] / sum(self.word_count.values())
p_word2 = self.word_count[word2] / sum(self.word_count.values())
p_word1_word2 = count / total_cooccurrences
if p_word1 > 0 and p_word2 > 0 and p_word1_word2 > 0:
pmi = math.log2(p_word1_word2 / (p_word1 * p_word2))
self.pmi_values[(word1, word2)] = pmi
self.pmi_values[(word2, word1)] = pmi
print(f"PMI计算完成，共{len(self.pmi_values)}个词对")
def _build_vocabulary_index(self):
"""构建词汇表和索引"""
# 只保留出现频率足够的词
filtered_words = [word for word, count in self.word_count.items()
if count >= self.min_count]
self.vocabulary = sorted(filtered_words)
self.word_to_idx = {word: idx for idx, word in enumerate(self.vocabulary)}
self.idx_to_word = {idx: word for idx, word in enumerate(self.vocabulary)}
self.embedding_dim = len(self.vocabulary)
def get_pmi_value(self, word1: str, word2: str) -> float:
"""获取两个词的PMI值"""
return self.pmi_values.get((word1, word2), 0.0)
def create_pmi_matrix(self, sample_size: int = 20) -> Tuple[np.ndarray, List[str]]:
"""创建PMI矩阵"""
# 选择高频词汇
high_freq_words = sorted(self.word_count.items(),
key=lambda x: x[1], reverse=True)[:sample_size]
selected_words = [word for word, count in high_freq_words]
n = len(selected_words)
pmi_matrix = np.zeros((n, n))
for i in range(n):
for j in range(n):
word1, word2 = selected_words[i], selected_words[j]
pmi_matrix[i, j] = self.get_pmi_value(word1, word2)
return pmi_matrix, selected_words
def get_word_vector(self, word: str, context_window: List[str] = None) -> np.ndarray:
"""
基于上下文创建词向量
Args:
word: 中心词
context_window: 上下文词汇列表
Returns:
词向量
"""
if context_window is None:
# 使用平均PMI值作为向量
pmi_values = []
for vocab_word in self.vocabulary:
pmi_val = self.get_pmi_value(word, vocab_word)
pmi_values.append(pmi_val)
return np.array(pmi_values)
# 创建基于特定上下文的向量
context_vector = []
for context_word in context_window:
pmi_val = self.get_pmi_value(word, context_word)
context_vector.append(pmi_val)
return np.array(context_vector)
def visualize_pmi_matrix(self, sample_size: int = 15):
"""可视化PMI矩阵"""
pmi_matrix, selected_words = self.create_pmi_matrix(sample_size)
plt.figure(figsize=(12, 10))
sns.heatmap(pmi_matrix,
xticklabels=selected_words,
yticklabels=selected_words,
cmap='RdYlBu_r',
annot=True,
fmt='.2f')
plt.title(f'点互信息 (PMI) 矩阵 (前{sample_size}个高频词)')
plt.tight_layout()
plt.show()
return pmi_matrix, selected_words
def analyze_pmi_statistics(self):
"""分析PMI统计信息"""
print("=== PMI统计信息 ===")
if not self.pmi_values:
print("没有PMI数据，请先调用fit方法")
return
# PMI值分布
pmi_values = list(self.pmi_values.values())
positive_pmi = [val for val in pmi_values if val > 0]
negative_pmi = [val for val in pmi_values if val < 0]
print(f"PMI词对总数: {len(self.pmi_values)}")
print(f"正PMI值词对数: {len(positive_pmi)}")
print(f"负PMI值词对数: {len(negative_pmi)}")
print(f"PMI值范围: [{min(pmi_values):.2f}, {max(pmi_values):.2f}]")
# 高PMI和低PMI词对
sorted_pmi = sorted(self.pmi_values.items(), key=lambda x: x[1], reverse=True)
low_pmi = sorted(self.pmi_values.items(), key=lambda x: x[1])[:10]
high_pmi = sorted(self.pmi_values.items(), key=lambda x: x[1], reverse=True)[:10]
print(f"\n高PMI词对 (Top 10):")
for (word1, word2), pmi_val in high_pmi:
print(f" {word1} - {word2}: {pmi_val:.4f}")
print(f"\n低PMI词对 (Bottom 10):")
for (word1, word2), pmi_val in low_pmi:
print(f" {word1} - {word2}: {pmmi_val:.4f}")
return {
'total_pairs': len(self.pmi_values),
'positive_pairs': len(positive_pmi),
'negative_pairs': len(negative_pmi),
'pmi_range': (min(pmi_values), max(pmi_values)),
'high_pmi_pairs': high_pmi,
'low_pmi_pairs': low_pmi
}
def find_word_associations(self, word: str, top_k: int = 10) -> List[Tuple[str, float]]:
"""查找与给定词关联的词汇"""
if word not in self.word_count:
return []
word_associations = []
for other_word in self.vocabulary:
if other_word != word:
pmi_val = self.get_pmi_value(word, other_word)
word_associations.append((other_word, pmi_val))
# 按PMI值排序
word_associations.sort(key=lambda x: x[1], reverse=True)
return word_associations[:top_k]
# 使用示例
print("=== 点互信息(PMI)词向量演示 ===")
# 训练PMI模型
pmi_embedding = PMIWordEmbedding(window_size=5, min_count=2)
pmi_embedding.fit(documents)
# 分析统计信息
stats = pmi_embedding.analyze_pmi_statistics()
# 查找词关联
test_words = ["自然", "语言", "模型", "算法"]
print(f"\n=== 词汇关联分析 ===")
for word in test_words:
associations = pmi_embedding.find_word_associations(word, top_k=5)
print(f"\n与'{word}'最相关的词汇:")
for assoc_word, pmi_val in associations:
print(f" {assoc_word}: PMI = {pmi_val:.4f}")
# 可视化PMI矩阵
pmi_matrix, selected_words = pmi_embedding.visualize_pmi_matrix(sample_size=12)
# 展示词向量获取
print(f"\n=== 词向量获取示例 ===")
center_word = "自然"
context_words = ["语言", "处理", "人工", "智能"]
vector = pmi_embedding.get_word_vector(center_word, context_words)
print(f"中心词: {center_word}")
print(f"上下文词汇: {context_words}")
print(f"向量形状: {vector.shape}")
print(f"向量范数: {np.linalg.norm(vector):.4f}")
---
05.神经网络词向量技术准备
a.神经网络基础知识回顾
神经网络是深度学习的核心，通过多层非线性变换学习数据的复杂模式。在词向量学习中，神经网络能够自动学习词汇的表示向量。
---
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class NeuralNetworkBasics:
"""神经网络基础知识回顾"""
@staticmethod
def activation_functions_demo():
"""激活函数演示"""
x = torch.linspace(-5, 5, 100)
# 不同激活函数
relu = F.relu(x)
sigmoid = torch.sigmoid(x)
tanh = torch.tanh(x)
leaky_relu = F.leaky_relu(x)
gelu = F.gelu(x)
activations = {
'ReLU': relu,
'Sigmoid': sigmoid,
'Tanh': tanh,
'Leaky ReLU': leaky_relu,
'GELU': gelu
}
plt.figure(figsize=(15, 10))
for i, (name, activation) in enumerate(activations.items(), 1):
plt.subplot(2, 3, i)
plt.plot(x.numpy(), activation.numpy())
plt.title(f'{name} 激活函数')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return activations
@staticmethod
def loss_functions_demo():
"""损失函数演示"""
# 模拟数据
y_true = torch.tensor([1, 0, 1, 1, 0, 0, 1, 0])
y_pred = torch.tensor([0.9, 0.1, 0.8, 0.95, 0.2, 0.3, 0.7, 0.15])
# 不同损失函数
mse_loss = F.mse_loss(y_pred, y_true)
cross_entropy_loss = F.cross_entropy(y_pred, y_true, weight=torch.tensor([1, 1, 1, 1, 1, 1, 1, 1]))
bce_loss = F.binary_cross_entropy(y_pred, y_true)
hinge_loss = F.hinge_loss(y_pred, y_true, torch.tensor([-1, 1]))
losses = {
'MSE Loss': mse_loss,
'Cross Entropy': cross_entropy_loss,
'Binary CE': bce_loss,
'Hinge Loss': hinge_loss
}
print("=== 损失函数比较 ===")
for name, loss in losses.items():
print(f"{name}: {loss.item():.4f}")
return losses
@staticmethod
def gradient_descent_demo():
"""梯度下降演示"""
# 简单的二次函数
def f(x, y):
return x² + y²
x, y = 3.0, 4.0
learning_rate = 0.1
iterations = 50
path_history = []
for i in range(iterations):
# 计算梯度
grad_x = 2 * x
grad_y = 2 * y
# 更新参数
x -= learning_rate * grad_x
y -= learning_rate * grad_y
path_history.append((x, y, f(x, y)))
# 可视化优化过程
x_history = [item[0] for item in path_history]
y_history = [item[1] for item in path_history]
z_history = [item[2] for item in path_history]
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
# 绘制优化路径
ax.plot(x_history, y_history, z_history, 'r-', linewidth=2)
ax.scatter(x_history[-1], y_history[-1], z_history[-1], 'ro', s=100)
# 绘制等高线
x = np.linspace(0, 6, 50)
y = np.linspace(0, 8, 50)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
ax.contour(X, Y, Z, levels=20, alpha=0.3)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('f(X,Y)')
ax.set_title('梯度下降优化过程')
plt.show()
return path_history
@staticmethod
def backpropagation_demo():
"""反向传播演示"""
# 简单的网络
class SimpleNetwork(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(SimpleNetwork, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
# 实例化网络
model = SimpleNetwork(10, 20, 1)
# 输入数据
x = torch.randn(32, 10)
y = torch.randn(32, 1)
# 前向传播
output = model(x)
loss = F.mse_loss(output, y)
# 反向传播
loss.backward()
# 获取梯度
fc1_grad = model.fc1.weight.grad
fc2_grad = model.fc2.weight.grad
print("=== 反向传播演示 ===")
print(f"损失值: {loss.item():.4f}")
print(f"FC1权重梯度范数: {fc1_grad.norm():.4f}")
print(f"FC2权重梯度范数: {fc2_grad.norm():.4f}")
return {
'loss': loss.item(),
'fc1_grad_norm': fc1_grad.norm().item(),
'fc2_grad_norm': fc2_grad.norm().item()
}
# 使用示例
print("=== 神经网络基础知识回顾 ===\n")
print("1. 激活函数演示:")
activations = NeuralNetworkBasics.activation_functions_demo()
print("\n2. 损失函数比较:")
losses = NeuralNetworkBasics.loss_functions_demo()
print("\n3. 梯度下降优化:")
path_history = NeuralNetworkBasics.gradient_descent_demo()
print("\n4. 反向传播演示:")
backprop_results = NeuralNetworkBasics.backpropagation_demo()
---
b.嵌入层原理与实现
嵌入层是将离散的词汇索引映射到连续向量空间的关键组件。
---
class EmbeddingLayer:
"""嵌入层实现与原理讲解"""
def __init__(self, vocab_size: int, embedding_dim: int, padding_idx: int = 0, max_norm: float = None):
"""
初始化嵌入层
Args:
vocab_size: 词汇表大小
embedding_dim: 嵌入维度
padding_idx: 填充索引
max_norm: 最大范数约束
"""
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
self.padding_idx = padding_idx
self.max_norm = max_norm
# 创建嵌入矩阵
self.embedding = nn.Embedding(
vocab_size, embedding_dim,
padding_idx=padding_idx,
max_norm=max_norm
)
# 初始化权重
nn.init.xavier_uniform_(self.embedding.weight)
def forward(self, input_ids: torch.Tensor) -> torch.Tensor:
"""
前向传播
Args:
input_ids: 输入ID张量 [batch_size, seq_len]
Returns:
嵌入向量 [batch_size, seq_len, embedding_dim]
"""
return self.embedding(input_ids)
def get_embedding_statistics(self):
"""获取嵌入层统计信息"""
weights = self.embedding.weight.data
return {
'weight_shape': weights.shape,
'weight_mean': weights.mean().item(),
'weight_std': weights.std().item(),
'weight_min': weights.min().item(),
'weight_max': weights.max().item(),
'sparsity': (weights == 0).float().mean().item()
}
def visualize_embeddings(self, sample_indices: List[int] = None, n_samples: int = 100):
"""可视化嵌入向量"""
if sample_indices is None:
# 随机选择词汇
sample_indices = np.random.choice(
min(self.vocab_size, n_samples),
size=n_samples,
replace=False
)
# 获取嵌入向量
embeddings = self.embedding.weight[sample_indices]
# 使用PCA降维进行可视化
if self.embedding_dim > 2:
pca = PCA(n_components=2)
embeddings_2d = pca.fit_transform(embeddings)
else:
embeddings_2d = embeddings
plt.figure(figsize=(12, 8))
scatter = plt.scatter(
embeddings_2d[:, 0],
embeddings_2d[:, 1],
c=range(len(embeddings_2d)),
cmap='viridis'
)
plt.colorbar(scatter, label='词索引')
# 标注一些词汇（如果有的话）
if hasattr(self, 'idx_to_word'):
for idx in sample_indices[:10]: # 只标注前10个
if idx in self.idx_to_word:
plt.annotate(
self.idx_to_word[idx],
(embeddings_2d[sample_indices.index(idx), 0],
(embeddings_2d[sample_indices.index(idx), 1])
)
plt.xlabel('第一主成分')
plt.ylabel('第二主成分')
plt.title('词向量PCA降维可视化')
plt.tight_layout()
plt.show()
return embeddings_2d
def find_similar_words(self, word_idx: int, top_k: int = 5) -> List[Tuple[int, float]]:
"""查找最相似的词汇"""
if word_idx >= self.vocab_size:
word_idx = self.vocab_size - 1 # 使用最后一个位置表示未知词
target_embedding = self.embedding.weight[word_idx]
# 计算与所有词汇的余弦相似度
similarities = []
for idx in range(self.vocab_size):
if idx != word_idx:
other_embedding = self.embedding.weight[idx]
similarity = F.cosine_similarity(
target_embedding.unsqueeze(0),
other_embedding.unsqueeze(0)
).item()
similarities.append((idx, similarity))
# 排序并返回top-k个
similarities.sort(key=lambda x: x[1], reverse=True)
return similarities[:top_k]
def embedding_properties_analysis(self):
"""嵌入层属性分析"""
stats = self.get_embedding_statistics()
print("=== 嵌入层属性分析 ===")
print(f"权重矩阵形状: {stats['weight_shape']}")
print(f"权重均值: {stats['weight_mean']:.4f}")
print(f"权重标准差: {stats['weight_std']:.4f}")
print(f"权重范围: [{stats['weight_min']:.4f}, {stats['weight_max']:.4f}]")
print(f"稀疏度: {stats['sparsity']:.4f}")
# 分析权重分布
weights_flat = self.embedding.weight.data.flatten()
plt.figure(figsize=(15, 5))
# 直方图
plt.subplot(1, 3, 1)
plt.hist(weights_flat, bins=50, alpha=0.7, density=True)
plt.xlabel('权重值')
plt.ylabel('密度')
plt.title('权重值分布直方图')
# Q-Q图
plt.subplot(1, 3, 2)
stats.probplot(weights_flat, dist="norm", plot=plt)
plt.xlabel('理论分位数')
plt.ylabel('实际分位数')
plt.title('Q-Q图')
# 箱线图
plt.subplot(1, 3, 3)
plt.plot(weights_flat, weights_flat, 'o', markersize=1, alpha=0.1)
plt.xlabel('权重索引')
plt.ylabel('权重值')
plt.title('权重值分布')
plt.tight_layout()
plt.show()
return stats
# 使用示例
print("=== 嵌入层原理与实现 ===")
# 创建嵌入层
vocab_size = 1000
embedding_dim = 100
embedding_layer = EmbeddingLayer(vocab_size, embedding_dim)
# 分析嵌入层属性
embedding_stats = embedding_layer.embedding_properties_analysis()
# 可视化嵌入向量
print(f"\n=== 嵌入向量可视化 ===")
embedding_2d = embedding_layer.visualize_embeddings(n_samples=50)
# 查找相似词汇
print(f"\n=== 相似词查找示例 ===")
test_indices = [10, 50, 100, 200, 500]
for idx in test_indices:
if idx < vocab_size:
similar_words = embedding_layer.find_similar_words(idx, top_k=3)
word = f"word_{idx}" # 假设我们没有词汇到索引的映射
print(f"{word} 的最相似词汇:")
for sim_idx, similarity in similar_words:
similar_word = f"word_{sim_idx}" # 假设
print(f" {similar_word}: 相似度 = {similarity:.4f}")
print()
# 演示梯度更新
print(f"\n=== 嵌入层梯度更新演示 ===")
# 创建简单的训练场景
input_ids = torch.randint(0, vocab_size, (4, 10))
target_vectors = torch.randn(4, 10, embedding_dim)
# 前向传播
embeddings = embedding_layer(input_ids)
loss = F.mse_loss(embeddings, target_vectors)
# 反向传播和梯度更新
loss.backward()
print(f"损失值: {loss.item():.4f}")
print(f"嵌入层权重梯度范数: {embedding_layer.embedding.weight.grad.norm():.4f}")
# 优化权重
optimizer = torch.optim.Adam(embedding_layer.parameters(), lr=0.01)
optimizer.step()
optimizer.zero_grad()
print(f"梯度更新完成")
return loss.item()
---
06.词向量评估与可视化
a.词向量质量评估指标
评估词向量质量需要考虑语义相似性、类比推理能力和下游任务表现等多个维度。
---
class WordEmbeddingEvaluator:
"""词向量质量评估器"""
def __init__(self, embeddings: Dict[str, np.ndarray]):
"""
初始化评估器
Args:
embeddings: 词汇到向量的映射字典
"""
self.embeddings = embeddings
self.vocabulary = list(embeddings.keys())
self.word_to_idx = {word: idx for idx, word in enumerate(self.vocabulary)}
self.embedding_matrix = np.array([embeddings[word] for word in self.vocabulary])
def calculate_cosine_similarity(self, word1: str, word2: str) -> float:
"""计算两个词的余弦相似度"""
if word1 not in self.embeddings or word2 not in self.embeddings:
return 0.0
vec1 = self.embeddings[word1]
vec2 = self.embeddings[word2]
dot_product = np.dot(vec1, vec2)
norm1 = np.linalg.norm(vec1)
norm2 = np.linalg.norm(vec2)
if norm1 == 0 or norm2 == 0:
return 0.0
return dot_product / (norm1 * norm2)
def evaluate_analogy_task(self, analogies: List[Tuple[str, str, str, str]]) -> Dict[str, float]:
"""
评估词类比任务
Args:
analogies: 类比任务列表，每个元素为 (word1, word2, word3, expected_word4)
Returns:
评估结果字典
"""
results = {
'total_tasks': len(analogies),
'correct_predictions': 0,
'top1_accuracy': 0.0,
'top5_accuracy': 0.0,
'top10_accuracy': 0.0
}
correct_top1 = correct_top5 = correct_top10 = 0
for word1, word2, word3, expected_word4 in analogies:
if all(word in self.embeddings for word in [word1, word2, word3, expected_word4]):
# 计算类比向量: word2 - word1 + word3
analogy_vector = (self.embeddings[word2] - self.embeddings[word1] +
self.embeddings[word3])
# 计算与所有词汇的相似度
similarities = []
for word in self.vocabulary:
if word not in [word1, word2, word3]: # 排除输入词
similarity = np.dot(analogy_vector, self.embeddings[word]) / (
np.linalg.norm(analogy_vector) * np.linalg.norm(self.embeddings[word])
)
similarities.append((word, similarity))
# 按相似度排序
similarities.sort(key=lambda x: x[1], reverse=True)
# 检查结果
predicted_words = [word for word, _ in similarities]
if expected_word4 == predicted_words[0]:
correct_top1 += 1
if expected_word4 in predicted_words[:5]:
correct_top5 += 1
if expected_word4 in predicted_words[:10]:
correct_top10 += 1
results['correct_predictions'] = correct_top1
results['top1_accuracy'] = correct_top1 / len(analogies) if analogies else 0
results['top5_accuracy'] = correct_top5 / len(analogies) if analogies else 0
results['top10_accuracy'] = correct_top10 / len(analogies) if analogies else 0
return results
def evaluate_similarity_task(self, similarity_pairs: List[Tuple[str, str, float]]) -> Dict[str, float]:
"""
评估相似度任务
Args:
similarity_pairs: (word1, word2, human_similarity) 列表
Returns:
相关系数和评估指标
"""
model_similarities = []
human_similarities = []
for word1, word2, human_sim in similarity_pairs:
if word1 in self.embeddings and word2 in self.embeddings:
model_sim = self.calculate_cosine_similarity(word1, word2)
model_similarities.append(model_sim)
human_similarities.append(human_sim)
# 计算相关系数
if len(model_similarities) > 1:
correlation = np.corrcoef(model_similarities, human_similarities)[0, 1]
else:
correlation = 0.0
# 计算其他指标
mse = np.mean([(ms - hs) ** 2 for ms, hs in zip(model_similarities, human_similarities)])
mae = np.mean([abs(ms - hs) for ms, hs in zip(model_similarities, human_similarities)])
return {
'correlation': correlation,
'mse': mse,
'mae': mae,
'valid_pairs': len(model_similarities),
'total_pairs': len(similarity_pairs)
}
def nearest_neighbors_analysis(self, test_words: List[str], top_k: int = 10) -> Dict[str, List[Tuple[str, float]]]:
"""最近邻分析"""
results = {}
for word in test_words:
if word in self.embeddings:
word_vector = self.embeddings[word]
similarities = []
for other_word in self.vocabulary:
if other_word != word:
similarity = self.calculate_cosine_similarity(word, other_word)
similarities.append((other_word, similarity))
similarities.sort(key=lambda x: x[1], reverse=True)
results[word] = similarities[:top_k]
return results
def cluster_analysis(self, word_categories: Dict[str, List[str]]) -> Dict[str, Any]:
"""
聚类分析
Args:
word_categories: 词汇类别字典
Returns:
聚类质量评估结果
"""
from sklearn.metrics import adjusted_rand_score, silhouette_score
from sklearn.cluster import KMeans
all_words = []
true_labels = []
for category_idx, (category, words) in enumerate(word_categories.items()):
valid_words = [word for word in words if word in self.embeddings]
all_words.extend(valid_words)
true_labels.extend([category_idx] * len(valid_words))
if len(all_words) < 2:
return {'error': '有效词汇数量不足'}
# 获取词向量
word_vectors = [self.embeddings[word] for word in all_words]
# K-means聚类
n_clusters = len(word_categories)
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
predicted_labels = kmeans.fit_predict(word_vectors)
# 计算评估指标
ari = adjusted_rand_score(true_labels, predicted_labels)
silhouette = silhouette_score(word_vectors, predicted_labels)
return {
'adjusted_rand_index': ari,
'silhouette_score': silhouette,
'n_clusters': n_clusters,
'n_words': len(all_words)
}
def generate_evaluation_report(self) -> Dict[str, Any]:
"""生成综合评估报告"""
print("=== 词向量质量评估报告 ===")
# 1. 基本统计信息
print("1. 基本统计信息:")
print(f" 词汇表大小: {len(self.vocabulary)}")
print(f" 嵌入维度: {len(list(self.embeddings.values())[0]) if self.embeddings else 0}")
if self.embeddings:
all_vectors = list(self.embeddings.values())
vector_matrix = np.array(all_vectors)
print(f" 向量均值: {np.mean(vector_matrix):.4f}")
print(f" 向量标准差: {np.std(vector_matrix):.4f}")
print(f" 向量范数均值: {np.mean([np.linalg.norm(v) for v in all_vectors]):.4f}")
# 2. 示例相似度分析
print("\n2. 相似度分析示例:")
sample_words = self.vocabulary[:5] if len(self.vocabulary) >= 5 else self.vocabulary
for i, word1 in enumerate(sample_words):
for word2 in sample_words[i+1:]:
sim = self.calculate_cosine_similarity(word1, word2)
print(f" {word1} - {word2}: {sim:.4f}")
return {
'vocabulary_size': len(self.vocabulary),
'embedding_dimension': len(list(self.embeddings.values())[0]) if self.embeddings else 0,
'basic_stats': self._calculate_basic_statistics()
}
def _calculate_basic_statistics(self) -> Dict[str, float]:
"""计算基本统计信息"""
if not self.embeddings:
return {}
all_vectors = list(self.embeddings.values())
vector_matrix = np.array(all_vectors)
return {
'mean': np.mean(vector_matrix),
'std': np.std(vector_matrix),
'min': np.min(vector_matrix),
'max': np.max(vector_matrix),
'avg_norm': np.mean([np.linalg.norm(v) for v in all_vectors])
}
# 使用示例
print("=== 词向量评估演示 ===")
# 创建示例词向量
sample_embeddings = {
'国王': np.random.randn(100) * 0.1 + np.array([1.0, 0.5, 0.2]),
'女王': np.random.randn(100) * 0.1 + np.array([0.9, 0.8, 0.3]),
'男人': np.random.randn(100) * 0.1 + np.array([0.6, 0.4, 0.1]),
'女人': np.random.randn(100) * 0.1 + np.array([0.7, 0.6, 0.2]),
'王子': np.random.randn(100) * 0.1 + np.array([0.95, 0.45, 0.15]),
'公主': np.random.randn(100) * 0.1 + np.array([0.85, 0.75, 0.25]),
'计算机': np.random.randn(100) * 0.1 + np.array([-0.5, -0.3, 0.8]),
'程序': np.random.randn(100) * 0.1 + np.array([-0.4, -0.2, 0.9]),
'数据': np.random.randn(100) * 0.1 + np.array([-0.6, -0.1, 0.7])
}
# 创建评估器
evaluator = WordEmbeddingEvaluator(sample_embeddings)
# 生成评估报告
report = evaluator.generate_evaluation_report()
# 最近邻分析
print(f"\n=== 最近邻分析 ===")
test_words = ['国王', '计算机']
neighbors = evaluator.nearest_neighbors_analysis(test_words, top_k=3)
for word, neighbor_list in neighbors.items():
print(f"\n{word} 的最近邻:")
for neighbor, similarity in neighbor_list:
print(f" {neighbor}: {similarity:.4f}")
# 类比任务评估
print(f"\n=== 类比任务评估 ===")
analogies = [
('国王', '女王', '男人', '女人'),
('男人', '女人', '王子', '公主'),
('计算机', '程序', '数据', '算法') # 最后一个词可能不在词汇表中
]
analogy_results = evaluator.evaluate_analogy_task(analogies)
print(f"Top-1 准确率: {analogy_results['top1_accuracy']:.4f}")
print(f"Top-5 准确率: {analogy_results['top5_accuracy']:.4f}")
print(f"Top-10 准确率: {analogy_results['top10_accuracy']:.4f}")
---
b.词向量可视化技术
可视化技术帮助我们直观理解词向量的语义空间结构和词汇关系。
---
class WordEmbeddingVisualizer:
"""词向量可视化器"""
def __init__(self, embeddings: Dict[str, np.ndarray]):
"""
初始化可视化器
Args:
embeddings: 词汇到向量的映射
"""
self.embeddings = embeddings
self.vocabulary = list(embeddings.keys())
self.embedding_matrix = np.array([embeddings[word] for word in self.vocabulary])
def pca_visualization(self, n_components: int = 2,
selected_words: List[str] = None,
color_groups: Dict[str, List[str]] = None):
"""
PCA降维可视化
Args:
n_components: 降维维度
selected_words: 选择的词汇列表
color_groups: 按组着色的词汇字典
"""
from sklearn.decomposition import PCA
if selected_words is None:
selected_words = self.vocabulary
# 获取选中词汇的向量
selected_vectors = [self.embeddings[word] for word in selected_words
if word in self.embeddings]
if not selected_vectors:
print("没有有效的词汇向量")
return
# PCA降维
pca = PCA(n_components=n_components)
vectors_2d = pca.fit_transform(selected_vectors)
# 创建图形
plt.figure(figsize=(12, 10))
if color_groups:
# 按组着色
colors = plt.cm.Set1(np.linspace(0, 1, len(color_groups)))
for group_idx, (group_name, words) in enumerate(color_groups.items()):
group_vectors = []
group_labels = []
for word in words:
if word in selected_words:
idx = selected_words.index(word)
group_vectors.append(vectors_2d[idx])
group_labels.append(word)
if group_vectors:
group_vectors = np.array(group_vectors)
plt.scatter(group_vectors[:, 0], group_vectors[:, 1],
c=[colors[group_idx]], label=group_name, s=60, alpha=0.7)
# 标注词汇
for i, label in enumerate(group_labels):
plt.annotate(label, (group_vectors[i, 0], group_vectors[i, 1]),
fontsize=8, alpha=0.8)
else:
# 统一着色
scatter = plt.scatter(vectors_2d[:, 0], vectors_2d[:, 1],
c=range(len(vectors_2d)), cmap='viridis', s=60, alpha=0.7)
# 标注词汇
for i, word in enumerate(selected_words):
plt.annotate(word, (vectors_2d[i, 0], vectors_2d[i, 1]),
fontsize=8, alpha=0.8)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.2%} variance)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.2%} variance)')
plt.title('词向量PCA降维可视化')
if color_groups:
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return vectors_2d, pca
def tsne_visualization(self, n_components: int = 2, perplexity: int = 30,
selected_words: List[str] = None,
color_groups: Dict[str, List[str]] = None):
"""
t-SNE降维可视化
Args:
n_components: 降维维度
perplexity: t-SNE困惑度
selected_words: 选择的词汇列表
color_groups: 按组着色的词汇字典
"""
from sklearn.manifold import TSNE
if selected_words is None:
selected_words = self.vocabulary
# 获取选中词汇的向量
selected_vectors = [self.embeddings[word] for word in selected_words
if word in self.embeddings]
if len(selected_vectors) < perplexity + 1:
print(f"词汇数量({len(selected_vectors)})少于困惑度+1({perplexity+1})")
return
# t-SNE降维
tsne = TSNE(n_components=n_components, perplexity=perplexity,
random_state=42, max_iter=1000)
vectors_2d = tsne.fit_transform(selected_vectors)
# 创建图形
plt.figure(figsize=(12, 10))
if color_groups:
# 按组着色
colors = plt.cm.Set1(np.linspace(0, 1, len(color_groups)))
for group_idx, (group_name, words) in enumerate(color_groups.items()):
group_vectors = []
group_labels = []
for word in words:
if word in selected_words:
idx = selected_words.index(word)
group_vectors.append(vectors_2d[idx])
group_labels.append(word)
if group_vectors:
group_vectors = np.array(group_vectors)
plt.scatter(group_vectors[:, 0], group_vectors[:, 1],
c=[colors[group_idx]], label=group_name, s=60, alpha=0.7)
# 标注词汇
for i, label in enumerate(group_labels):
plt.annotate(label, (group_vectors[i, 0], group_vectors[i, 1]),
fontsize=8, alpha=0.8)
else:
# 统一着色
scatter = plt.scatter(vectors_2d[:, 0], vectors_2d[:, 1],
c=range(len(vectors_2d)), cmap='viridis', s=60, alpha=0.7)
# 标注词汇
for i, word in enumerate(selected_words):
plt.annotate(word, (vectors_2d[i, 0], vectors_2d[i, 1]),
fontsize=8, alpha=0.8)
plt.xlabel('t-SNE维度1')
plt.ylabel('t-SNE维度2')
plt.title('词向量t-SNE降维可视化')
if color_groups:
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return vectors_2d, tsne
def similarity_heatmap(self, words: List[str] = None, max_words: int = 20):
"""相似度热力图"""
if words is None:
words = self.vocabulary[:max_words]
# 计算相似度矩阵
n = len(words)
similarity_matrix = np.zeros((n, n))
for i in range(n):
for j in range(n):
if words[i] in self.embeddings and words[j] in self.embeddings:
vec1 = self.embeddings[words[i]]
vec2 = self.embeddings[words[j]]
# 计算余弦相似度
similarity = np.dot(vec1, vec2) / (
np.linalg.norm(vec1) * np.linalg.norm(vec2)
)
similarity_matrix[i, j] = similarity
# 绘制热力图
plt.figure(figsize=(10, 8))
sns.heatmap(similarity_matrix, xticklabels=words, yticklabels=words,
cmap='coolwarm', center=0, annot=True, fmt='.2f', square=True)
plt.title('词向量相似度热力图')
plt.tight_layout()
plt.show()
return similarity_matrix
def word_clusters_visualization(self, n_clusters: int = 5, method: str = 'kmeans'):
"""词汇聚类可视化"""
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
# 准备数据
vectors = []
words = []
for word, vector in self.embeddings.items():
vectors.append(vector)
words.append(word)
vectors = np.array(vectors)
# 聚类
if method == 'kmeans':
clusterer = KMeans(n_clusters=n_clusters, random_state=42)
else:
from sklearn.cluster import AgglomerativeClustering
clusterer = AgglomerativeClustering(n_clusters=n_clusters)
cluster_labels = clusterer.fit_predict(vectors)
# 计算轮廓系数
if len(set(cluster_labels)) > 1:
silhouette_avg = silhouette_score(vectors, cluster_labels)
else:
silhouette_avg = 0
# 降维可视化
pca = PCA(n_components=2)
vectors_2d = pca.fit_transform(vectors)
# 绘制聚类结果
plt.figure(figsize=(12, 8))
colors = plt.cm.Set1(np.linspace(0, 1, n_clusters))
for cluster_id in range(n_clusters):
cluster_mask = cluster_labels == cluster_id
cluster_vectors = vectors_2d[cluster_mask]
cluster_words = [words[i] for i in range(len(words)) if cluster_mask[i]]
plt.scatter(cluster_vectors[:, 0], cluster_vectors[:, 1],
c=[colors[cluster_id]], label=f'聚类{cluster_id}',
s=60, alpha=0.7)
# 标注每个簇的中心词汇
if cluster_vectors.shape[0] > 0:
center_idx = np.random.choice(len(cluster_vectors),
min(3, len(cluster_vectors)), replace=False)
for idx in center_idx:
plt.annotate(cluster_words[idx],
(cluster_vectors[idx, 0], cluster_vectors[idx, 1]),
fontsize=8, alpha=0.8)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.2%} variance)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.2%} variance)')
plt.title(f'词向量聚类可视化 (轮廓系数: {silhouette_avg:.3f})')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 返回聚类结果
clusters = {}
for i, label in enumerate(cluster_labels):
if label not in clusters:
clusters[label] = []
clusters[label].append(words[i])
return {
'clusters': clusters,
'silhouette_score': silhouette_avg,
'vectors_2d': vectors_2d,
'cluster_labels': cluster_labels
}
def analogy_visualization(self, analogies: List[Tuple[str, str, str, str]]):
"""类比关系可视化"""
plt.figure(figsize=(15, 10))
for i, (word1, word2, word3, word4) in enumerate(analogies[:4]): # 最多显示4个类比
plt.subplot(2, 2, i+1)
# 检查词汇是否都在嵌入中
words = [word1, word2, word3, word4]
valid_words = [w for w in words if w in self.embeddings]
if len(valid_words) >= 3:
# 获取向量
vectors = [self.embeddings[w] for w in valid_words]
# PCA降维到2D
pca = PCA(n_components=2)
vectors_2d = pca.fit_transform(vectors)
# 绘制点
colors = ['red', 'blue', 'green', 'orange']
markers = ['o', 's', '^', 'D']
for j, (word, pos) in enumerate(zip(valid_words, vectors_2d)):
plt.scatter(pos[0], pos[1], c=colors[j], s=100,
marker=markers[j], label=word, alpha=0.7)
plt.annotate(word, pos, fontsize=10, alpha=0.8)
# 绘制类比向量（如果四个词都存在）
if len(valid_words) == 4:
# word1 -> word2 向量
plt.arrow(vectors_2d[0, 0], vectors_2d[0, 1],
vectors_2d[1, 0] - vectors_2d[0, 0],
vectors_2d[1, 1] - vectors_2d[0, 1],
head_width=0.1, head_length=0.1, fc='gray', ec='gray', alpha=0.5)
# word3 -> word4 向量
plt.arrow(vectors_2d[2, 0], vectors_2d[2, 1],
vectors_2d[3, 0] - vectors_2d[2, 0],
vectors_2d[3, 1] - vectors_2d[2, 1],
head_width=0.1, head_length=0.1, fc='gray', ec='gray', alpha=0.5)
plt.title(f'类比: {word1}:{word2} :: {word3}:{word4}')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 使用示例
print("=== 词向量可视化演示 ===")
# 创建可视化器
visualizer = WordEmbeddingVisualizer(sample_embeddings)
# 1. PCA可视化
print("1. PCA降维可视化:")
color_groups = {
'皇室': ['国王', '女王', '王子', '公主'],
'技术': ['计算机', '程序', '数据']
}
pca_result = visualizer.pca_visualization(
selected_words=list(sample_embeddings.keys()),
color_groups=color_groups
)
# 2. 相似度热力图
print("\n2. 相似度热力图:")
similarity_matrix = visualizer.similarity_heatmax(
words=list(sample_embeddings.keys())[:6]
)
# 3. 聚类可视化
print("\n3. 聚类可视化:")
cluster_results = visualizer.word_clusters_visualization(n_clusters=3)
# 4. 类比关系可视化
print("\n4. 类比关系可视化:")
analogies = [
('国王', '女王', '男人', '女人'),
('计算机', '程序', '数据', '算法')
]
visualizer.analogy_visualization(analogies)
---
07.总结与展望
a.词向量技术发展历程
1.独热编码时代 (1950s-2000s): 简单但有限的词汇表示
2.统计方法时代 (2000s-2010s): LSA、LSI、LDA等主题模型
3.神经网络时代 (2013-2018): Word2Vec、GloVe、FastText
4.上下文相关时代 (2018-2020): ELMo、BERT、GPT
5.大语言模型时代 (2020-至今): 超大规模预训练模型
b.当前挑战
当前词向量技术面临的主要挑战：
1.计算资源需求巨大
2.多语言和跨语言支持
3.领域适应性和迁移学习
4.解释性和可理解性
5.实时更新和增量学习
c.未来方向
1.更高效的训练算法
2.多模态词向量融合
3.知识增强的词表示
4.自适应和个性化词向量
5.量子计算在词向量训练中的应用
d.实践建议
1.根据任务需求选择合适的词向量方法
2.充分利用预训练模型并进行适当微调
3.关注词向量的评估和质量控制
4.结合具体业务场景优化词向量表示
5.持续跟踪最新的研究进展和技术发展
2.4 Word2Vec
01.模型概述
a.分类1
a.功能说明
Word2Vec是Google于2013年提出的词向量训练模型，由Tomas Mikolov等人开发。它通过浅层神经网络学习词向量，能够有效捕捉词汇间的语义关系，成为现代NLP的基础技术之一。
b.发展历程
a.2013年：首次发表"Efficient Estimation of Word Representations in Vector Space"
b.2013年：发布工具包，支持大规模语料训练
c.2014年：扩展支持短语检测和词类比
d.2015年：引入负采样和层次softmax优化
e.至今：广泛应用于各种NLP任务和深度学习模型中
c.核心思想
Word2Vec的核心思想基于分布式假说：一个词的含义由其上下文词汇决定。出现在相似上下文中的词具有相似的语义表示。
b.分类2
a.数学表达
P(context | target) → 相似的target具有相似的P(context | target)
b.关键假设
a.上下文窗口内的词汇与中心词存在语义关联
b.语义相似的词会出现在相似的上下文中
c.词向量空间能够反映词汇间的语义关系
c.分类3
a.架构对比
CBOW (Continuous Bag-of-Words) vs Skip-gram：
b.CBOW特点
a.输入：上下文词汇
b.输出：中心词
c.训练：根据上下文预测中心词
d.优势：训练速度快，对高频词效果好
e.适用：大规模语料，通用词表示
c.Skip-gram特点
a.输入：中心词
b.输出：上下文词汇
c.训练：根据中心词预测上下文
d.优势：对低频词和罕见词效果好
e.适用：小规模语料，专业术语学习
d.分类4
a.应用场景
a.文本分类和情感分析
b.机器翻译和跨语言映射
c.信息检索和语义搜索
d.推荐系统和用户画像
e.问答系统和对话系统
b.主要优势
a.训练效率高，支持大规模语料
b.向量质量好，语义表示丰富
c.支持词类比运算
d.实现简单，易于理解和优化
e.开源工具成熟，社区支持活跃
02.CBOW模型
a.架构设计
a.功能说明
CBOW模型采用三层架构：输入层、投影层和输出层。
b.架构设计
a.输入层：上下文词汇的One-Hot编码
b.投影层：上下文词向量的平均或求和
c.输出层：Softmax分类器预测中心词
c.网络结构
a.输入：多个上下文词的One-Hot向量
b.嵌入层：将One-Hot映射为词向量
c.投影层：对所有上下文向量求平均
d.输出层：预测中心词的概率分布
b.代码示例
---
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from typing import List, Tuple, Dict, Optional
import matplotlib.pyplot as plt
from collections import Counter, defaultdict
import math
class CBOWModel(nn.Module):
"""CBOW模型实现"""
def __init__(self, vocab_size: int, embedding_dim: int, context_size: int = 2):
"""
初始化CBOW模型
Args:
vocab_size: 词汇表大小
embedding_dim: 词向量维度
context_size: 上下文窗口大小（单侧）
"""
super(CBOWModel, self).__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
self.context_size = context_size
self.window_size = 2 * context_size # 总上下文大小
# 嵌入层：词汇到向量的映射
self.embeddings = nn.Embedding(vocab_size, embedding_dim)
# 输出层：投影层到词汇表的映射
self.output_layer = nn.Linear(embedding_dim, vocab_size)
# 初始化权重
self._init_weights()
def _init_weights(self):
"""初始化模型权重"""
# 嵌入层使用均匀分布初始化
nn.init.uniform_(self.embeddings.weight, -0.1/embedding_dim, 0.1/embedding_dim)
# 输出层使用Xavier初始化
nn.init.xavier_uniform_(self.output_layer.weight)
nn.init.zeros_(self.output_layer.bias)
def forward(self, context_ids: torch.Tensor) -> torch.Tensor:
"""
前向传播
Args:
context_ids: 上下文词汇ID [batch_size, window_size]
Returns:
中心词预测概率 [batch_size, vocab_size]
"""
# 获取上下文词向量 [batch_size, window_size, embedding_dim]
context_embeddings = self.embeddings(context_ids)
# 对上下文向量求平均 [batch_size, embedding_dim]
context_mean = torch.mean(context_embeddings, dim=1)
# 通过输出层预测中心词 [batch_size, vocab_size]
output_scores = self.output_layer(context_mean)
return output_scores
def get_embeddings(self) -> torch.Tensor:
"""获取词向量矩阵"""
return self.embeddings.weight.data
def get_word_vector(self, word_id: int) -> torch.Tensor:
"""获取指定词汇的向量"""
return self.embeddings.weight[word_id]
def find_most_similar(self, word_id: int, top_k: int = 5) -> List[Tuple[int, float]]:
"""查找最相似的词汇"""
if word_id >= self.vocab_size:
return []
word_vector = self.get_word_vector(word_id)
similarities = []
# 计算与所有词汇的余弦相似度
for i in range(self.vocab_size):
if i != word_id:
other_vector = self.get_word_vector(i)
similarity = F.cosine_similarity(
word_vector.unsqueeze(0),
other_vector.unsqueeze(0)
).item()
similarities.append((i, similarity))
# 按相似度排序
similarities.sort(key=lambda x: x[1], reverse=True)
return similarities[:top_k]
# 使用示例
print("=== CBOW模型架构演示 ===")
# 模型参数
vocab_size = 1000
embedding_dim = 100
context_size = 2
# 创建CBOW模型
cbow_model = CBOWModel(vocab_size, embedding_dim, context_size)
print(f"模型参数:")
print(f" 词汇表大小: {cbow_model.vocab_size}")
print(f" 词向量维度: {cbow_model.embedding_dim}")
print(f" 上下文窗口大小: {cbow_model.window_size}")
# 模拟输入数据
batch_size = 4
context_ids = torch.randint(0, vocab_size, (batch_size, cbow_model.window_size))
# 前向传播
output_scores = cbow_model(context_ids)
print(f"\n输入形状: {context_ids.shape}")
print(f"输出形状: {output_scores.shape}")
# 获取词向量
embeddings = cbow_model.get_embeddings()
print(f"词向量矩阵形状: {embeddings.shape}")
---
b.训练过程
a.功能说明
CBOW使用多分类交叉熵损失函数，通过最大化预测中心词的概率来训练模型。
b.训练步骤
a.准备训练数据：(上下文, 中心词)对
b.前向传播：计算中心词预测概率
c.计算损失：交叉熵损失
d.反向传播：更新模型参数
e.重复直到收敛
c.损失函数
L = -∑ log P(w_center | w_context)
P(w_center | w_context) = softmax(activation(w_context))
d.代码示例
---
class CBOWTrainer:
"""CBOW模型训练器"""
def __init__(self, model: CBOWModel, learning_rate: float = 0.025):
"""
初始化训练器
Args:
model: CBOW模型
learning_rate: 学习率
"""
self.model = model
self.learning_rate = learning_rate
self.optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
self.criterion = nn.CrossEntropyLoss()
# 训练统计
self.training_losses = []
self.training_accuracies = []
def prepare_training_data(self, corpus: List[List[str]],
word_to_idx: Dict[str, int],
window_size: int = 5) -> List[Tuple[List[int], int]]:
"""
准备训练数据
Args:
corpus: 分好词的语料
word_to_idx: 词汇到索引的映射
window_size: 上下文窗口大小
Returns:
训练数据列表 [(上下文词汇索引, 中心词索引), ...]
"""
training_data = []
half_window = window_size // 2
for sentence in corpus:
sentence_length = len(sentence)
for i in range(sentence_length):
# 跳过句子边界附近的词
if i < half_window or i >= sentence_length - half_window:
continue
# 获取中心词
center_word = sentence[i]
if center_word not in word_to_idx:
continue
center_idx = word_to_idx[center_word]
# 获取上下文词汇
context_words = []
for j in range(i - half_window, i + half_window + 1):
if j != i and 0 <= j < sentence_length:
context_word = sentence[j]
if context_word in word_to_idx:
context_words.append(word_to_idx[context_word])
# 确保上下文窗口完整
if len(context_words) == window_size - 1: # 减去中心词
training_data.append((context_words, center_idx))
return training_data
def train_epoch(self, training_data: List[Tuple[List[int], int]],
batch_size: int = 32) -> Dict[str, float]:
"""
训练一个epoch
Args:
training_data: 训练数据
batch_size: 批大小
Returns:
训练统计信息
"""
self.model.train()
total_loss = 0.0
correct_predictions = 0
total_predictions = 0
# 随机打乱数据
np.random.shuffle(training_data)
# 分批训练
for i in range(0, len(training_data), batch_size):
batch = training_data[i:i + batch_size]
# 准备批次数据
context_list = []
target_list = []
for context, target in batch:
context_list.append(context)
target_list.append(target)
# 转换为张量
context_tensor = torch.tensor(context_list, dtype=torch.long)
target_tensor = torch.tensor(target_list, dtype=torch.long)
# 前向传播
self.optimizer.zero_grad()
output = self.model(context_tensor)
loss = self.criterion(output, target_tensor)
# 反向传播
loss.backward()
self.optimizer.step()
# 统计
total_loss += loss.item()
# 计算准确率
_, predicted = torch.max(output, 1)
correct_predictions += (predicted == target_tensor).sum().item()
total_predictions += target_tensor.size(0)
avg_loss = total_loss / len(training_data)
accuracy = correct_predictions / total_predictions
self.training_losses.append(avg_loss)
self.training_accuracies.append(accuracy)
return {
'loss': avg_loss,
'accuracy': accuracy,
'total_loss': total_loss,
'correct_predictions': correct_predictions,
'total_predictions': total_predictions
}
def train(self, training_data: List[Tuple[List[int], int]],
epochs: int = 10, batch_size: int = 32,
validation_data: Optional[List[Tuple[List[int], int]]] = None) -> Dict[str, List[float]]:
"""
完整训练过程
Args:
training_data: 训练数据
epochs: 训练轮数
batch_size: 批大小
validation_data: 验证数据（可选）
Returns:
训练历史
"""
print(f"开始训练CBOW模型...")
print(f"训练数据量: {len(training_data)}")
print(f"训练轮数: {epochs}")
print(f"批大小: {batch_size}")
training_history = {
'train_losses': [],
'train_accuracies': [],
'val_losses': [],
'val_accuracies': []
}
for epoch in range(epochs):
print(f"\nEpoch {epoch + 1}/{epochs}")
# 训练
train_stats = self.train_epoch(training_data, batch_size)
training_history['train_losses'].append(train_stats['loss'])
training_history['train_accuracies'].append(train_stats['accuracy'])
print(f" 训练损失: {train_stats['loss']:.4f}")
print(f" 训练准确率: {train_stats['accuracy']:.4f}")
# 验证
if validation_data:
val_stats = self.validate_epoch(validation_data, batch_size)
training_history['val_losses'].append(val_stats['loss'])
training_history['val_accuracies'].append(val_stats['accuracy'])
print(f" 验证损失: {val_stats['loss']:.4f}")
print(f" 验证准确率: {val_stats['accuracy']:.4f}")
print(f"\n训练完成!")
return training_history
def validate_epoch(self, validation_data: List[Tuple[List[int], int]],
batch_size: int = 32) -> Dict[str, float]:
"""验证一个epoch"""
self.model.eval()
total_loss = 0.0
correct_predictions = 0
total_predictions = 0
with torch.no_grad():
for i in range(0, len(validation_data), batch_size):
batch = validation_data[i:i + batch_size]
context_list = []
target_list = []
for context, target in batch:
context_list.append(context)
target_list.append(target)
context_tensor = torch.tensor(context_list, dtype=torch.long)
target_tensor = torch.tensor(target_list, dtype=torch.long)
output = self.model(context_tensor)
loss = self.criterion(output, target_tensor)
total_loss += loss.item()
_, predicted = torch.max(output, 1)
correct_predictions += (predicted == target_tensor).sum().item()
total_predictions += target_tensor.size(0)
avg_loss = total_loss / len(validation_data)
accuracy = correct_predictions / total_predictions
return {
'loss': avg_loss,
'accuracy': accuracy
}
def plot_training_history(self, training_history: Dict[str, List[float]]):
"""绘制训练历史"""
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
# 损失曲线
ax1.plot(training_history['train_losses'], label='训练损失', color='blue')
if training_history['val_losses']:
ax1.plot(training_history['val_losses'], label='验证损失', color='red')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss')
ax1.set_title('训练损失曲线')
ax1.legend()
ax1.grid(True, alpha=0.3)
# 准确率曲线
ax2.plot(training_history['train_accuracies'], label='训练准确率', color='blue')
if training_history['val_accuracies']:
ax2.plot(training_history['val_accuracies'], label='验证准确率', color='red')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Accuracy')
ax2.set_title('训练准确率曲线')
ax2.legend()
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 使用示例
print("=== CBOW模型训练演示 ===")
# 示例语料
sample_corpus = [
["自然", "语言", "处理", "是", "人工智能", "的", "重要", "分支"],
["深度", "学习", "在", "自然", "语言", "处理", "中", "应用", "广泛"],
["我们", "需要", "更多", "的", "数据", "来", "训练", "模型"],
["词向量", "技术", "能够", "捕捉", "词汇", "的", "语义", "信息"],
["神经", "网络", "模型", "表现", "优异", "在", "NLP", "任务", "中"]
]
# 构建词汇表
all_words = [word for sentence in sample_corpus for word in sentence]
word_counts = Counter(all_words)
vocabulary = [word for word, count in word_counts.most_common(20)] # 取前20个词
word_to_idx = {word: idx for idx, word in enumerate(vocabulary)}
idx_to_word = {idx: word for word, idx in word_to_idx.items()}
print(f"词汇表大小: {len(vocabulary)}")
print(f"词汇表示例: {vocabulary[:10]}")
# 创建和训练模型
model = CBOWModel(len(vocabulary), embedding_dim=50, context_size=2)
trainer = CBOWTrainer(model, learning_rate=0.01)
# 准备训练数据
training_data = trainer.prepare_training_data(sample_corpus, word_to_idx, window_size=5)
print(f"训练数据量: {len(training_data)}")
# 训练模型
if len(training_data) > 0:
training_history = trainer.train(training_data, epochs=50, batch_size=4)
trainer.plot_training_history(training_history)
# 查看词向量
print(f"\n=== 词向量质量检查 ===")
embeddings = model.get_embeddings()
print(f"词向量矩阵形状: {embeddings.shape}")
print(f"词向量范数: {embeddings.norm(dim=1).mean():.4f}")
# 查找相似词
if len(vocabulary) > 5:
test_word_idx = 0
similar_words = model.find_most_similar(test_word_idx, top_k=3)
test_word = idx_to_word[test_word_idx]
print(f"\n与'{test_word}'最相似的词:")
for sim_idx, similarity in similar_words:
if sim_idx < len(vocabulary):
sim_word = idx_to_word[sim_idx]
print(f" {sim_word}: {similarity:.4f}")
---
c.窗口策略
a.功能说明
上下文窗口的选择对CBOW模型的性能有重要影响。
b.窗口策略
a.固定窗口：使用固定的窗口大小（如5个词）
b.动态窗口：根据词频调整窗口大小
c.加权窗口：根据距离给予不同权重
d.不对称窗口：左右窗口大小不同
c.窗口大小影响
a.小窗口：捕捉局部语法关系
b.大窗口：捕捉全局语义关系
c.过大窗口：增加计算复杂度，可能引入噪声
d.过小窗口：语义信息不足
d.代码示例
---
class ContextWindowStrategies:
"""上下文窗口策略实现"""
@staticmethod
def fixed_window(sentence: List[str], center_idx: int, window_size: int) -> List[Tuple[str, int]]:
"""
固定窗口策略
Args:
sentence: 句子词汇列表
center_idx: 中心词索引
window_size: 窗口大小（单侧）
Returns:
上下文词汇及其位置
"""
contexts = []
sentence_len = len(sentence)
for i in range(max(0, center_idx - window_size),
min(sentence_len, center_idx + window_size + 1)):
if i != center_idx:
contexts.append((sentence[i], i - center_idx))
return contexts
@staticmethod
def dynamic_window(sentence: List[str], center_idx: int,
base_window: int = 3, max_window: int = 10) -> List[Tuple[str, int]]:
"""
动态窗口策略
Args:
sentence: 句子词汇列表
center_idx: 中心词索引
base_window: 基础窗口大小
max_window: 最大窗口大小
Returns:
上下文词汇及其位置
"""
# 简化的动态窗口：随机选择窗口大小
import random
actual_window = random.randint(base_window, max_window)
return ContextWindowStrategies.fixed_window(sentence, center_idx, actual_window)
@staticmethod
def weighted_window(sentence: List[str], center_idx: int,
window_size: int = 5) -> List[Tuple[str, int, float]]:
"""
加权窗口策略
Args:
sentence: 句子词汇列表
center_idx: 中心词索引
window_size: 窗口大小
Returns:
上下文词汇、位置和权重
"""
contexts = []
sentence_len = len(sentence)
for i in range(max(0, center_idx - window_size),
min(sentence_len, center_idx + window_size + 1)):
if i != center_idx:
distance = abs(i - center_idx)
weight = 1.0 / (distance + 1) # 距离越近权重越大
contexts.append((sentence[i], i - center_idx, weight))
return contexts
@staticmethod
def asymmetric_window(sentence: List[str], center_idx: int,
left_window: int = 3, right_window: int = 5) -> List[Tuple[str, int]]:
"""
不对称窗口策略
Args:
sentence: 句子词汇列表
center_idx: 中心词索引
left_window: 左侧窗口大小
right_window: 右侧窗口大小
Returns:
上下文词汇及其位置
"""
contexts = []
sentence_len = len(sentence)
# 左侧窗口
for i in range(max(0, center_idx - left_window), center_idx):
contexts.append((sentence[i], i - center_idx))
# 右侧窗口
for i in range(center_idx + 1, min(sentence_len, center_idx + right_window + 1)):
contexts.append((sentence[i], i - center_idx))
return contexts
@staticmethod
def compare_strategies(sentence: List[str], center_idx: int):
"""比较不同窗口策略"""
print(f"句子: {' '.join(sentence)}")
print(f"中心词: {sentence[center_idx]} (索引: {center_idx})")
print()
# 固定窗口
fixed_contexts = ContextWindowStrategies.fixed_window(sentence, center_idx, 3)
print(f"固定窗口 (窗口大小=3):")
for word, distance in fixed_contexts:
print(f" {word} (距离: {distance})")
print()
# 加权窗口
weighted_contexts = ContextWindowStrategies.weighted_window(sentence, center_idx, 3)
print(f"加权窗口 (窗口大小=3):")
for word, distance, weight in weighted_contexts:
print(f" {word} (距离: {distance}, 权重: {weight:.2f})")
print()
# 不对称窗口
asymmetric_contexts = ContextWindowStrategies.asymmetric_window(sentence, center_idx, 2, 4)
print(f"不对称窗口 (左=2, 右=4):")
for word, distance in asymmetric_contexts:
print(f" {word} (距离: {distance})")
# 使用示例
print("=== 上下文窗口策略演示 ===")
sample_sentence = ["深度", "学习", "在", "自然", "语言", "处理", "中", "表现", "出色"]
center_word_idx = 4 # "语言"
ContextWindowStrategies.compare_strategies(sample_sentence, center_word_idx)
# 分析窗口大小的影响
print(f"\n=== 窗口大小影响分析 ===")
window_sizes = [1, 2, 3, 5, 7]
for window_size in window_sizes:
contexts = ContextWindowStrategies.fixed_window(sample_sentence, center_word_idx, window_size)
print(f"窗口大小 {window_size}: 上下文词汇数 {len(contexts)}")
print(f" 上下文: {[word for word, _ in contexts]}")
---
03.Skip-gram模型
a.架构设计
a.功能说明
Skip-gram模型与CBOW相反，使用中心词预测上下文词汇。这种架构特别适合处理低频词和学习语义关系。
b.架构设计
a.输入层：中心词的One-Hot编码
b.嵌入层：将中心词映射为向量
c.输出层：预测每个上下文位置的概率分布
c.关键特点
a.输入：单个中心词
b.输出：多个上下文词的概率分布
c.训练：最大化上下文词的概率
d.优势：对低频词和罕见词效果好
b.代码示例
---
class SkipGramModel(nn.Module):
"""Skip-gram模型实现"""
def __init__(self, vocab_size: int, embedding_dim: int):
"""
初始化Skip-gram模型
Args:
vocab_size: 词汇表大小
embedding_dim: 词向量维度
"""
super(SkipGramModel, self).__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
# 输入嵌入层：中心词到向量的映射
self.input_embeddings = nn.Embedding(vocab_size, embedding_dim)
# 输出嵌入层：上下文词到向量的映射（用于负采样）
self.output_embeddings = nn.Embedding(vocab_size, embedding_dim)
# 初始化权重
self._init_weights()
def _init_weights(self):
"""初始化模型权重"""
nn.init.uniform_(self.input_embeddings.weight, -0.1/embedding_dim, 0.1/embedding_dim)
nn.init.uniform_(self.output_embeddings.weight, -0.1/embedding_dim, 0.1/embedding_dim)
def forward(self, center_ids: torch.Tensor, context_ids: torch.Tensor) -> torch.Tensor:
"""
前向传播（使用点积计算相似度）
Args:
center_ids: 中心词ID [batch_size]
context_ids: 上下文词ID [batch_size]
Returns:
相似度分数 [batch_size]
"""
# 获取中心词向量 [batch_size, embedding_dim]
center_vectors = self.input_embeddings(center_ids)
# 获取上下文词向量 [batch_size, embedding_dim]
context_vectors = self.output_embeddings(context_ids)
# 计算点积相似度 [batch_size]
scores = torch.sum(center_vectors * context_vectors, dim=1)
return scores
def forward_negative_sampling(self, center_ids: torch.Tensor,
context_ids: torch.Tensor,
negative_ids: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
"""
负采样前向传播
Args:
center_ids: 中心词ID [batch_size]
context_ids: 正样本上下文词ID [batch_size]
negative_ids: 负样本词ID [batch_size, num_negative]
Returns:
正样本分数和负样本分数
"""
batch_size = center_ids.size(0)
num_negative = negative_ids.size(1) if negative_ids.dim() > 1 else 1
# 获取中心词向量
center_vectors = self.input_embeddings(center_ids) # [batch_size, embedding_dim]
# 获取正样本上下文向量
context_vectors = self.output_embeddings(context_ids) # [batch_size, embedding_dim]
# 计算正样本分数
positive_scores = torch.sum(center_vectors * context_vectors, dim=1) # [batch_size]
# 获取负样本向量并计算分数
if negative_ids.dim() == 1:
negative_ids = negative_ids.unsqueeze(1) # [batch_size, 1]
# 重构中心向量以进行广播计算
center_vectors_expanded = center_vectors.unsqueeze(1).expand(-1, num_negative, -1) # [batch_size, num_negative, embedding_dim]
negative_vectors = self.output_embeddings(negative_ids) # [batch_size, num_negative, embedding_dim]
# 计算负样本分数
negative_scores = torch.sum(center_vectors_expanded * negative_vectors, dim=2) # [batch_size, num_negative]
return positive_scores, negative_scores
def get_word_vector(self, word_id: int) -> torch.Tensor:
"""获取指定词汇的向量"""
return self.input_embeddings.weight[word_id]
def get_all_embeddings(self) -> torch.Tensor:
"""获取所有词向量"""
return self.input_embeddings.weight.data
def predict_context_probabilities(self, center_id: int) -> torch.Tensor:
"""预测给定中心词的上下文概率分布"""
center_vector = self.get_word_vector(center_id)
all_context_vectors = self.output_embeddings.weight
# 计算与所有词汇的点积
scores = torch.matmul(all_context_vectors, center_vector)
# 应用softmax得到概率分布
probabilities = F.softmax(scores, dim=0)
return probabilities
# 使用示例
print("=== Skip-gram模型架构演示 ===")
# 创建Skip-gram模型
vocab_size = 1000
embedding_dim = 100
skipgram_model = SkipGramModel(vocab_size, embedding_dim)
print(f"Skip-gram模型参数:")
print(f" 词汇表大小: {skipgram_model.vocab_size}")
print(f" 词向量维度: {skipgram_model.embedding_dim}")
# 模拟输入数据
batch_size = 8
center_ids = torch.randint(0, vocab_size, (batch_size,))
context_ids = torch.randint(0, vocab_size, (batch_size,))
negative_ids = torch.randint(0, vocab_size, (batch_size, 5)) # 5个负样本
# 前向传播
positive_scores, negative_scores = skipgram_model.forward_negative_sampling(
center_ids, context_ids, negative_ids
)
print(f"\n输入形状:")
print(f" 中心词ID: {center_ids.shape}")
print(f" 上下文词ID: {context_ids.shape}")
print(f" 负样本ID: {negative_ids.shape}")
print(f"\n输出形状:")
print(f" 正样本分数: {positive_scores.shape}")
print(f" 负样本分数: {negative_scores.shape}")
# 演示上下文概率预测
test_center_id = 42
context_probs = skipgram_model.predict_context_probabilities(test_center_id)
print(f"\n中心词 {test_center_id} 的上下文概率分布:")
print(f" 概率分布形状: {context_probs.shape}")
print(f" 最大概率: {context_probs.max().item():.4f}")
print(f" 最可能上下文词索引: {context_probs.argmax().item()}")
---
b.训练过程
a.功能说明
Skip-gram训练需要处理大量的负样本，负采样技术是关键优化手段。
b.训练步骤
a.采样中心词和上下文词对
b.生成负样本
c.计算正负样本的损失
d.反向传播更新参数
e.重复直到收敛
c.优化技巧
a.负采样：减少计算复杂度
b.采样频率调整：平衡常见词和罕见词
c.学习率衰减：动态调整学习率
d.梯度裁剪：防止梯度爆炸
d.代码示例
---
class SkipGramTrainer:
"""Skip-gram模型训练器"""
def __init__(self, model: SkipGramModel, learning_rate: float = 0.025):
"""
初始化训练器
Args:
model: Skip-gram模型
learning_rate: 学习率
"""
self.model = model
self.learning_rate = learning_rate
self.optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# 负采样相关
self.word_frequencies = None
self.sampling_table = None
self.num_negative = 5
def build_sampling_table(self, word_counts: Dict[str, int], power: float = 0.75):
"""
构建负采样表
Args:
word_counts: 词频统计
power: 采样频率调整参数
"""
total_count = sum(word_counts.values())
word_probs = {word: (count / total_count) ** power for word, count in word_counts.items()}
# 归一化概率
total_prob = sum(word_probs.values())
word_probs = {word: prob / total_prob for word, prob in word_probs.items()}
self.word_frequencies = word_probs
print(f"构建采样表完成，词汇数量: {len(word_probs)}")
def sample_negative_words(self, target_word: int, num_negative: int,
word_to_idx: Dict[str, int]) -> List[int]:
"""
采样负样本词
Args:
target_word: 目标词ID
num_negative: 负样本数量
word_to_idx: 词汇到索引的映射
Returns:
负样本词ID列表
"""
if self.word_frequencies is None:
# 如果没有采样表，使用均匀采样
vocab_size = len(word_to_idx)
negative_words = []
for _ in range(num_negative):
neg_word = np.random.randint(0, vocab_size)
while neg_word == target_word:
neg_word = np.random.randint(0, vocab_size)
negative_words.append(neg_word)
return negative_words
# 使用采样表进行采样
words = list(word_to_idx.keys())
probs = [self.word_frequencies.get(word, 0) for word in words]
total_prob = sum(probs)
if total_prob > 0:
probs = [p / total_prob for p in probs]
negative_words = []
for _ in range(num_negative):
neg_word = np.random.choice(len(words), p=probs)
while neg_word == target_word:
neg_word = np.random.choice(len(words), p=probs)
negative_words.append(neg_word)
return negative_words
else:
# 回退到均匀采样
vocab_size = len(word_to_idx)
return [np.random.randint(0, vocab_size) for _ in range(num_negative)]
def prepare_training_data(self, corpus: List[List[str]],
word_to_idx: Dict[str, int],
window_size: int = 5,
num_negative: int = 5) -> List[Tuple[int, int, List[int]]]:
"""
准备Skip-gram训练数据
Args:
corpus: 分好词的语料
word_to_idx: 词汇到索引的映射
window_size: 上下文窗口大小
num_negative: 负样本数量
Returns:
训练数据列表 [(中心词ID, 上下文词ID, 负样本ID列表), ...]
"""
self.num_negative = num_negative
training_data = []
half_window = window_size // 2
print("准备Skip-gram训练数据...")
for sentence_idx, sentence in enumerate(corpus):
if sentence_idx % 1000 == 0:
print(f"处理句子: {sentence_idx}/{len(corpus)}")
sentence_length = len(sentence)
for i in range(sentence_length):
center_word = sentence[i]
if center_word not in word_to_idx:
continue
center_idx = word_to_idx[center_word]
# 遍历上下文窗口
for j in range(max(0, i - half_window),
min(sentence_length, i + half_window + 1)):
if j == i:
continue
context_word = sentence[j]
if context_word not in word_to_idx:
continue
context_idx = word_to_idx[context_word]
# 采样负样本
negative_ids = self.sample_negative_words(
center_idx, num_negative, word_to_idx
)
training_data.append((center_idx, context_idx, negative_ids))
print(f"训练数据准备完成，共 {len(training_data)} 个样本")
return training_data
def train_batch(self, batch_data: List[Tuple[int, int, List[int]]]) -> Dict[str, float]:
"""
训练一个批次
Args:
batch_data: 批次训练数据
Returns:
训练统计信息
"""
self.model.train()
self.optimizer.zero_grad()
total_loss = 0.0
correct_predictions = 0
total_predictions = 0
for center_idx, context_idx, negative_ids in batch_data:
# 转换为张量
center_tensor = torch.tensor([center_idx], dtype=torch.long)
context_tensor = torch.tensor([context_idx], dtype=torch.long)
negative_tensor = torch.tensor(negative_ids, dtype=torch.long).unsqueeze(0)
# 前向传播
positive_scores, negative_scores = self.model.forward_negative_sampling(
center_tensor, context_tensor, negative_tensor
)
# 计算损失（使用sigmoid交叉熵）
# 正样本损失：希望分数接近1
positive_loss = -F.logsigmoid(positive_scores).mean()
# 负样本损失：希望分数接近0
negative_loss = -F.logsigmoid(-negative_scores).mean()
batch_loss = positive_loss + negative_loss
total_loss += batch_loss.item()
# 计算准确率（简化版）
correct_predictions += (positive_scores > 0).sum().item()
correct_predictions += (negative_scores < 0).sum().item()
total_predictions += 1 + len(negative_ids)
# 反向传播
batch_loss.backward()
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
# 更新参数
self.optimizer.step()
avg_loss = total_loss / len(batch_data)
accuracy = correct_predictions / total_predictions
return {
'loss': avg_loss,
'accuracy': accuracy,
'total_loss': total_loss
}
def train(self, training_data: List[Tuple[int, int, List[int]]],
epochs: int = 10, batch_size: int = 64) -> Dict[str, List[float]]:
"""
完整训练过程
Args:
training_data: 训练数据
epochs: 训练轮数
batch_size: 批大小
Returns:
训练历史
"""
print(f"开始训练Skip-gram模型...")
print(f"训练数据量: {len(training_data)}")
print(f"训练轮数: {epochs}")
print(f"批大小: {batch_size}")
training_history = {
'losses': [],
'accuracies': []
}
for epoch in range(epochs):
print(f"\nEpoch {epoch + 1}/{epochs}")
# 随机打乱数据
np.random.shuffle(training_data)
epoch_loss = 0.0
epoch_accuracy = 0.0
num_batches = 0
# 分批训练
for i in range(0, len(training_data), batch_size):
batch = training_data[i:i + batch_size]
batch_stats = self.train_batch(batch)
epoch_loss += batch_stats['loss']
epoch_accuracy += batch_stats['accuracy']
num_batches += 1
avg_loss = epoch_loss / num_batches
avg_accuracy = epoch_accuracy / num_batches
training_history['losses'].append(avg_loss)
training_history['accuracies'].append(avg_accuracy)
print(f" 平均损失: {avg_loss:.4f}")
print(f" 平均准确率: {avg_accuracy:.4f}")
# 学习率衰减
if epoch > 0 and epoch % 5 == 0:
for param_group in self.optimizer.param_groups:
param_group['lr'] *= 0.9
print(f" 学习率衰减至: {self.optimizer.param_groups[0]['lr']:.6f}")
print(f"\n训练完成!")
return training_history
def evaluate_word_analogies(self, word_to_idx: Dict[str, int],
idx_to_word: Dict[int, str],
analogies: List[Tuple[str, str, str, str]]) -> Dict[str, float]:
"""
评估词类比任务
Args:
word_to_idx: 词汇到索引的映射
idx_to_word: 索引到词汇的映射
analogies: 类比任务列表
Returns:
评估结果
"""
correct_predictions = 0
total_predictions = 0
print("评估词类比任务...")
for word1, word2, word3, expected_word4 in analogies:
if all(word in word_to_idx for word in [word1, word2, word3, expected_word4]):
# 获取词向量
vec1 = self.model.get_word_vector(word_to_idx[word1])
vec2 = self.model.get_word_vector(word_to_idx[word2])
vec3 = self.model.get_word_vector(word_to_idx[word3])
# 计算类比向量
analogy_vector = vec2 - vec1 + vec3
# 查找最相似的词
max_similarity = -float('inf')
best_word = None
for word, idx in word_to_idx.items():
if word not in [word1, word2, word3]:
word_vec = self.model.get_word_vector(idx)
similarity = torch.cosine_similarity(
analogy_vector.unsqueeze(0),
word_vec.unsqueeze(0)
).item()
if similarity > max_similarity:
max_similarity = similarity
best_word = word
if best_word == expected_word4:
correct_predictions += 1
total_predictions += 1
print(f" {word1}:{word2} :: {word3}:{best_word} "
f"(期望: {expected_word4}, {'✓' if best_word == expected_word4 else '✗'})")
accuracy = correct_predictions / total_predictions if total_predictions > 0 else 0
return {
'accuracy': accuracy,
'correct_predictions': correct_predictions,
'total_predictions': total_predictions
}
# 使用示例
print("=== Skip-gram模型训练演示 ===")
# 构建词汇表和词频统计
word_counts = Counter(all_words)
vocabulary = [word for word, count in word_counts.most_common(15)] # 取前15个词
word_to_idx = {word: idx for idx, word in enumerate(vocabulary)}
idx_to_word = {idx: word for word, idx in word_to_idx.items()}
# 创建和训练Skip-gram模型
skipgram_model = SkipGramModel(len(vocabulary), embedding_dim=50)
skipgram_trainer = SkipGramTrainer(skipgram_model, learning_rate=0.01)
# 构建采样表
word_count_dict = {word: word_counts[word] for word in vocabulary}
skipgram_trainer.build_sampling_table(word_count_dict, power=0.75)
# 准备训练数据
training_data = skipgram_trainer.prepare_training_data(
sample_corpus, word_to_idx, window_size=3, num_negative=3
)
# 训练模型
if len(training_data) > 0:
training_history = skipgram_trainer.train(training_data, epochs=30, batch_size=8)
# 绘制训练历史
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
ax1.plot(training_history['losses'], color='blue')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss')
ax1.set_title('Skip-gram训练损失')
ax1.grid(True, alpha=0.3)
ax2.plot(training_history['accuracies'], color='red')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Accuracy')
ax2.set_title('Skip-gram训练准确率')
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 评估词类比任务
print(f"\n=== 词类比评估 ===")
test_analogies = [
('深度', '学习', '自然', '语言'), # 可能不准确，仅用于演示
('模型', '训练', '数据', '处理') # 可能不准确，仅用于演示
]
analogy_results = skipgram_trainer.evaluate_word_analogies(
word_to_idx, idx_to_word, test_analogies
)
print(f"\n词类比任务准确率: {analogy_results['accuracy']:.4f}")
---
c.负采样技术
a.功能说明
负采样是Skip-gram训练的关键优化技术，通过减少计算复杂度来提高训练效率。
b.负采样原理
a.对每个正样本(中心词,上下文词)，采样k个负样本
b.只计算正样本和负样本的损失，忽略其他词汇
c.将多分类问题转化为二分类问题
d.大大减少计算量，特别是对于大词汇表
c.采样策略
a.均匀采样：每个词被选中的概率相同
b.频率采样：按词频的α次幂采样
c.噪声对比估计：优化采样分布
d.代码示例
---
class NegativeSamplingAnalyzer:
"""负采样技术分析器"""
def __init__(self, word_counts: Dict[str, int]):
"""
初始化分析器
Args:
word_counts: 词频统计
"""
self.word_counts = word_counts
self.total_words = sum(word_counts.values())
self.vocab_size = len(word_counts)
def uniform_sampling_probabilities(self) -> Dict[str, float]:
"""均匀采样概率"""
uniform_prob = 1.0 / self.vocab_size
return {word: uniform_prob for word in self.word_counts.keys()}
def frequency_sampling_probabilities(self, power: float = 0.75) -> Dict[str, float]:
"""
频率采样概率
Args:
power: 采样频率调整参数
"""
freq_probs = {}
for word, count in self.word_counts.items():
# 词频的power次幂
adjusted_freq = count ** power
freq_probs[word] = adjusted_freq
# 归一化
total_freq = sum(freq_probs.values())
for word in freq_probs:
freq_probs[word] /= total_freq
return freq_probs
def analyze_sampling_distribution(self, power: float = 0.75, top_k: int = 10):
"""分析采样分布"""
print(f"=== 负采样分布分析 ===")
print(f"词汇表大小: {self.vocab_size}")
print(f"总词数: {self.total_words}")
# 获取不同采样策略的概率
uniform_probs = self.uniform_sampling_probabilities()
frequency_probs = self.frequency_sampling_probabilities(power)
# 按词频排序
sorted_words = sorted(self.word_counts.items(), key=lambda x: x[1], reverse=True)
print(f"\n采样分布对比 (Top {top_k}):")
print(f"{'词汇':<10} {'词频':<8} {'均匀概率':<12} {'频率概率':<12} {'频率比':<10}")
print("-" * 60)
for word, count in sorted_words[:top_k]:
uniform_prob = uniform_probs[word]
frequency_prob = frequency_probs[word]
frequency_ratio = frequency_prob / uniform_prob
print(f"{word:<10} {count:<8} {uniform_prob:<12.6f} {frequency_prob:<12.6f} {frequency_ratio:<10.2f}")
# 分析采样效果
print(f"\n采样效果分析:")
high_freq_words = [word for word, count in sorted_words[:5]]
low_freq_words = [word for word, count in sorted_words[-5:]]
high_freq_uniform = sum(uniform_probs[word] for word in high_freq_words)
high_freq_frequency = sum(frequency_probs[word] for word in high_freq_words)
low_freq_uniform = sum(uniform_probs[word] for word in low_freq_words)
low_freq_frequency = sum(frequency_probs[word] for word in low_freq_words)
print(f"高频词 (Top 5):")
print(f" 均匀采样概率: {high_freq_uniform:.6f}")
print(f" 频率采样概率: {high_freq_frequency:.6f}")
print(f" 概率放大倍数: {high_freq_frequency/high_freq_uniform:.2f}")
print(f"低频词 (Bottom 5):")
print(f" 均匀采样概率: {low_freq_uniform:.6f}")
print(f" 频率采样概率: {low_freq_frequency:.6f}")
print(f" 概率缩小倍数: {low_freq_uniform/low_freq_frequency:.2f}")
return uniform_probs, frequency_probs
def simulate_negative_sampling(self, center_word: str, num_negative: int = 5,
sampling_strategy: str = 'frequency',
power: float = 0.75) -> List[str]:
"""
模拟负采样过程
Args:
center_word: 中心词
num_negative: 负样本数量
sampling_strategy: 采样策略
power: 频率调整参数
Returns:
采样得到的负样本词汇列表
"""
if sampling_strategy == 'uniform':
probs = list(self.uniform_sampling_probabilities().values())
elif sampling_strategy == 'frequency':
probs = list(self.frequency_sampling_probabilities(power).values())
else:
raise ValueError(f"不支持的采样策略: {sampling_strategy}")
words = list(self.word_counts.keys())
center_idx = words.index(center_word)
negative_samples = []
for _ in range(num_negative):
# 采样
sampled_idx = np.random.choice(len(words), p=probs)
# 确保不是中心词
while sampled_idx == center_idx:
sampled_idx = np.random.choice(len(words), p=probs)
negative_samples.append(words[sampled_idx])
return negative_samples
def compare_sampling_strategies(self, center_word: str, num_negative: int = 5,
num_simulations: int = 100):
"""比较不同采样策略"""
print(f"=== 采样策略比较 ===")
print(f"中心词: '{center_word}'")
print(f"负样本数量: {num_negative}")
print(f"模拟次数: {num_simulations}")
# 统计每种策略的采样结果
uniform_counts = Counter()
frequency_counts = Counter()
for _ in range(num_simulations):
# 均匀采样
uniform_samples = self.simulate_negative_sampling(
center_word, num_negative, 'uniform'
)
uniform_counts.update(uniform_samples)
# 频率采样
frequency_samples = self.simulate_negative_sampling(
center_word, num_negative, 'frequency', power=0.75
)
frequency_counts.update(frequency_samples)
print(f"\n采样结果统计 (Top 10):")
print(f"{'词汇':<12} {'均匀采样次数':<12} {'频率采样次数':<12} {'频率比':<10}")
print("-" * 50)
# 获取所有被采样的词汇
all_sampled_words = set(uniform_counts.keys()) | set(frequency_counts.keys())
for word in sorted(all_sampled_words,
key=lambda w: max(uniform_counts[w], frequency_counts[w]),
reverse=True)[:10]:
uniform_count = uniform_counts[word]
frequency_count = frequency_counts[word]
if uniform_count > 0:
frequency_ratio = frequency_count / uniform_count
else:
frequency_ratio = float('inf') if frequency_count > 0 else 0
print(f"{word:<12} {uniform_count:<12} {frequency_count:<12} {frequency_ratio:<10.2f}")
return uniform_counts, frequency_counts
def visualize_sampling_distributions(self, power: float = 0.75):
"""可视化采样分布"""
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
# 1. 词频分布
sorted_words = sorted(self.word_counts.items(), key=lambda x: x[1], reverse=True)
words = [word for word, _ in sorted_words[:20]]
counts = [count for _, count in sorted_words[:20]]
ax1.bar(range(len(words)), counts)
ax1.set_xlabel('词汇排名')
ax1.set_ylabel('词频')
ax1.set_title('词频分布 (Top 20)')
ax1.set_xticks(range(len(words)))
ax1.set_xticklabels(words, rotation=45, ha='right')
# 2. 均匀采样分布
uniform_probs = self.uniform_sampling_probabilities()
uniform_values = [uniform_probs[word] for word in words]
ax2.bar(range(len(words)), uniform_values)
ax2.set_xlabel('词汇排名')
ax2.set_ylabel('采样概率')
ax2.set_title('均匀采样分布')
ax2.set_xticks(range(len(words)))
ax2.set_xticklabels(words, rotation=45, ha='right')
# 3. 频率采样分布
frequency_probs = self.frequency_sampling_probabilities(power)
frequency_values = [frequency_probs[word] for word in words]
ax3.bar(range(len(words)), frequency_values)
ax3.set_xlabel('词汇排名')
ax3.set_ylabel('采样概率')
ax3.set_title(f'频率采样分布 (power={power})')
ax3.set_xticks(range(len(words)))
ax3.set_xticklabels(words, rotation=45, ha='right')
# 4. 采样概率对比
ax4.scatter(uniform_values, frequency_values, alpha=0.6)
ax4.set_xlabel('均匀采样概率')
ax4.set_ylabel('频率采样概率')
ax4.set_title('采样概率对比')
# 添加对角线
max_prob = max(max(uniform_values), max(frequency_values))
ax4.plot([0, max_prob], [0, max_prob], 'r--', alpha=0.8, label='相等线')
ax4.legend()
plt.tight_layout()
plt.show()
# 使用示例
print("=== 负采样技术演示 ===")
# 构建词频统计
word_count_dict = {word: count for word, count in word_counts.most_common(20) if count > 1}
if len(word_count_dict) > 0:
# 创建分析器
analyzer = NegativeSamplingAnalyzer(word_count_dict)
# 分析采样分布
uniform_probs, frequency_probs = analyzer.analyze_sampling_distribution(power=0.75, top_k=10)
# 比较采样策略
if len(word_count_dict) > 5:
test_word = list(word_count_dict.keys())[0] # 使用最高频词作为测试词
analyzer.compare_sampling_strategies(test_word, num_negative=3, num_simulations=50)
# 可视化采样分布
analyzer.visualize_sampling_distributions(power=0.75)
---
04.层次Softmax
a.基本原理
a.功能说明
层次Softmax是Word2Vec的另一种优化技术，将传统Softmax的O(|V|)复杂度降低到O(log|V|)。
b.基本思想
a.将词汇表构建成二叉树（霍夫曼树）
b.每个词汇对应树的一个叶子节点
c.预测词的概率等于从根到该叶子节点路径上的概率乘积
d.每个内部节点都是一个二分类器
c.数学原理
P(w|context) = ∏[n=1 to L(w)] P(d_n|context, n)
其中d_n是路径上第n个节点的方向（左/右）
d.代码示例
---
class HuffmanNode:
"""霍夫曼树节点"""
def __init__(self, word: str = None, frequency: int = 0):
self.word = word # 词汇（仅叶子节点有）
self.frequency = frequency # 词频
self.left = None # 左子节点
self.right = None # 右子节点
self.is_leaf = word is not None
self.index = None # 节点索引（用于内部节点）
self.code = [] # 霍夫曼编码
self.path = [] # 从根到该节点的路径
class HuffmanTree:
"""霍夫曼树构建器"""
def __init__(self, word_counts: Dict[str, int]):
"""
初始化霍夫曼树
Args:
word_counts: 词频统计
"""
self.word_counts = word_counts
self.root = None
self.word_to_code = {}
self.word_to_path = {}
self.internal_nodes = []
self.node_counter = 0
def build_tree(self):
"""构建霍夫曼树"""
print("构建霍夫曼树...")
# 创建初始节点列表
nodes = []
for word, frequency in self.word_counts.items():
node = HuffmanNode(word, frequency)
nodes.append(node)
# 构建霍夫曼树
while len(nodes) > 1:
# 找到频率最小的两个节点
nodes.sort(key=lambda x: x.frequency)
left = nodes.pop(0)
right = nodes.pop(0)
# 创建父节点
parent = HuffmanNode(frequency=left.frequency + right.frequency)
parent.left = left
parent.right = right
parent.index = self.node_counter
self.node_counter += 1
self.internal_nodes.append(parent)
nodes.append(parent)
self.root = nodes[0]
print(f"霍夫曼树构建完成，内部节点数: {len(self.internal_nodes)}")
# 生成编码和路径
self._generate_codes_and_paths()
print(f"词汇编码生成完成")
def _generate_codes_and_paths(self):
"""生成霍夫曼编码和路径"""
for word in self.word_counts.keys():
code, path = self._get_code_and_path(word)
self.word_to_code[word] = code
self.word_to_path[word] = path
def _get_code_and_path(self, word: str) -> Tuple[List[int], List[int]]:
"""获取指定词汇的霍夫曼编码和路径"""
code = []
path = []
def dfs(node: HuffmanNode, target_word: str, current_code: List[int], current_path: List[int]):
if node.is_leaf and node.word == target_word:
code.extend(current_code)
path.extend(current_path)
return True
if node.left:
current_code.append(0) # 左边为0
current_path.append(node.left.index)
if dfs(node.left, target_word, current_code, current_path):
return True
current_code.pop()
current_path.pop()
if node.right:
current_code.append(1) # 右边为1
current_path.append(node.right.index)
if dfs(node.right, target_word, current_code, current_path):
return True
current_code.pop()
current_path.pop()
return False
dfs(self.root, word, [], [])
return code, path
def analyze_tree_properties(self):
"""分析树的性质"""
if not self.root:
print("请先构建霍夫曼树")
return
print("=== 霍夫曼树性质分析 ===")
print(f"词汇表大小: {len(self.word_counts)}")
print(f"内部节点数: {len(self.internal_nodes)}")
print(f"总节点数: {len(self.word_counts) + len(self.internal_nodes)}")
# 分析编码长度分布
code_lengths = [len(code) for code in self.word_to_code.values()]
avg_code_length = sum(code_lengths) / len(code_lengths)
max_code_length = max(code_lengths)
min_code_length = min(code_lengths)
print(f"\n霍夫曼编码长度:")
print(f" 平均长度: {avg_code_length:.2f}")
print(f" 最大长度: {max_code_length}")
print(f" 最小长度: {min_code_length}")
# 按词频排序分析
sorted_words = sorted(self.word_counts.items(), key=lambda x: x[1], reverse=True)
print(f"\n高频词编码 (Top 10):")
print(f"{'词汇':<10} {'词频':<8} {'编码长度':<10} {'霍夫曼编码':<15}")
print("-" * 50)
for word, freq in sorted_words[:10]:
code = self.word_to_code[word]
code_str = ''.join(map(str, code))
print(f"{word:<10} {freq:<8} {len(code):<10} {code_str:<15}")
# 计算压缩率
traditional_bits = math.ceil(math.log2(len(self.word_counts))) # 传统编码位数
huffman_bits = avg_code_length
compression_ratio = huffman_bits / traditional_bits
print(f"\n压缩效果:")
print(f" 传统编码位数: {traditional_bits}")
print(f" 霍夫曼编码位数: {huffman_bits:.2f}")
print(f" 压缩比: {compression_ratio:.2f}")
return {
'avg_code_length': avg_code_length,
'max_code_length': max_code_length,
'min_code_length': min_code_length,
'compression_ratio': compression_ratio
}
def visualize_tree_structure(self, max_depth: int = 4):
"""可视化树结构（简化版）"""
if not self.root:
print("请先构建霍夫曼树")
return
print(f"=== 霍夫曼树结构可视化 (深度限制: {max_depth}) ===")
def print_node(node: HuffmanNode, level: int = 0, prefix: str = ""):
if level > max_depth:
return
indent = " " * level
if node.is_leaf:
print(f"{indent}{prefix}叶子: {node.word} (频率: {node.frequency})")
else:
print(f"{indent}{prefix}内部节点 {node.index} (频率: {node.frequency})")
if node.left:
print_node(node.left, level + 1, "左-")
if node.right:
print_node(node.right, level + 1, "右-")
print_node(self.root)
def compute_word_probability_hierarchical(self, word: str,
node_probabilities: Dict[int, float]) -> float:
"""
使用层次Softmax计算词概率
Args:
word: 目标词汇
node_probabilities: 内部节点的概率
Returns:
词汇概率
"""
if word not in self.word_to_path:
return 0.0
path = self.word_to_path[word]
code = self.word_to_code[word]
# 计算路径概率
probability = 1.0
for node_idx, bit in zip(path, code):
if node_idx in node_probabilities:
node_prob = node_probabilities[node_idx]
if bit == 0: # 左边
probability *= (1 - node_prob)
else: # 右边
probability *= node_prob
return probability
# 使用示例
print("=== 层次Softmax与霍夫曼树演示 ===")
# 构建示例词频
sample_word_counts = {
'自然': 100, '语言': 95, '处理': 90, '深度': 85, '学习': 80,
'模型': 75, '数据': 70, '训练': 65, '算法': 60, '向量': 55,
'语义': 50, '文本': 45, '分类': 40, '情感': 35, '分析': 30
}
if len(sample_word_counts) > 2:
# 构建霍夫曼树
huffman_tree = HuffmanTree(sample_word_counts)
huffman_tree.build_tree()
# 分析树性质
tree_properties = huffman_tree.analyze_tree_properties()
# 可视化树结构
huffman_tree.visualize_tree_structure(max_depth=3)
# 模拟层次Softmax概率计算
print(f"\n=== 层次Softmax概率计算演示 ===")
# 假设的内部节点概率
sample_node_probs = {i: np.random.random() for i in range(len(huffman_tree.internal_nodes))}
test_words = ['自然', '处理', '模型', '文本']
for word in test_words:
if word in huffman_tree.word_to_code:
path = huffman_tree.word_to_path[word]
code = huffman_tree.word_to_code[word]
prob = huffman_tree.compute_word_probability_hierarchical(word, sample_node_probs)
print(f"\n词汇: {word}")
print(f" 霍夫曼编码: {''.join(map(str, code))}")
print(f" 路径节点: {path}")
print(f" 层次概率: {prob:.6f}")
---
b.技术实现
a.功能说明
层次Softmax将传统Softmax的二叉搜索树结构，每个内部节点都是一个二分类器。
b.实现步骤
a.构建霍夫曼树
b.为每个内部节点学习分类器
c.预测时计算路径概率
d.反向传播更新内部节点参数
c.计算复杂度
a.传统Softmax: O(|V|)
b.层次Softmax: O(log|V|)
c.对于大词汇表，显著提升效率
d.代码示例
---
class HierarchicalSoftmax(nn.Module):
"""层次Softmax实现"""
def __init__(self, vocab_size: int, embedding_dim: int, word_counts: Dict[str, int]):
"""
初始化层次Softmax
Args:
vocab_size: 词汇表大小
embedding_dim: 词向量维度
word_counts: 词频统计
"""
super(HierarchicalSoftmax, self).__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
# 构建霍夫曼树
self.huffman_tree = HuffmanTree(word_counts)
self.huffman_tree.build_tree()
# 内部节点分类器参数
num_internal_nodes = len(self.huffman_tree.internal_nodes)
self.internal_weights = nn.Parameter(
torch.randn(num_internal_nodes, embedding_dim) * 0.1
)
self.internal_biases = nn.Parameter(torch.zeros(num_internal_nodes))
def forward(self, center_vectors: torch.Tensor, target_word_ids: torch.Tensor) -> torch.Tensor:
"""
前向传播
Args:
center_vectors: 中心词向量 [batch_size, embedding_dim]
target_word_ids: 目标词ID [batch_size]
Returns:
损失值
"""
batch_size = center_vectors.size(0)
total_loss = 0.0
for i in range(batch_size):
center_vec = center_vectors[i]
target_word_id = target_word_ids[i].item()
# 获取目标词汇的路径和编码
if target_word_id < len(self.huffman_tree.word_to_code):
target_word = list(self.huffman_tree.word_to_code.keys())[target_word_id]
if target_word in self.huffman_tree.word_to_path:
path = self.huffman_tree.word_to_path[target_word]
code = self.huffman_tree.word_to_code[target_word]
# 计算路径上的损失
path_loss = self._compute_path_loss(center_vec, path, code)
total_loss += path_loss
return total_loss / batch_size
def _compute_path_loss(self, center_vector: torch.Tensor,
path: List[int], code: List[int]) -> torch.Tensor:
"""
计算路径损失
Args:
center_vector: 中心词向量
path: 路径节点索引列表
code: 霍夫曼编码列表
Returns:
路径损失
"""
path_loss = 0.0
for node_idx, direction in zip(path, code):
node_weight = self.internal_weights[node_idx]
node_bias = self.internal_biases[node_idx]
# 计算节点输出
node_output = torch.dot(center_vector, node_weight) + node_bias
node_prob = torch.sigmoid(node_output)
# 计算交叉熵损失
if direction == 1: # 应该走向右边
target_prob = 1.0
else: # 应该走向左边
target_prob = 0.0
# 二元交叉熵损失
loss = -(target_prob * torch.log(node_prob + 1e-10) +
(1 - target_prob) * torch.log(1 - node_prob + 1e-10))
path_loss += loss
return path_loss
def predict_word_probabilities(self, center_vector: torch.Tensor) -> Dict[str, float]:
"""
预测所有词汇的概率
Args:
center_vector: 中心词向量
Returns:
词汇概率字典
"""
word_probabilities = {}
for word in self.huffman_tree.word_to_code.keys():
if word in self.huffman_tree.word_to_path:
path = self.huffman_tree.word_to_path[word]
code = self.huffman_tree.word_to_code[word]
# 计算路径概率
word_prob = 1.0
for node_idx, direction in zip(path, code):
node_weight = self.internal_weights[node_idx]
node_bias = self.internal_biases[node_idx]
node_output = torch.dot(center_vector, node_weight) + node_bias
node_prob = torch.sigmoid(node_output)
if direction == 1:
word_prob *= node_prob
else:
word_prob *= (1 - node_prob)
word_probabilities[word] = word_prob.item()
return word_probabilities
def analyze_computational_complexity(self):
"""分析计算复杂度"""
print("=== 层次Softmax计算复杂度分析 ===")
# 传统Softmax复杂度
traditional_ops = self.vocab_size * self.embedding_dim
print(f"传统Softmax:")
print(f" 词汇表大小: {self.vocab_size}")
print(f" 词向量维度: {self.embedding_dim}")
print(f" 每次前向传播操作数: {traditional_ops:,}")
# 层次Softmax复杂度
avg_code_length = np.mean([len(code) for code in self.huffman_tree.word_to_code.values()])
hierarchical_ops = avg_code_length * self.embedding_dim
print(f"\n层次Softmax:")
print(f" 平均编码长度: {avg_code_length:.2f}")
print(f" 每次前向传播操作数: {hierarchical_ops:.0f}")
# 速度提升
speedup = traditional_ops / hierarchical_ops
print(f"\n性能提升:")
print(f" 加速比: {speedup:.2f}x")
print(f" 时间节省: {(1 - 1/speedup)*100:.1f}%")
return {
'traditional_ops': traditional_ops,
'hierarchical_ops': hierarchical_ops,
'speedup': speedup,
'avg_code_length': avg_code_length
}
# 使用示例
print("=== 层次Softmax实现演示 ===")
if len(sample_word_counts) > 2:
# 创建层次Softmax
hierarchical_softmax = HierarchicalSoftmax(
vocab_size=len(sample_word_counts),
embedding_dim=50,
word_counts=sample_word_counts
)
# 分析计算复杂度
complexity_analysis = hierarchical_softmax.analyze_computational_complexity()
# 模拟前向传播
print(f"\n=== 前向传播演示 ===")
center_vectors = torch.randn(3, 50) # 3个中心词向量
target_word_ids = torch.tensor([0, 1, 2]) # 目标词ID
loss = hierarchical_softmax(center_vectors, target_word_ids)
print(f"批次损失: {loss.item():.6f}")
# 预测词汇概率
print(f"\n=== 词汇概率预测演示 ===")
test_center_vector = torch.randn(50)
word_probs = hierarchical_softmax.predict_word_probabilities(test_center_vector)
print(f"中心词向量形状: {test_center_vector.shape}")
print(f"预测词汇数量: {len(word_probs)}")
# 显示前几个词汇的概率
sorted_probs = sorted(word_probs.items(), key=lambda x: x[1], reverse=True)
print(f"\n概率最高的5个词汇:")
for word, prob in sorted_probs[:5]:
print(f" {word}: {prob:.6f}")
# 检查概率和
total_prob = sum(word_probs.values())
print(f"\n概率总和: {total_prob:.6f} (应接近1.0)")
---
c.性能对比与选择
a.功能说明
对比层次Softmax和负采样的性能特点，为不同场景选择合适的优化策略。
b.性能对比维度
1. 计算复杂度：时间复杂度和空间复杂度
2. 训练速度：收敛速度和每轮训练时间
3. 词向量质量：语义表示能力和下游任务表现
4. 内存使用：参数数量和存储需求
5. 实现复杂度：代码复杂度和调试难度
c.选择建议
a.大词汇表：优先考虑层次Softmax
b.小到中等词汇表：负采样通常效果更好
c.GPU训练：负采样更易并行化
d.CPU训练：层次Softmax更高效
d.代码示例
---
class OptimizationStrategyComparison:
"""优化策略对比分析器"""
def __init__(self):
self.results = {
'hierarchical_softmax': {},
'negative_sampling': {},
'traditional_softmax': {}
}
def analyze_time_complexity(self, vocab_sizes: List[int], embedding_dims: List[int]):
"""分析时间复杂度"""
print("=== 时间复杂度分析 ===")
for vocab_size in vocab_sizes:
for embedding_dim in embedding_dims:
# 传统Softmax: O(|V| * d)
traditional_ops = vocab_size * embedding_dim
# 层次Softmax: O(log|V| * d)
avg_code_length = math.log2(vocab_size)
hierarchical_ops = avg_code_length * embedding_dim
# 负采样: O(k * d), k是负样本数量
k = 5 # 典型负样本数量
negative_ops = k * embedding_dim
print(f"\n词汇表大小: {vocab_size}, 词向量维度: {embedding_dim}")
print(f" 传统Softmax: {traditional_ops:,} 操作")
print(f" 层次Softmax: {hierarchical_ops:.0f} 操作 (加速比: {traditional_ops/hierarchical_ops:.1f}x)")
print(f" 负采样: {negative_ops:,} 操作 (加速比: {traditional_ops/negative_ops:.1f}x)")
def analyze_memory_usage(self, vocab_size: int, embedding_dim: int,
num_negative: int = 5):
"""分析内存使用"""
print(f"\n=== 内存使用分析 (词汇表: {vocab_size}, 维度: {embedding_dim}) ===")
# 传统Softmax
traditional_params = vocab_size * embedding_dim + vocab_size # 嵌入 + 输出层
traditional_memory = traditional_params * 4 / (1024 * 1024) # 假设float32
# 层次Softmax
num_internal = vocab_size - 1 # 霍夫曼树内部节点数
hierarchical_params = vocab_size * embedding_dim + num_internal * embedding_dim + num_internal
hierarchical_memory = hierarchical_params * 4 / (1024 * 1024)
# 负采样
negative_params = vocab_size * embedding_dim * 2 # 输入和输出嵌入
negative_memory = negative_params * 4 / (1024 * 1024)
print(f"传统Softmax:")
print(f" 参数数量: {traditional_params:,}")
print(f" 内存使用: {traditional_memory:.2f} MB")
print(f"\n层次Softmax:")
print(f" 参数数量: {hierarchical_params:,}")
print(f" 内存使用: {hierarchical_memory:.2f} MB")
print(f" 相比传统节省: {(1 - hierarchical_memory/traditional_memory)*100:.1f}%")
print(f"\n负采样:")
print(f" 参数数量: {negative_params:,}")
print(f" 内存使用: {negative_memory:.2f} MB")
return {
'traditional': {'params': traditional_params, 'memory_mb': traditional_memory},
'hierarchical': {'params': hierarchical_params, 'memory_mb': hierarchical_memory},
'negative': {'params': negative_params, 'memory_mb': negative_memory}
}
def simulate_training_time(self, vocab_sizes: List[int], epochs: int = 10):
"""模拟训练时间"""
print(f"\n=== 训练时间模拟 ({epochs} epochs) ===")
# 假设每次操作的时间常数
op_time = 1e-9 # 每次操作1纳秒
for vocab_size in vocab_sizes:
# 假设每个epoch的训练样本数
samples_per_epoch = min(100000, vocab_size * 100)
# 传统Softmax
traditional_ops_per_sample = vocab_size * 100 # 假设100维嵌入
traditional_total_ops = samples_per_epoch * epochs * traditional_ops_per_sample
traditional_time = traditional_total_ops * op_time
# 层次Softmax
avg_code_length = math.log2(vocab_size)
hierarchical_ops_per_sample = avg_code_length * 100
hierarchical_total_ops = samples_per_epoch * epochs * hierarchical_ops_per_sample
hierarchical_time = hierarchical_total_ops * op_time
# 负采样
negative_ops_per_sample = 5 * 100 # 5个负样本
negative_total_ops = samples_per_epoch * epochs * negative_ops_per_sample
negative_time = negative_total_ops * op_time
print(f"\n词汇表大小: {vocab_size:,}")
print(f" 传统Softmax: {traditional_time/3600:.2f} 小时")
print(f" 层次Softmax: {hierarchical_time/3600:.2f} 小时 (加速: {traditional_time/hierarchical_time:.1f}x)")
print(f" 负采样: {negative_time/3600:.2f} 小时 (加速: {traditional_time/negative_time:.1f}x)")
def recommend_strategy(self, vocab_size: int, training_data_size: int,
hardware: str = 'GPU', time_budget: float = None):
"""推荐优化策略"""
print(f"\n=== 优化策略推荐 ===")
print(f"输入参数:")
print(f" 词汇表大小: {vocab_size:,}")
print(f" 训练数据大小: {training_data_size:,}")
print(f" 硬件类型: {hardware}")
recommendations = []
# 基于词汇表大小的推荐
if vocab_size < 1000:
recommendations.append("词汇表较小，传统Softmax可行")
recommendations.append("负采样适合，训练速度快")
elif vocab_size < 100000:
recommendations.append("中等词汇表，负采样是首选")
recommendations.append("层次Softmax也可考虑，特别是对训练时间敏感的场景")
else:
recommendations.append("大词汇表，层次Softmax强烈推荐")
recommendations.append("负采样内存开销较大，需谨慎使用")
# 基于硬件类型的推荐
if hardware == 'GPU':
recommendations.append("GPU环境：负采样更易并行化")
recommendations.append("层次Softmax的树结构不易GPU优化")
elif hardware == 'CPU':
recommendations.append("CPU环境：层次Softmax更适合")
recommendations.append("负采样仍有优势，但不如层次Softmax显著")
# 基于训练数据大小的推荐
if training_data_size > 1000000:
recommendations.append("大数据集：优先考虑训练速度，推荐层次Softmax")
elif training_data_size < 10000:
recommendations.append("小数据集：两种方法都可以，负采样更简单")
print(f"\n推荐策略:")
for i, rec in enumerate(recommendations, 1):
print(f" {i}. {rec}")
# 最终推荐
if vocab_size > 50000 and hardware == 'CPU':
final_rec = "层次Softmax"
elif hardware == 'GPU' or vocab_size < 100000:
final_rec = "负采样"
else:
final_rec = "层次Softmax"
print(f"\n最终推荐: {final_rec}")
return final_rec
def create_comparison_table(self) -> Dict[str, Dict[str, str]]:
"""创建对比表格"""
comparison = {
'传统Softmax': {
'时间复杂度': 'O(|V|×d)',
'空间复杂度': 'O(|V|×d)',
'训练速度': '慢',
'实现复杂度': '简单',
'适用场景': '小词汇表',
'内存使用': '高',
'并行化': '好',
'词向量质量': '高'
},
'层次Softmax': {
'时间复杂度': 'O(log|V|×d)',
'空间复杂度': 'O(|V|×d)',
'训练速度': '快',
'实现复杂度': '中等',
'适用场景': '大词汇表',
'内存使用': '中等',
'并行化': '一般',
'词向量质量': '中等'
},
'负采样': {
'时间复杂度': 'O(k×d)',
'空间复杂度': 'O(|V|×d)',
'训练速度': '很快',
'实现复杂度': '简单',
'适用场景': '中等词汇表',
'内存使用': '高',
'并行化': '好',
'词向量质量': '高'
}
}
print(f"\n=== 优化策略对比表 ===")
print(f"{'策略':<15} {'时间复杂度':<12} {'训练速度':<8} {'内存使用':<8} {'并行化':<8}")
print("-" * 60)
for strategy, metrics in comparison.items():
print(f"{strategy:<15} {metrics['时间复杂度']:<12} {metrics['训练速度']:<8} "
f"{metrics['内存使用']:<8} {metrics['并行化']:<8}")
return comparison
# 使用示例
print("=== 优化策略对比演示 ===")
comparison_analyzer = OptimizationStrategyComparison()
# 时间复杂度分析
vocab_sizes = [1000, 10000, 100000, 1000000]
embedding_dims = [50, 100, 300]
comparison_analyzer.analyze_time_complexity(vocab_sizes, embedding_dims)
# 内存使用分析
memory_analysis = comparison_analyzer.analyze_memory_usage(vocab_size=50000, embedding_dim=100)
# 训练时间模拟
comparison_analyzer.simulate_training_time(vocab_sizes, epochs=5)
# 策略推荐
final_recommendation = comparison_analyzer.recommend_strategy(
vocab_size=50000,
training_data_size=100000,
hardware='GPU'
)
# 创建对比表
comparison_table = comparison_analyzer.create_comparison_table()
---
05.实际应用
a.应用案例
a.功能说明
Word2Vec在工业界有广泛的应用，从搜索引擎到推荐系统都有成功案例。
b.主要应用领域
a.搜索引擎：查询理解和文档匹配
b.推荐系统：用户兴趣建模和物品推荐
c.社交媒体：内容分析和情感监测
d.电商系统：商品推荐和搜索优化
e.金融风控：文本分析和异常检测
c.成功案例特点
a.大规模语料训练
b.领域适应性优化
c.多模态数据融合
d.实时更新机制
e.效果评估体系
b.开源工具
a.功能说明
主流的Word2Vec实现工具和深度学习框架。
b.原生工具
a.Google Word2Vec工具包
b.Gensim Word2Vec实现
c.Facebook fastText
d.TensorFlow Word2Vec
e.PyTorch Word2Vec
c.深度学习框架
a.TensorFlow/Keras
b.PyTorch
c.MXNet
d.PaddlePaddle
e.JAX
d.选择因素
a.性能要求
b.开发效率
c.社区支持
d.文档质量
e.部署便利性
c.性能优化
a.功能说明
Word2Vec模型的性能优化和参数调优策略。
b.性能优化
a.数据预处理优化
b.超参数调优
c.并行化训练
d.内存使用优化
e.模型压缩技术
c.关键参数
a.词向量维度：50-300
b.窗口大小：2-10
c.负样本数量：5-20
d.学习率：0.01-0.05
e.训练轮数：3-10
06.总结与展望
a.技术总结
a.功能说明
Word2Vec作为词向量学习的里程碑技术，具有以下重要贡献。
b.重要贡献
a.提出了高效的词向量学习算法
b.建立了分布式词表示的标准
c.推动了NLP领域的发展
d.为后续预训练模型奠定基础
c.技术优势
a.训练效率高
b.词向量质量好
c.实现简单可靠
d.应用范围广泛
b.当前局限性
a.功能说明
Word2Vec也存在一些局限性。
b.局限性
a.静态词表示，无法处理一词多义
b.缺乏上下文信息
c.对低频词处理不佳
d.无法捕捉长距离依赖
c.未来发展方向
a.功能说明
Word2Vec的未来发展方向。
b.发展方向
a.上下文相关词向量
b.多语言词向量学习
c.知识增强的词表示
d.端到端学习框架
e.大规模预训练模型
2.5 GloVe
01.模型概述
a.分类1
a.功能说明
GloVe（Global Vectors for Word Representation）是斯坦福大学于2014年提出的词向量模型，由Jeffrey Pennington、Richard Socher和Christopher Manning开发。GloVe结合了全局矩阵分解和局部上下文窗口的优点，通过学习词向量和上下文向量来表示词汇的语义信息。
b.发展背景
a.2013年：Word2Vec的发布推动了神经词向量的发展
b.2014年：GloVe提出，结合全局统计信息
c.核心创新：利用共现矩阵的全局统计特性
d.优势：同时捕捉局部和全局的语义关系
e.影响：成为Word2Vec的重要替代方案
c.关键特点
a.全局统计信息：使用整个语料的共现统计
b.向量空间结构：保持语义关系的线性结构
c.训练效率：比传统矩阵分解方法更快
d.可扩展性：支持大规模词汇表和语料
b.分类2
a.核心思想
GloVe的核心思想是通过词共现统计来学习词向量，使词向量的点积能够反映词共现概率。
b.理论原理
a.共现概率：P(j|i) = X_ij / X_i，其中X_ij是词i和词j的共现次数
b.概率比：P(j|k)/P(j|i)能够编码词i和词k的语义关系
c.向量表示：w_i · w_j + b_i + b_j = log(X_ij)
d.优化目标：最小化重构误差
c.分类3
a.模型对比
GloVe与Word2Vec的主要区别：
b.训练数据
a.Word2Vec：使用局部上下文窗口
b.GloVe：使用全局共现统计
c.优化目标
a.Word2Vec：最大化预测概率
b.GloVe：最小化重构误差
d.计算效率
a.Word2Vec：在线学习，适合流式数据
b.GloVe：批量训练，需要完整共现矩阵
e.词向量质量
a.Word2Vec：局部语义关系好
b.GloVe：全局语义关系和类比任务表现更好
f.适用场景
a.Word2Vec：大规模动态数据
b.GloVe：静态数据，需要精确统计
d.分类4
a.应用场景
a.文本分类和情感分析
b.机器翻译和跨语言应用
c.信息检索和语义搜索
d.词类比和关系推理
e.推荐系统和用户画像
b.技术优势
a.结合全局和局部信息
b.训练收敛速度快
c.词向量质量高
d.支持大规模训练
e.数学理论清晰
02.共现矩阵
a.统计方法
a.功能说明
词共现统计是GloVe的基础，需要统计词汇在语料中的共现频率。
b.统计方法
a.滑动窗口统计：在固定大小的窗口内统计词对共现
b.加权共现：根据距离给予不同权重
c.全局统计：遍历整个语料构建共现矩阵
d.稀疏存储：利用矩阵的稀疏性进行优化
c.权重策略
a.距离权重：距离越近权重越大
b.线性衰减：1/d，其中d是距离
c.指数衰减：exp(-d/scale)
d.固定权重：窗口内权重相同
b.代码示例
---
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List, Dict, Tuple, Optional, Any
from collections import defaultdict, Counter
import matplotlib.pyplot as plt
from scipy.sparse import csr_matrix, save_npz, load_npz
import scipy.sparse as sp
import pickle
import time
from sklearn.decomposition import TruncatedSVD
from sklearn.manifold import TSNE
class CooccurrenceMatrixBuilder:
"""共现矩阵构建器"""
def __init__(self, vocab_size: int, window_size: int = 5,
weighting_scheme: str = 'distance'):
"""
初始化共现矩阵构建器
Args:
vocab_size: 词汇表大小
window_size: 上下文窗口大小
weighting_scheme: 权重方案 ('distance', 'linear', 'exponential', 'uniform')
"""
self.vocab_size = vocab_size
self.window_size = window_size
self.weighting_scheme = weighting_scheme
self.cooccurrence_counts = defaultdict(lambda: defaultdict(int))
self.word_counts = Counter()
def build_cooccurrence_matrix(self, corpus: List[List[int]],
word_to_idx: Dict[str, int]) -> csr_matrix:
"""
构建共现矩阵
Args:
corpus: 转换为索引的语料
word_to_idx: 词汇到索引的映射
Returns:
稀疏共现矩阵
"""
print("开始构建共现矩阵...")
start_time = time.time()
# 初始化稀疏矩阵数据结构
rows, cols, data = [], [], []
# 统计词频
for sentence in corpus:
self.word_counts.update(sentence)
# 构建共现统计
total_pairs = 0
processed_sentences = 0
for sentence_idx, sentence in enumerate(corpus):
if sentence_idx % 1000 == 0:
print(f"处理句子: {sentence_idx}/{len(corpus)}")
processed_sentences += 1
sentence_length = len(sentence)
for i in range(sentence_length):
center_word = sentence[i]
if center_word >= self.vocab_size:
continue
# 遍历上下文窗口
start = max(0, i - self.window_size)
end = min(sentence_length, i + self.window_size + 1)
for j in range(start, end):
if j == i:
continue
context_word = sentence[j]
if context_word >= self.vocab_size:
continue
# 计算权重
distance = abs(j - i)
weight = self._calculate_weight(distance)
# 记录共现
self.cooccurrence_counts[center_word][context_word] += weight
total_pairs += 1
print(f"共现统计完成，总词对数: {total_pairs}")
# 转换为稀疏矩阵
for i, cooccurrences in self.cooccurrence_counts.items():
for j, count in cooccurrences.items():
rows.append(i)
cols.append(j)
data.append(count)
# 创建稀疏矩阵
cooc_matrix = csr_matrix((data, (rows, cols)),
shape=(self.vocab_size, self.vocab_size),
dtype=np.float64)
# 对称化（可选）
cooc_matrix = self._symmetrize_matrix(cooc_matrix)
end_time = time.time()
print(f"共现矩阵构建完成，耗时: {end_time - start_time:.2f}秒")
print(f"矩阵形状: {cooc_matrix.shape}")
print(f"非零元素数: {cooc_matrix.nnz}")
print(f"稀疏度: {1 - cooc_matrix.nnz / (cooc_matrix.shape[0] * cooc_matrix.shape[1]):.6f}")
return cooc_matrix
def _calculate_weight(self, distance: int) -> float:
"""计算共现权重"""
if distance == 0:
return 0.0
if self.weighting_scheme == 'uniform':
return 1.0
elif self.weighting_scheme == 'distance':
return 1.0 / distance
elif self.weighting_scheme == 'linear':
return max(0, 1.0 - distance / self.window_size)
elif self.weighting_scheme == 'exponential':
return np.exp(-distance / 2.0)
else:
return 1.0
def _symmetrize_matrix(self, matrix: csr_matrix) -> csr_matrix:
"""对称化共现矩阵"""
return matrix + matrix.T - sp.diags(matrix.diagonal())
def analyze_matrix_statistics(self, cooc_matrix: csr_matrix) -> Dict[str, Any]:
"""分析共现矩阵统计信息"""
print("=== 共现矩阵统计分析 ===")
# 基本统计
total_elements = cooc_matrix.shape[0] * cooc_matrix.shape[1]
non_zero_elements = cooc_matrix.nnz
sparsity = 1 - non_zero_elements / total_elements
# 共现值统计
cooc_values = cooc_matrix.data
total_cooc_count = np.sum(cooc_values)
max_cooc_count = np.max(cooc_values)
min_cooc_count = np.min(cooc_values[cooc_values > 0]) if np.any(cooc_values > 0) else 0
avg_cooc_count = np.mean(cooc_values)
std_cooc_count = np.std(cooc_values)
print(f"矩阵形状: {cooc_matrix.shape}")
print(f"总元素数: {total_elements:,}")
print(f"非零元素数: {non_zero_elements:,}")
print(f"稀疏度: {sparsity:.6f}")
print(f"总共现次数: {total_cooc_count:,.0f}")
print(f"最大共现次数: {max_cooc_count:.2f}")
print(f"最小共现次数: {min_cooc_count:.2f}")
print(f"平均共现次数: {avg_cooc_count:.2f}")
print(f"共现次数标准差: {std_cooc_count:.2f}")
# 词频统计
print(f"\n词频统计:")
print(f"词汇表大小: {len(self.word_counts)}")
print(f"总词数: {sum(self.word_counts.values()):,}")
# 高频词分析
top_words = self.word_counts.most_common(10)
print(f"\n最高频词 (Top 10):")
for word, count in top_words:
print(f" 词 {word}: {count:,} 次")
return {
'matrix_shape': cooc_matrix.shape,
'total_elements': total_elements,
'non_zero_elements': non_zero_elements,
'sparsity': sparsity,
'total_cooc_count': total_cooc_count,
'max_cooc_count': max_cooc_count,
'avg_cooc_count': avg_cooc_count,
'top_words': top_words
}
def visualize_cooccurrence_distribution(self, cooc_matrix: csr_matrix,
max_samples: int = 10000):
"""可视化共现分布"""
print("=== 共现分布可视化 ===")
# 采样共现值
cooc_values = cooc_matrix.data
if len(cooc_values) > max_samples:
sampled_indices = np.random.choice(len(cooc_values), max_samples, replace=False)
sampled_values = cooc_values[sampled_indices]
else:
sampled_values = cooc_values
# 创建子图
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
# 1. 共现值直方图
ax1.hist(np.log10(sampled_values + 1), bins=50, alpha=0.7, edgecolor='black')
ax1.set_xlabel('log10(共现次数 + 1)')
ax1.set_ylabel('频次')
ax1.set_title('共现次数分布 (对数尺度)')
ax1.grid(True, alpha=0.3)
# 2. 共现值累积分布
sorted_values = np.sort(sampled_values)
cumulative = np.arange(1, len(sorted_values) + 1) / len(sorted_values)
ax2.plot(sorted_values, cumulative)
ax2.set_xlabel('共现次数')
ax2.set_ylabel('累积概率')
ax2.set_title('共现次数累积分布')
ax2.grid(True, alpha=0.3)
ax2.set_xscale('log')
# 3. 热力图（采样部分矩阵）
matrix_size = min(50, cooc_matrix.shape[0])
sample_indices = np.random.choice(cooc_matrix.shape[0], matrix_size, replace=False)
sample_matrix = cooc_matrix[sample_indices, :][:, sample_indices].toarray()
im = ax3.imshow(np.log10(sample_matrix + 1), cmap='hot', aspect='auto')
ax3.set_title('共现矩阵热力图 (对数尺度)')
ax3.set_xlabel('词汇索引')
ax3.set_ylabel('词汇索引')
plt.colorbar(im, ax=ax3)
# 4. 共现次数与词频的关系
word_freqs = np.array([self.word_counts[i] for i in range(min(len(self.word_counts), 1000))])
avg_coocs = []
for i in range(min(len(self.word_counts), 1000)):
row_coocs = cooc_matrix[i].data
if len(row_coocs) > 0:
avg_coocs.append(np.mean(row_coocs))
else:
avg_coocs.append(0)
ax4.scatter(word_freqs, avg_coocs, alpha=0.5)
ax4.set_xlabel('词频')
ax4.set_ylabel('平均共现次数')
ax4.set_title('词频 vs 平均共现次数')
ax4.set_xscale('log')
ax4.set_yscale('log')
ax4.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 使用示例
print("=== 共现矩阵构建演示 ===")
# 示例语料（转换为索引形式）
sample_corpus = [
[0, 1, 2, 3, 4, 5, 6], # "自然语言处理是人工智能的重要分支"
[7, 8, 0, 1, 2, 9, 10, 11], # "深度学习在自然语言处理中应用广泛"
[12, 13, 14, 3, 15, 2, 16, 17], # "我们需要更多数据来训练模型"
[18, 19, 20, 21, 2, 3, 22, 23], # "词向量技术能够捕捉词汇的语义信息"
[24, 25, 26, 27, 28, 29, 30, 2, 31] # "神经网络模型表现优异在NLP任务中"
]
# 构建词汇表映射
vocabulary = ['自然', '语言', '处理', '是', '人工智能', '的', '重要', '分支', '深度', '学习', '在', '中', '应用', '广泛', '我们', '需要', '更多', '数据', '来', '训练', '模型', '词向量', '技术', '能够', '捕捉', '词汇', '的', '语义', '信息', '神经', '网络', '表现', '优异', 'NLP', '任务']
word_to_idx = {word: idx for idx, word in enumerate(vocabulary)}
idx_to_word = {idx: word for word, idx in word_to_idx.items()}
# 构建共现矩阵
matrix_builder = CooccurrenceMatrixBuilder(
vocab_size=len(vocabulary),
window_size=3,
weighting_scheme='distance'
)
cooc_matrix = matrix_builder.build_cooccurrence_matrix(sample_corpus, word_to_idx)
# 分析统计信息
stats = matrix_builder.analyze_matrix_statistics(cooc_matrix)
# 可视化分布
matrix_builder.visualize_cooccurrence_distribution(cooc_matrix)
---
b.权重函数设计
a.功能说明
权重函数在GloVe训练中起到重要作用，需要平衡高频和低频词对的影响。
b.权重函数特点
a.截断函数：f(x) = (x/x_max)^α if x < x_max else 1
b.降采样：对高频词进行降采样
c.最小阈值：忽略低频共现
d.自适应权重：根据词频动态调整
c.参数选择
a.x_max：最大共现次数阈值（通常100）
b.α：权重指数（通常0.75）
c.min_count：最小词频阈值（通常5）
d.代码示例
---
class GloVeWeightingFunction:
"""GloVe权重函数实现"""
def __init__(self, x_max: float = 100.0, alpha: float = 0.75):
"""
初始化权重函数
Args:
x_max: 最大共现次数阈值
alpha: 权重指数
"""
self.x_max = x_max
self.alpha = alpha
def calculate_weight(self, x_ij: float) -> float:
"""
计算权重
Args:
x_ij: 共现次数
Returns:
权重值
"""
if x_ij < self.x_max:
return (x_ij / self.x_max) ** self.alpha
else:
return 1.0
def vectorized_weights(self, cooc_matrix: csr_matrix) -> csr_matrix:
"""向量化计算权重"""
# 获取共现值
data = cooc_matrix.data.copy()
# 计算权重
mask = data < self.x_max
data[mask] = (data[mask] / self.x_max) ** self.alpha
data[~mask] = 1.0
# 创建加权矩阵
weighted_matrix = csr_matrix((data, cooc_matrix.indices, cooc_matrix.indptr),
shape=cooc_matrix.shape,
dtype=np.float64)
return weighted_matrix
def visualize_weight_function(self, max_x: float = 200):
"""可视化权重函数"""
x_values = np.linspace(0, max_x, 1000)
weights = [self.calculate_weight(x) for x in x_values]
plt.figure(figsize=(12, 8))
# 权重函数曲线
plt.subplot(2, 2, 1)
plt.plot(x_values, weights, 'b-', linewidth=2)
plt.axvline(x=self.x_max, color='r', linestyle='--', label=f'x_max = {self.x_max}')
plt.xlabel('共现次数 (x_ij)')
plt.ylabel('权重 f(x)')
plt.title(f'GloVe权重函数 (α = {self.alpha})')
plt.legend()
plt.grid(True, alpha=0.3)
# 对数尺度
plt.subplot(2, 2, 2)
plt.semilogx(x_values[1:], weights[1:], 'g-', linewidth=2) # 跳过0
plt.axvline(x=self.x_max, color='r', linestyle='--')
plt.xlabel('共现次数 (对数尺度)')
plt.ylabel('权重 f(x)')
plt.title('权重函数 (对数尺度)')
plt.grid(True, alpha=0.3)
# 权重分布
plt.subplot(2, 2, 3)
# 模拟共现分布
simulated_coocs = np.random.exponential(10, 10000)
weights_sim = [self.calculate_weight(x) for x in simulated_coocs]
plt.hist(weights_sim, bins=50, alpha=0.7, edgecolor='black')
plt.xlabel('权重值')
plt.ylabel('频次')
plt.title('权重分布 (模拟共现数据)')
plt.grid(True, alpha=0.3)
# 不同α值的比较
plt.subplot(2, 2, 4)
alphas = [0.5, 0.75, 1.0]
for alpha in alphas:
temp_func = GloVeWeightingFunction(x_max=self.x_max, alpha=alpha)
temp_weights = [temp_func.calculate_weight(x) for x in x_values]
plt.plot(x_values, temp_weights, label=f'α = {alpha}', linewidth=2)
plt.xlabel('共现次数 (x_ij)')
plt.ylabel('权重 f(x)')
plt.title('不同α值的权重函数比较')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
def analyze_parameter_impact(self, cooc_matrix: csr_matrix,
sample_size: int = 1000) -> Dict[str, Any]:
"""分析参数影响"""
print("=== 权重函数参数影响分析 ===")
# 采样共现值
cooc_values = cooc_matrix.data
if len(cooc_values) > sample_size:
sampled_values = np.random.choice(cooc_values, sample_size, replace=False)
else:
sampled_values = cooc_values
# 分析不同参数设置
analysis_results = {}
# 不同x_max的影响
x_max_values = [10, 50, 100, 200, 500]
print(f"\n不同x_max值的影响:")
for x_max in x_max_values:
temp_func = GloVeWeightingFunction(x_max=x_max, alpha=self.alpha)
weights = [temp_func.calculate_weight(x) for x in sampled_values]
analysis_results[f'x_max_{x_max}'] = {
'mean_weight': np.mean(weights),
'std_weight': np.std(weights),
'high_weight_ratio': np.mean(np.array(weights) > 0.9)
}
print(f" x_max={x_max}: 平均权重={np.mean(weights):.4f}, "
f"高权重比例={np.mean(np.array(weights) > 0.9):.4f}")
# 不同α的影响
alpha_values = [0.5, 0.75, 1.0]
print(f"\n不同α值的影响:")
for alpha in alpha_values:
temp_func = GloVeWeightingFunction(x_max=self.x_max, alpha=alpha)
weights = [temp_func.calculate_weight(x) for x in sampled_values]
analysis_results[f'alpha_{alpha}'] = {
'mean_weight': np.mean(weights),
'std_weight': np.std(weights),
'high_weight_ratio': np.mean(np.array(weights) > 0.9)
}
print(f" α={alpha}: 平均权重={np.mean(weights):.4f}, "
f"高权重比例={np.mean(np.array(weights) > 0.9):.4f}")
return analysis_results
# 使用示例
print("=== GloVe权重函数演示 ===")
# 创建权重函数
weighting_function = GloVeWeightingFunction(x_max=100.0, alpha=0.75)
# 可视化权重函数
weighting_function.visualize_weight_function()
# 分析参数影响
if cooc_matrix.nnz > 0:
impact_analysis = weighting_function.analyze_parameter_impact(cooc_matrix)
---
03.GloVe模型实现
a.模型架构设计
a.功能说明
GloVe模型使用简单的线性架构，包含词向量、上下文向量和偏置项。
b.架构组件
a.词向量矩阵 W: [vocab_size, embedding_dim]
b.上下文向量矩阵 W̃: [vocab_size, embedding_dim]
c.词偏置向量 b: [vocab_size]
d.上下文偏置向量 b̃: [vocab_size]
c.训练目标
J = Σ_{i,j} f(X_ij) (w_i^T w̃_j + b_i + b̃_j - log X_ij)^2
d.模型特点
a.线性变换，没有非线性激活函数
b.全局优化，使用整个共现矩阵
c.对称性：w_i和w̃_j在训练后可以合并
b.代码示例
---
class GloVeModel(nn.Module):
"""GloVe模型实现"""
def __init__(self, vocab_size: int, embedding_dim: int):
"""
初始化GloVe模型
Args:
vocab_size: 词汇表大小
embedding_dim: 词向量维度
"""
super(GloVeModel, self).__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
# 词向量和上下文向量
self.word_embeddings = nn.Parameter(
torch.randn(vocab_size, embedding_dim) * 0.01
)
self.context_embeddings = nn.Parameter(
torch.randn(vocab_size, embedding_dim) * 0.01
)
# 偏置项
self.word_biases = nn.Parameter(torch.zeros(vocab_size))
self.context_biases = nn.Parameter(torch.zeros(vocab_size))
def forward(self, word_indices: torch.Tensor,
context_indices: torch.Tensor,
cooc_counts: torch.Tensor) -> torch.Tensor:
"""
前向传播
Args:
word_indices: 中心词索引 [batch_size]
context_indices: 上下文词索引 [batch_size]
cooc_counts: 共现次数 [batch_size]
Returns:
预测的log共现次数 [batch_size]
"""
# 获取向量和偏置
word_vecs = self.word_embeddings[word_indices] # [batch_size, embedding_dim]
context_vecs = self.context_embeddings[context_indices] # [batch_size, embedding_dim]
word_bias = self.word_biases[word_indices] # [batch_size]
context_bias = self.context_biases[context_indices] # [batch_size]
# 计算点积
dot_product = torch.sum(word_vecs * context_vecs, dim=1) # [batch_size]
# 计算预测值
predictions = dot_product + word_bias + context_bias # [batch_size]
return predictions
def get_word_vectors(self) -> torch.Tensor:
"""获取词向量（合并词向量和上下文向量）"""
return self.word_embeddings.data + self.context_embeddings.data
def get_individual_vectors(self) -> Tuple[torch.Tensor, torch.Tensor]:
"""获取单独的词向量和上下文向量"""
return self.word_embeddings.data, self.context_embeddings.data
def compute_loss(self, predictions: torch.Tensor,
targets: torch.Tensor,
weights: torch.Tensor) -> torch.Tensor:
"""
计算加权最小二乘损失
Args:
predictions: 预测值 [batch_size]
targets: 目标值 [batch_size]
weights: 权重 [batch_size]
Returns:
损失值
"""
diff = predictions - targets
weighted_loss = weights * diff ** 2
return torch.mean(weighted_loss)
def initialize_parameters(self):
"""初始化参数"""
nn.init.normal_(self.word_embeddings, std=0.01)
nn.init.normal_(self.context_embeddings, std=0.01)
nn.init.zeros_(self.word_biases)
nn.init.zeros_(self.context_biases)
class GloVeTrainer:
"""GloVe训练器"""
def __init__(self, model: GloVeModel, learning_rate: float = 0.05,
x_max: float = 100.0, alpha: float = 0.75):
"""
初始化训练器
Args:
model: GloVe模型
learning_rate: 学习率
x_max: 权重函数参数
alpha: 权重函数参数
"""
self.model = model
self.learning_rate = learning_rate
self.weighting_function = GloVeWeightingFunction(x_max, alpha)
self.training_losses = []
# 优化器
self.optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
def prepare_training_data(self, cooc_matrix: csr_matrix,
sample_ratio: float = 1.0) -> Tuple[List, List, List]:
"""
准备训练数据
Args:
cooc_matrix: 共现矩阵
sample_ratio: 采样比例
Returns:
(word_indices, context_indices, cooc_counts)
"""
print("准备GloVe训练数据...")
# 获取非零元素
rows, cols = cooc_matrix.nonzero()
data = cooc_matrix.data
# 采样
if sample_ratio < 1.0:
n_samples = int(len(data) * sample_ratio)
sample_indices = np.random.choice(len(data), n_samples, replace=False)
rows = rows[sample_indices]
cols = cols[sample_indices]
data = data[sample_indices]
print(f"训练样本数: {len(data)}")
return rows.tolist(), cols.tolist(), data.tolist()
def train_epoch(self, word_indices: List[int],
context_indices: List[int],
cooc_counts: List[float],
batch_size: int = 1024) -> Dict[str, float]:
"""
训练一个epoch
Args:
word_indices: 中心词索引列表
context_indices: 上下文词索引列表
cooc_counts: 共现次数列表
batch_size: 批大小
Returns:
训练统计信息
"""
self.model.train()
total_loss = 0.0
num_batches = 0
# 计算权重
weights = [self.weighting_function.calculate_weight(count) for count in cooc_counts]
# 转换为张量
word_tensor = torch.tensor(word_indices, dtype=torch.long)
context_tensor = torch.tensor(context_indices, dtype=torch.long)
count_tensor = torch.tensor(cooc_counts, dtype=torch.float32)
weight_tensor = torch.tensor(weights, dtype=torch.float32)
# 目标值（log共现次数）
targets = torch.log(count_tensor + 1)
# 分批训练
num_samples = len(word_indices)
for i in range(0, num_samples, batch_size):
end_idx = min(i + batch_size, num_samples)
batch_word = word_tensor[i:end_idx]
batch_context = context_tensor[i:end_idx]
batch_targets = targets[i:end_idx]
batch_weights = weight_tensor[i:end_idx]
# 前向传播
predictions = self.model(batch_word, batch_context, batch_count)
# 计算损失
loss = self.model.compute_loss(predictions, batch_targets, batch_weights)
# 反向传播
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
total_loss += loss.item()
num_batches += 1
avg_loss = total_loss / num_batches
self.training_losses.append(avg_loss)
return {
'loss': avg_loss,
'total_loss': total_loss,
'num_batches': num_batches
}
def train(self, cooc_matrix: csr_matrix,
epochs: int = 100, batch_size: int = 1024,
sample_ratio: float = 1.0,
validation_cooc: Optional[csr_matrix] = None) -> Dict[str, List[float]]:
"""
完整训练过程
Args:
cooc_matrix: 训练共现矩阵
epochs: 训练轮数
batch_size: 批大小
sample_ratio: 采样比例
validation_cooc: 验证共现矩阵
Returns:
训练历史
"""
print(f"开始训练GloVe模型...")
print(f"词汇表大小: {self.model.vocab_size}")
print(f"词向量维度: {self.model.embedding_dim}")
print(f"训练轮数: {epochs}")
print(f"批大小: {batch_size}")
# 准备训练数据
word_indices, context_indices, cooc_counts = self.prepare_training_data(
cooc_matrix, sample_ratio
)
training_history = {
'train_losses': [],
'val_losses': []
}
for epoch in range(epochs):
print(f"\nEpoch {epoch + 1}/{epochs}")
# 训练
train_stats = self.train_epoch(
word_indices, context_indices, cooc_counts, batch_size
)
training_history['train_losses'].append(train_stats['loss'])
print(f" 训练损失: {train_stats['loss']:.6f}")
# 学习率衰减
if epoch > 0 and epoch % 20 == 0:
for param_group in self.optimizer.param_groups:
param_group['lr'] *= 0.9
print(f" 学习率衰减至: {self.optimizer.param_groups[0]['lr']:.6f}")
print(f"\n训练完成!")
return training_history
def save_model(self, filepath: str, word_to_idx: Dict[str, int]):
"""保存模型"""
checkpoint = {
'model_state_dict': self.model.state_dict(),
'word_to_idx': word_to_idx,
'vocab_size': self.model.vocab_size,
'embedding_dim': self.model.embedding_dim,
'training_losses': self.training_losses
}
torch.save(checkpoint, filepath)
print(f"模型已保存到: {filepath}")
def load_model(self, filepath: str) -> Dict[str, int]:
"""加载模型"""
checkpoint = torch.load(filepath, map_location='cpu')
self.model.load_state_dict(checkpoint['model_state_dict'])
self.training_losses = checkpoint['training_losses']
print(f"模型已从 {filepath} 加载")
return checkpoint['word_to_idx']
# 使用示例
print("=== GloVe模型实现演示 ===")
# 创建GloVe模型
vocab_size = len(vocabulary)
embedding_dim = 50
glove_model = GloVeModel(vocab_size, embedding_dim)
print(f"模型参数:")
print(f" 词汇表大小: {glove_model.vocab_size}")
print(f" 词向量维度: {glove_model.embedding_dim}")
# 创建训练器
glove_trainer = GloVeTrainer(glove_model, learning_rate=0.05, x_max=100.0, alpha=0.75)
# 模拟训练数据（使用之前构建的共现矩阵）
if cooc_matrix.nnz > 0:
# 训练模型
training_history = glove_trainer.train(
cooc_matrix, epochs=50, batch_size=128, sample_ratio=1.0
)
# 绘制训练曲线
plt.figure(figsize=(10, 6))
plt.plot(training_history['train_losses'])
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('GloVe训练损失曲线')
plt.grid(True, alpha=0.3)
plt.show()
# 获取词向量
word_vectors = glove_model.get_word_vectors()
print(f"\n词向量矩阵形状: {word_vectors.shape}")
# 分析词向量质量
print(f"词向量统计:")
print(f" 平均范数: {torch.norm(word_vectors, dim=1).mean().item():.4f}")
print(f" 范数标准差: {torch.norm(word_vectors, dim=1).std().item():.4f}")
---
b.训练过程与损失函数
a.功能说明
GloVe使用加权最小二乘损失函数，通过最小化预测误差来学习词向量。
b.损失函数
J = Σ_{i,j} f(X_ij) (w_i^T w̃_j + b_i + b̃_j - log X_ij)^2
c.训练过程
a.初始化模型参数
b.采样共现矩阵的非零元素
c.计算权重函数值
d.前向传播计算预测值
e.计算加权最小二乘损失
f.反向传播更新参数
g.重复直到收敛
d.优化技巧
a.自适应学习率
b.梯度裁剪
c.批量训练
d.采样策略
e.早停机制
c.超参数调优策略
a.功能说明
GloVe的关键超参数需要仔细调优以获得最佳性能。
b.主要超参数
a.embedding_dim: 词向量维度 (50-300)
b.window_size: 共现窗口大小 (5-15)
c.x_max: 权重函数阈值 (10-100)
d.alpha: 权重函数指数 (0.5-1.0)
e.learning_rate: 学习率 (0.001-0.1)
f.epochs: 训练轮数 (50-200)
c.调优策略
a.网格搜索
b.随机搜索
c.贝叶斯优化
d.遗传算法
e.经验法则
d.代码示例
---
class GloVeHyperparameterTuner:
"""GloVe超参数调优器"""
def __init__(self, corpus: List[List[int]], cooc_matrix: csr_matrix,
word_to_idx: Dict[str, int]):
"""
初始化调优器
Args:
corpus: 训练语料
cooc_matrix: 共现矩阵
word_to_idx: 词汇到索引的映射
"""
self.corpus = corpus
self.cooc_matrix = cooc_matrix
self.word_to_idx = word_to_idx
self.idx_to_word = {idx: word for word, idx in word_to_idx.items()}
self.tuning_results = []
def grid_search(self, param_grid: Dict[str, List],
max_trials: int = 10) -> List[Dict[str, Any]]:
"""
网格搜索超参数
Args:
param_grid: 参数网格
max_trials: 最大试验次数
Returns:
调优结果列表
"""
print("开始网格搜索...")
# 生成所有参数组合
from itertools import product
param_names = list(param_grid.keys())
param_values = list(param_grid.values())
all_combinations = product(*param_values)
# 限制试验次数
total_combinations = len(list(all_combinations))
if total_combinations > max_trials:
import random
all_combinations = random.sample(list(all_combinations), max_trials)
trial_count = 0
for combination in all_combinations:
trial_count += 1
print(f"\n试验 {trial_count}/{min(total_combinations, max_trials)}")
# 构建参数字典
params = dict(zip(param_names, combination))
print(f"参数: {params}")
try:
# 训练模型
result = self._train_with_params(params)
result['params'] = params
self.tuning_results.append(result)
print(f"验证损失: {result['val_loss']:.6f}")
print(f"训练时间: {result['training_time']:.2f}秒")
except Exception as e:
print(f"训练失败: {e}")
continue
# 按验证损失排序
self.tuning_results.sort(key=lambda x: x['val_loss'])
print(f"\n网格搜索完成，共完成 {len(self.tuning_results)} 个试验")
return self.tuning_results
def _train_with_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
"""使用指定参数训练模型"""
import time
start_time = time.time()
# 创建模型
model = GloVeModel(
vocab_size=len(self.word_to_idx),
embedding_dim=params['embedding_dim']
)
# 创建训练器
trainer = GloVeTrainer(
model=model,
learning_rate=params['learning_rate'],
x_max=params['x_max'],
alpha=params['alpha']
)
# 训练模型
training_history = trainer.train(
cooc_matrix=self.cooc_matrix,
epochs=params['epochs'],
batch_size=params.get('batch_size', 1024),
sample_ratio=params.get('sample_ratio', 1.0)
)
# 评估模型
word_vectors = model.get_word_vectors()
eval_score = self._evaluate_model(word_vectors)
end_time = time.time()
return {
'val_loss': training_history['train_losses'][-1],
'eval_score': eval_score,
'training_time': end_time - start_time,
'final_loss': training_history['train_losses'][-1],
'converged': len(training_history['train_losses']) > 10
}
def _evaluate_model(self, word_vectors: torch.Tensor,
sample_size: int = 100) -> float:
"""评估模型质量"""
# 简化的评估：计算向量的内聚性
# 在实际应用中，应该使用专门的评估任务
vectors_np = word_vectors.numpy()
# 采样评估
if vectors_np.shape[0] > sample_size:
sample_indices = np.random.choice(vectors_np.shape[0], sample_size, replace=False)
sample_vectors = vectors_np[sample_indices]
else:
sample_vectors = vectors_np
# 计算平均内余弦相似度（作为简单评估指标）
from sklearn.metrics.pairwise import cosine_similarity
sim_matrix = cosine_similarity(sample_vectors)
np.fill_diagonal(sim_matrix, 0) # 排除自相似
# 返回平均相似度作为评估分数
return np.mean(sim_matrix[sim_matrix > 0])
def analyze_tuning_results(self) -> Dict[str, Any]:
"""分析调优结果"""
if not self.tuning_results:
print("没有调优结果可分析")
return {}
print("=== 超参数调优结果分析 ===")
# 最佳参数
best_result = self.tuning_results[0]
print(f"最佳验证损失: {best_result['val_loss']:.6f}")
print(f"最佳参数: {best_result['params']}")
print(f"最佳评估分数: {best_result['eval_score']:.4f}")
# 参数影响分析
param_analysis = {}
for param_name in best_result['params'].keys():
param_values = [r['params'][param_name] for r in self.tuning_results]
val_losses = [r['val_loss'] for r in self.tuning_results]
# 计算相关性
if len(set(param_values)) > 1:
correlation = np.corrcoef(param_values, val_losses)[0, 1]
param_analysis[param_name] = {
'correlation': correlation,
'best_value': best_result['params'][param_name],
'value_range': (min(param_values), max(param_values))
}
print(f"\n{param_name} 影响:")
print(f" 与验证损失的相关性: {correlation:.4f}")
print(f" 最佳值: {best_result['params'][param_name]}")
print(f" 取值范围: {min(param_values):.4f} - {max(param_values):.4f}")
return {
'best_result': best_result,
'param_analysis': param_analysis,
'total_trials': len(self.tuning_results)
}
def plot_tuning_results(self):
"""可视化调优结果"""
if not self.tuning_results:
print("没有调优结果可可视化")
return
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
# 1. 损失分布
losses = [r['val_loss'] for r in self.tuning_results]
axes[0, 0].hist(losses, bins=20, alpha=0.7, edgecolor='black')
axes[0, 0].set_xlabel('验证损失')
axes[0, 0].set_ylabel('频次')
axes[0, 0].set_title('验证损失分布')
axes[0, 0].grid(True, alpha=0.3)
# 2. 训练时间 vs 损失
times = [r['training_time'] for r in self.tuning_results]
axes[0, 1].scatter(times, losses, alpha=0.6)
axes[0, 1].set_xlabel('训练时间 (秒)')
axes[0, 1].set_ylabel('验证损失')
axes[0, 1].set_title('训练时间 vs 验证损失')
axes[0, 1].grid(True, alpha=0.3)
# 3. 参数影响（embedding_dim）
if 'embedding_dim' in self.tuning_results[0]['params']:
embed_dims = [r['params']['embedding_dim'] for r in self.tuning_results]
axes[1, 0].scatter(embed_dims, losses, alpha=0.6)
axes[1, 0].set_xlabel('词向量维度')
axes[1, 0].set_ylabel('验证损失')
axes[1, 0].set_title('词向量维度 vs 验证损失')
axes[1, 0].grid(True, alpha=0.3)
# 4. 学习率影响
if 'learning_rate' in self.tuning_results[0]['params']:
lrs = [r['params']['learning_rate'] for r in self.tuning_results]
axes[1, 1].scatter(lrs, losses, alpha=0.6)
axes[1, 1].set_xlabel('学习率')
axes[1, 1].set_ylabel('验证损失')
axes[1, 1].set_title('学习率 vs 验证损失')
axes[1, 1].set_xscale('log')
axes[1, 1].grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 使用示例
print("=== GloVe超参数调优演示 ===")
if cooc_matrix.nnz > 0:
# 创建调优器
tuner = GloVeHyperparameterTuner(sample_corpus, cooc_matrix, word_to_idx)
# 定义参数网格
param_grid = {
'embedding_dim': [25, 50], # 减少维度以加快演示
'learning_rate': [0.01, 0.05],
'x_max': [50, 100],
'alpha': [0.75],
'epochs': [10], # 减少epoch以加快演示
'batch_size': [64]
}
# 执行网格搜索
tuning_results = tuner.grid_search(param_grid, max_trials=4)
# 分析结果
if tuning_results:
analysis = tuner.analyze_tuning_results()
tuner.plot_tuning_results()
---
04.模型评估与优化
a.评估指标与基准测试
a.功能说明
GloVe模型的评估需要使用多种指标来全面衡量词向量质量。
b.主要评估指标
a.词类比任务准确率
b.词语相似度相关性
c.词聚类质量
d.下游任务性能
e.训练收敛速度
c.基准数据集
a.Google analogy test set
b.WS-353 相似度数据集
c.MEN 相似度数据集
d.Rare Words 相似度数据集
e.SimLex-999 相似度数据集
b.性能优化技巧
a.功能说明
GloVe模型的性能优化可以从多个维度进行。
b.训练优化
a.数据预处理优化
b.内存使用优化
c.并行化训练
d.GPU加速
e.增量学习
c.模型优化
a.向量维度调整
b.正则化技术
c.自适应学习率
d.早停机制
e.模型压缩
c.与Word2Vec性能对比
a.功能说明
对比GloVe和Word2Vec在不同任务上的性能表现。
b.对比维度
a.训练速度和收敛性
b.词向量质量
c.内存使用效率
d.类比推理能力
e.下游任务性能
c.实验结果总结
a.训练速度：GloVe通常更快
b.词类比：GloVe在类比任务上表现更好
c.相似度：两种方法各有优势
d.可扩展性：GloVe更适合大规模训练
e.灵活性：Word2Vec更适合动态数据
05.实际应用案例
a.文本分类应用
a.功能说明
GloVe词向量在文本分类任务中的应用案例。
b.应用场景
a.情感分析
b.主题分类
c.垃圾邮件检测
d.新闻分类
e.评论分析
c.使用方法
a.预训练GloVe词向量
b.句子向量聚合（平均、最大池化等）
c.分类器训练
d.模型调优
e.性能评估
b.信息检索应用
a.功能说明
GloVe在信息检索和搜索系统中的应用。
b.应用方式
a.文档表示学习
b.查询扩展
c.语义搜索
d.推荐系统
e.问答系统
c.技术实现
a.文档向量表示
b.相似度计算
c.排序算法
d.相关性评估
e.系统优化
c.跨语言应用
a.功能说明
GloVe在多语言和跨语言场景下的应用。
b.应用场景
a.机器翻译
b.跨语言信息检索
c.多语言情感分析
d.跨语言词对齐
e.多语言推荐系统
c.实现方法
a.联合训练
b.向量空间对齐
c.迁移学习
d.零样本学习
e.多任务学习
06.高级扩展与应用
a.动态GloVe
a.功能说明
传统GloVe的局限性及动态扩展方法。
b.局限性
a.静态词表示
b.无法处理一词多义
c.上下文不敏感
d.无法适应新词
c.扩展方法
a.上下文相关GloVe
b.多原型GloVe
c.动态更新机制
d.混合模型
e.注意力机制
b.知识增强GloVe
a.功能说明
将外部知识融入GloVe模型的方法。
b.知识来源
a.WordNet语义网络
b.ConceptNet概念网络
c.领域本体
d.知识图谱
e.用户反馈
c.融合方法
a.约束优化
b.多目标学习
c.正则化技术
d.迁移学习
e.元学习
c.大规模分布式训练
a.功能说明
GloVe的大规模分布式训练策略。
b.分布式策略
a.数据并行
b.模型并行
c.参数服务器
d.混合并行
e.容错机制
c.优化技术
a.内存管理
b.通信优化
c.负载均衡
d.缓存策略
e.容错恢复
07.总结与展望
a.GloVe技术总结
a.功能说明
GloVe作为重要的词向量学习技术，具有以下关键贡献。
b.关键贡献
a.结合全局统计和局部上下文
b.数学理论清晰简洁
c.训练效率高效果好
d.在类比任务上表现优异
e.为后续发展奠定基础
c.技术优势
a.全局优化能力强
b.训练收敛速度快
c.参数解释性好
d.易于并行化
e.扩展性强
b.当前挑战
a.功能说明
GloVe面临的挑战和局限性。
b.局限性
a.静态词表示限制
b.上下文信息缺失
c.计算资源需求
d.超参数调优复杂
e.领域适应性有限
c.未来发展方向
a.功能说明
GloVe的未来发展方向。
b.发展方向
a.上下文相关词表示
b.多模态词向量融合
c.自适应学习机制
d.知识增强模型
e.大规模预训练融合
f.效率优化技术
g.解释性增强
h.跨语言和跨领域应用
c.发展趋势
a.与预训练模型融合
b.更高效的学习算法
c.更强的语义表示能力
d.更广泛的应用场景
2.6 FastText
01.模型概述
a.功能说明
FastText是Facebook于2016年提出的词向量学习模型，由Piotr Bojanowski、Armand Joulin、Tomas Mikolov等人开发。FastText扩展了Word2Vec，通过考虑子词信息来处理形态丰富的语言，并支持快速文本分类。
b.发展背景
a.2016年：首次发表"Enriching Word Vectors with Subword Information"
b.2016年：发布开源工具包，支持大规模训练
c.2017年：扩展支持多语言和预训练模型
d.2018年：引入监督学习文本分类器
e.至今：广泛应用于工业界和学术界，成为NLP基础工具之一
c.核心创新
a.子词模型：将词汇分解为字符n-gram，解决OOV问题
b.快速文本分类：基于词向量的线性分类器
c.层次Softmax：优化大规模词汇表训练
d.多语言支持：支持157种语言的预训练模型
d.关键特点
a.处理OOV：通过子词组合表示未见词汇
b.形态学感知：捕捉词根、前缀、后缀等语言特征
c.训练效率高：支持多线程和GPU加速
d.内存占用低：使用哈希技巧优化存储
e.应用场景
a.文本分类和情感分析
b.语言检测和机器翻译
c.信息检索和语义搜索
d.拼写检查和自动纠错
e.推荐系统和用户画像
02.子词模型
a.字符n-gram表示
a.功能说明
FastText将每个词表示为其字符n-gram的集合，包括词本身和前后缀。
b.表示方法
a.词本身：作为特殊的n-gram
b.前缀：词开头的字符序列
c.后缀：词结尾的字符序列
d.边界标记：使用<和>标记词的开始和结束
c.示例说明
词"where"的n-gram表示：
a.词本身：<where>
b.前缀：<wh, <whe, <wher
c.后缀：here>, ere>, re>
d.向量表示
词向量 = 所有n-gram向量的平均值
b.处理OOV问题
a.功能说明
子词模型使FastText能够处理训练时未见过的词汇。
b.解决机制
a.未知词分解为已知的子词
b.子词向量组合生成词向量
c.无需重新训练即可表示新词
c.优势
a.词汇表大小固定
b.模型泛化能力强
c.适合形态丰富的语言
c.代码示例
---
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List, Dict, Tuple, Set
from collections import defaultdict, Counter
import re
class SubwordModel:
"""子词模型实现"""
def __init__(self, min_n: int = 3, max_n: int = 6):
"""
初始化子词模型
Args:
min_n: 最小n-gram长度
max_n: 最大n-gram长度
"""
self.min_n = min_n
self.max_n = max_n
self.word_to_subwords = {}
self.subword_to_idx = {}
self.idx_to_subword = {}
def get_word_ngrams(self, word: str) -> List[str]:
"""
获取词的所有n-gram表示
Args:
word: 输入词汇
Returns:
n-gram列表
"""
word = f"<{word}>" # 添加边界标记
ngrams = []
ngrams.append(word) # 添加词本身
# 生成所有长度的n-gram
for n in range(self.min_n, self.max_n + 1):
for i in range(len(word) - n + 1):
ngram = word[i:i+n]
ngrams.append(ngram)
return ngrams
def build_vocabulary(self, words: List[str]) -> Dict[str, int]:
"""
构建子词词汇表
Args:
words: 词汇列表
Returns:
子词到索引的映射
"""
print("构建子词词汇表...")
subword_counts = Counter()
# 统计所有子词出现频率
for word in words:
ngrams = self.get_word_ngrams(word)
self.word_to_subwords[word] = ngrams
for ngram in ngrams:
subword_counts[ngram] += 1
# 过滤低频子词
min_count = 5
filtered_subwords = {subword for subword, count in subword_counts.items()
if count >= min_count}
# 构建子词到索引的映射
for idx, subword in enumerate(filtered_subwords):
self.subword_to_idx[subword] = idx
self.idx_to_subword[idx] = subword
print(f"子词词汇表大小: {len(filtered_subwords)}")
return self.subword_to_idx
def get_word_vector(self, word: str, subword_embeddings: torch.Tensor) -> torch.Tensor:
"""
通过子词向量计算词向量
Args:
word: 输入词汇
subword_embeddings: 子词嵌入矩阵
Returns:
词向量
"""
if word not in self.word_to_subwords:
# 处理未知词：分解为字符n-gram
ngrams = self.get_word_ngrams(word)
else:
ngrams = self.word_to_subwords[word]
# 获取所有子词的向量
vectors = []
for ngram in ngrams:
if ngram in self.subword_to_idx:
idx = self.subword_to_idx[ngram]
vectors.append(subword_embeddings[idx])
# 计算平均向量
if vectors:
word_vector = torch.mean(torch.stack(vectors), dim=0)
else:
# 如果没有已知子词，返回零向量
word_vector = torch.zeros(subword_embeddings.size(1))
return word_vector
def analyze_subword_coverage(self, test_words: List[str]) -> Dict[str, float]:
"""
分析子词覆盖率
Args:
test_words: 测试词汇列表
Returns:
覆盖率统计
"""
total_words = len(test_words)
covered_words = 0
oov_words = []
for word in test_words:
if word in self.word_to_subwords:
covered_words += 1
else:
# 检查是否可以通过子词表示
ngrams = self.get_word_ngrams(word)
known_ngrams = sum(1 for ngram in ngrams if ngram in self.subword_to_idx)
if known_ngrams > 0:
covered_words += 1
else:
oov_words.append(word)
coverage_rate = covered_words / total_words
oov_rate = len(oov_words) / total_words
return {
'total_words': total_words,
'covered_words': covered_words,
'oov_words': len(oov_words),
'coverage_rate': coverage_rate,
'oov_rate': oov_rate,
'oov_examples': oov_words[:10] # 显示前10个OOV词
}
# 使用示例
print("=== 子词模型演示 ===")
# 示例词汇
sample_words = [
"hello", "world", "fasttext", "embedding", "unseenword"
]
# 创建子词模型
subword_model = SubwordModel(min_n=3, max_n=6)
# 构建词汇表
subword_to_idx = subword_model.build_vocabulary(sample_words)
# 分析词汇表示
print("\n=== 词汇表示分析 ===")
for word in sample_words:
ngrams = subword_model.get_word_ngrams(word)
print(f"词汇: {word}")
print(f" n-gram数量: {len(ngrams)}")
print(f" n-gram列表: {ngrams[:5]}...") # 只显示前5个
# 模拟子词嵌入
embedding_dim = 50
subword_embeddings = torch.randn(len(subword_to_idx), embedding_dim)
# 计算词向量
print("\n=== 词向量计算 ===")
for word in sample_words:
word_vector = subword_model.get_word_vector(word, subword_embeddings)
print(f"词汇: {word}")
print(f" 向量形状: {word_vector.shape}")
print(f" 向量范数: {torch.norm(word_vector).item():.4f}")
# 分析覆盖率
test_words = sample_words + ["newword1", "newword2", "completelyunseen"]
coverage_stats = subword_model.analyze_subword_coverage(test_words)
print("\n=== 子词覆盖率分析 ===")
print(f"总词汇数: {coverage_stats['total_words']}")
print(f"覆盖词汇数: {coverage_stats['covered_words']}")
print(f"OOV词汇数: {coverage_stats['oov_words']}")
print(f"覆盖率: {coverage_stats['coverage_rate']:.4f}")
print(f"OOV率: {coverage_stats['oov_rate']:.4f}")
print(f"OOV示例: {coverage_stats['oov_examples']}")
---
03.FastText模型架构
a.CBOW与Skip-gram扩展
a.功能说明
FastText扩展了Word2Vec的CBOW和Skip-gram模型，使其能够处理子词信息。
b.CBOW扩展
a.输入：上下文子词
b.输出：中心子词
c.训练：根据上下文子词预测中心子词
d.向量聚合：子词向量平均得到词向量
c.Skip-gram扩展
a.输入：中心子词
b.输出：上下文子词
c.训练：根据中心子词预测上下文子词
d.向量聚合：子词向量平均得到词向量
b.模型架构设计
a.嵌入层
a.子词嵌入矩阵：将子词映射为向量
b.词向量聚合：通过平均或求和聚合子词向量
c.输出层：预测目标子词的概率分布
b.层次Softmax
a.霍夫曼树优化：减少计算复杂度
b.负采样：提高训练效率
c.批量训练：支持大规模数据集
c.代码示例
---
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List, Dict, Tuple, Optional
import numpy as np
import time
class FastTextModel(nn.Module):
"""FastText模型实现"""
def __init__(self, vocab_size: int, embedding_dim: int,
min_n: int = 3, max_n: int = 6,
model_type: str = 'cbow'):
"""
初始化FastText模型
Args:
vocab_size: 词汇表大小
embedding_dim: 词向量维度
min_n: 最小n-gram长度
max_n: 最大n-gram长度
model_type: 模型类型 ('cbow' 或 'skipgram')
"""
super(FastTextModel, self).__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
self.min_n = min_n
self.max_n = max_n
self.model_type = model_type.lower()
# 子词嵌入层
self.subword_embeddings = nn.Embedding(vocab_size, embedding_dim)
# 输出层
self.output_layer = nn.Linear(embedding_dim, vocab_size)
# 初始化权重
self._init_weights()
def _init_weights(self):
"""初始化模型权重"""
# 子词嵌入使用均匀分布初始化
nn.init.uniform_(self.subword_embeddings.weight,
-0.1/self.embedding_dim, 0.1/self.embedding_dim)
# 输出层使用Xavier初始化
nn.init.xavier_uniform_(self.output_layer.weight)
nn.init.zeros_(self.output_layer.bias)
def forward(self, subword_indices: torch.Tensor) -> torch.Tensor:
"""
前向传播
Args:
subword_indices: 子词索引 [batch_size, num_subwords]
Returns:
预测概率 [batch_size, vocab_size]
"""
batch_size, num_subwords = subword_indices.shape
# 获取子词向量 [batch_size, num_subwords, embedding_dim]
subword_vectors = self.subword_embeddings(subword_indices)
# 聚合子词向量 [batch_size, embedding_dim]
if self.model_type == 'cbow':
# CBOW: 平均所有子词向量
word_vectors = torch.mean(subword_vectors, dim=1)
elif self.model_type == 'skipgram':
# Skip-gram: 每个子词单独处理
word_vectors = subword_vectors.view(-1, self.embedding_dim)
batch_size = batch_size * num_subwords
else:
raise ValueError(f"不支持的模型类型: {self.model_type}")
# 通过输出层预测
output_scores = self.output_layer(word_vectors)
return output_scores
def get_word_vector(self, word: str,
subword_model: SubwordModel) -> torch.Tensor:
"""
获取词向量
Args:
word: 输入词汇
subword_model: 子词模型
Returns:
词向量
"""
# 获取词的子词
if word in subword_model.word_to_subwords:
subwords = subword_model.word_to_subwords[word]
else:
subwords = subword_model.get_word_ngrams(word)
# 获取子词索引
subword_indices = []
for subword in subwords:
if subword in subword_model.subword_to_idx:
subword_indices.append(subword_model.subword_to_idx[subword])
if not subword_indices:
return torch.zeros(self.embedding_dim)
# 转换为张量
subword_tensor = torch.tensor([subword_indices], dtype=torch.long)
# 获取子词向量并平均
with torch.no_grad():
subword_vectors = self.subword_embeddings(subword_tensor)
word_vector = torch.mean(subword_vectors, dim=0)
return word_vector
def get_subword_vector(self, subword_idx: int) -> torch.Tensor:
"""获取子词向量"""
return self.subword_embeddings.weight[subword_idx]
# 使用示例
print("=== FastText模型架构演示 ===")
# 模型参数
vocab_size = 10000 # 假设的子词词汇表大小
embedding_dim = 100
min_n = 3
max_n = 6
# 创建FastText模型
cbow_model = FastTextModel(vocab_size, embedding_dim, min_n, max_n, 'cbow')
skipgram_model = FastTextModel(vocab_size, embedding_dim, min_n, max_n, 'skipgram')
print(f"CBOW模型参数:")
print(f" 词汇表大小: {cbow_model.vocab_size}")
print(f" 词向量维度: {cbow_model.embedding_dim}")
print(f" n-gram范围: {cbow_model.min_n}-{cbow_model.max_n}")
print(f"\nSkip-gram模型参数:")
print(f" 词汇表大小: {skipgram_model.vocab_size}")
print(f" 词向量维度: {skipgram_model.embedding_dim}")
print(f" n-gram范围: {skipgram_model.min_n}-{skipgram_model.max_n}")
# 模拟输入数据
batch_size = 4
num_subwords = 5 # 假设每个词平均有5个子词
# CBOW前向传播
cbow_subword_indices = torch.randint(0, vocab_size, (batch_size, num_subwords))
cbow_output = cbow_model(cbow_subword_indices)
print(f"\nCBOW输入形状: {cbow_subword_indices.shape}")
print(f"CBOW输出形状: {cbow_output.shape}")
# Skip-gram前向传播
skipgram_subword_indices = torch.randint(0, vocab_size, (batch_size, num_subwords))
skipgram_output = skipgram_model(skipgram_subword_indices)
print(f"\nSkip-gram输入形状: {skipgram_subword_indices.shape}")
print(f"Skip-gram输出形状: {skipgram_output.shape}")
# 创建子词模型
subword_model = SubwordModel(min_n, max_n)
subword_to_idx = subword_model.build_vocabulary(["hello", "world", "fasttext"])
# 获取词向量
test_word = "hello"
word_vector = cbow_model.get_word_vector(test_word, subword_model)
print(f"\n词 '{test_word}' 的向量形状: {word_vector.shape}")
print(f"词 '{test_word}' 的向量范数: {torch.norm(word_vector).item():.4f}")
---
04.快速文本分类器
a.分类器架构
a.功能说明
FastText包含一个高效的线性文本分类器，基于平均词向量。
b.架构设计
a.词向量平均：对文本中所有词向量求平均
b.线性变换：通过权重矩阵映射到类别空间
c.层次Softmax：优化多类分类计算
d.损失函数：使用负采样或层次Softmax
c.训练特点
a.监督学习：使用标注数据训练
b.在线学习：支持增量更新模型
c.高效推理：分类速度极快
d.内存友好：模型参数少
b.代码示例
---
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List, Dict, Tuple, Optional
import numpy as np
import time
class FastTextClassifier(nn.Module):
"""FastText文本分类器实现"""
def __init__(self, vocab_size: int, embedding_dim: int, num_classes: int,
min_n: int = 3, max_n: int = 6):
"""
初始化FastText分类器
Args:
vocab_size: 词汇表大小
embedding_dim: 词向量维度
num_classes: 类别数量
min_n: 最小n-gram长度
max_n: 最大n-gram长度
"""
super(FastTextClassifier, self).__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
self.num_classes = num_classes
self.min_n = min_n
self.max_n = max_n
# 词嵌入层
self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
# 分类层
self.classifier = nn.Linear(embedding_dim, num_classes)
# 初始化权重
self._init_weights()
def _init_weights(self):
"""初始化模型权重"""
# 词嵌入使用均匀分布初始化
nn.init.uniform_(self.word_embeddings.weight,
-0.1/self.embedding_dim, 0.1/self.embedding_dim)
# 分类层使用Xavier初始化
nn.init.xavier_uniform_(self.classifier.weight)
nn.init.zeros_(self.classifier.bias)
def forward(self, word_indices: torch.Tensor,
word_counts: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
前向传播
Args:
word_indices: 词索引 [batch_size, seq_len]
word_counts: 词计数 [batch_size, seq_len] (可选)
Returns:
分类概率 [batch_size, num_classes]
"""
batch_size, seq_len = word_indices.shape
# 获取词向量 [batch_size, seq_len, embedding_dim]
word_vectors = self.word_embeddings(word_indices)
# 计算文本表示
if word_counts is not None:
# 加权平均：根据词频加权
word_weights = word_counts.float().unsqueeze(-1) # [batch_size, seq_len, 1]
weighted_vectors = word_vectors * word_weights
text_vector = torch.sum(weighted_vectors, dim=1) / torch.sum(word_weights, dim=1)
else:
# 简单平均：所有词向量平均
text_vector = torch.mean(word_vectors, dim=1) # [batch_size, embedding_dim]
# 通过分类器
logits = self.classifier(text_vector) # [batch_size, num_classes]
return logits
def predict(self, word_indices: torch.Tensor,
word_counts: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
预测类别
Args:
word_indices: 词索引 [batch_size, seq_len]
word_counts: 词计数 [batch_size, seq_len] (可选)
Returns:
预测类别 [batch_size]
"""
logits = self.forward(word_indices, word_counts)
probabilities = F.softmax(logits, dim=1)
predictions = torch.argmax(probabilities, dim=1)
return predictions
def get_text_vector(self, word_indices: torch.Tensor,
word_counts: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
获取文本向量表示
Args:
word_indices: 词索引 [batch_size, seq_len]
word_counts: 词计数 [batch_size, seq_len] (可选)
Returns:
文本向量 [batch_size, embedding_dim]
"""
batch_size, seq_len = word_indices.shape
# 获取词向量 [batch_size, seq_len, embedding_dim]
word_vectors = self.word_embeddings(word_indices)
# 计算文本表示
if word_counts is not None:
# 加权平均：根据词频加权
word_weights = word_counts.float().unsqueeze(-1) # [batch_size, seq_len, 1]
weighted_vectors = word_vectors * word_weights
text_vector = torch.sum(weighted_vectors, dim=1) / torch.sum(word_weights, dim=1)
else:
# 简单平均：所有词向量平均
text_vector = torch.mean(word_vectors, dim=1) # [batch_size, embedding_dim]
return text_vector
class FastTextTrainer:
"""FastText分类器训练器"""
def __init__(self, model: FastTextClassifier, learning_rate: float = 0.1):
"""
初始化训练器
Args:
model: FastText分类器模型
learning_rate: 学习率
"""
self.model = model
self.learning_rate = learning_rate
self.optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
self.criterion = nn.CrossEntropyLoss()
self.training_losses = []
self.training_accuracies = []
def train_epoch(self, word_indices_batch: List[torch.Tensor],
labels_batch: List[torch.Tensor],
word_counts_batch: Optional[List[torch.Tensor]] = None,
batch_size: int = 32) -> Dict[str, float]:
"""
训练一个epoch
Args:
word_indices_batch: 批次词索引列表
labels_batch: 批次标签列表
word_counts_batch: 批次词计数列表
batch_size: 批大小
Returns:
训练统计信息
"""
self.model.train()
total_loss = 0.0
correct_predictions = 0
total_predictions = 0
# 随机打乱数据
indices = np.random.permutation(len(word_indices_batch))
# 分批训练
for i in range(0, len(word_indices_batch), batch_size):
batch_indices = indices[i:i+batch_size]
# 准备批次数据
word_indices_list = [word_indices_batch[idx] for idx in batch_indices]
labels_list = [labels_batch[idx] for idx in batch_indices]
if word_counts_batch:
word_counts_list = [word_counts_batch[idx] for idx in batch_indices]
else:
word_counts_list = None
# 填充序列到相同长度
max_len = max(len(indices) for indices in word_indices_list)
padded_word_indices = []
padded_word_counts = []
padded_labels = []
for j in range(len(word_indices_list)):
word_indices = word_indices_list[j]
labels = labels_list[j]
# 填充词索引
if len(word_indices) < max_len:
padding = torch.zeros(max_len - len(word_indices), dtype=torch.long)
padded_word_indices = torch.cat([word_indices, padding])
else:
padded_word_indices = word_indices
# 填充标签
if len(labels) < max_len:
padding = torch.zeros(max_len - len(labels), dtype=torch.long)
padded_labels = torch.cat([labels, padding])
else:
padded_labels = labels
padded_word_indices.append(padded_word_indices)
padded_word_counts.append(None) # 简化处理
padded_labels.append(padded_labels)
# 转换为张量
word_indices_tensor = torch.stack(padded_word_indices)
labels_tensor = torch.stack(padded_labels)
# 前向传播
self.optimizer.zero_grad()
logits = self.model(word_indices_tensor)
# 计算损失（只考虑非填充部分）
mask = (word_indices_tensor != 0).float()
loss = self.criterion(logits, labels_tensor)
masked_loss = (loss * mask).sum() / mask.sum()
# 反向传播
masked_loss.backward()
self.optimizer.step()
# 统计
total_loss += masked_loss.item()
# 计算准确率
predictions = torch.argmax(logits, dim=2)
correct = (predictions == labels_tensor) & (word_indices_tensor != 0)
correct_predictions += correct.sum().item()
total_predictions += mask.sum().item()
avg_loss = total_loss / len(word_indices_batch)
accuracy = correct_predictions / total_predictions
self.training_losses.append(avg_loss)
self.training_accuracies.append(accuracy)
return {
'loss': avg_loss,
'accuracy': accuracy,
'total_loss': total_loss,
'correct_predictions': correct_predictions,
'total_predictions': total_predictions
}
def train(self, word_indices_list: List[torch.Tensor],
labels_list: List[torch.Tensor],
word_counts_list: Optional[List[torch.Tensor]] = None,
epochs: int = 10, batch_size: int = 32,
validation_data: Optional[Tuple] = None) -> Dict[str, List[float]]:
"""
完整训练过程
Args:
word_indices_list: 词索引列表
labels_list: 标签列表
word_counts_list: 词计数列表
epochs: 训练轮数
batch_size: 批大小
validation_data: 验证数据
Returns:
训练历史
"""
print(f"开始训练FastText分类器...")
print(f"训练数据量: {len(word_indices_list)}")
print(f"训练轮数: {epochs}")
print(f"批大小: {batch_size}")
training_history = {
'train_losses': [],
'train_accuracies': [],
'val_losses': [],
'val_accuracies': []
}
for epoch in range(epochs):
print(f"\nEpoch {epoch + 1}/{epochs}")
# 训练
train_stats = self.train_epoch(
word_indices_list, labels_list, word_counts_list, batch_size
)
training_history['train_losses'].append(train_stats['loss'])
training_history['train_accuracies'].append(train_stats['accuracy'])
print(f" 训练损失: {train_stats['loss']:.4f}")
print(f" 训练准确率: {train_stats['accuracy']:.4f}")
# 验证
if validation_data:
val_word_indices, val_labels, val_word_counts = validation_data
val_stats = self.train_epoch(
val_word_indices, val_labels, val_word_counts, batch_size
)
training_history['val_losses'].append(val_stats['loss'])
training_history['val_accuracies'].append(val_stats['accuracy'])
print(f" 验证损失: {val_stats['loss']:.4f}")
print(f" 验证准确率: {val_stats['accuracy']:.4f}")
print(f"\n训练完成!")
return training_history
# 使用示例
print("=== FastText分类器演示 ===")
# 模型参数
vocab_size = 5000
embedding_dim = 100
num_classes = 10
# 创建分类器
classifier = FastTextClassifier(vocab_size, embedding_dim, num_classes)
print(f"分类器参数:")
print(f" 词汇表大小: {classifier.vocab_size}")
print(f" 词向量维度: {classifier.embedding_dim}")
print(f" 类别数量: {classifier.num_classes}")
# 创建训练器
trainer = FastTextTrainer(classifier, learning_rate=0.01)
# 模拟训练数据
batch_size = 8
seq_len = 10
num_batches = 5
word_indices_list = []
labels_list = []
for _ in range(num_batches):
# 随机生成词索引和标签
word_indices = torch.randint(0, vocab_size, (batch_size, seq_len))
labels = torch.randint(0, num_classes, (batch_size,))
word_indices_list.append(word_indices)
labels_list.append(labels)
# 训练模型
training_history = trainer.train(word_indices_list, labels_list, epochs=5, batch_size=4)
# 绘制训练曲线
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(training_history['train_losses'], label='训练损失', color='blue')
if training_history['val_losses']:
plt.plot(training_history['val_losses'], label='验证损失', color='red')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('FastText分类器训练损失')
plt.legend()
plt.grid(True, alpha=0.3)
plt.subplot(1, 2, 2)
plt.plot(training_history['train_accuracies'], label='训练准确率', color='blue')
if training_history['val_accuracies']:
plt.plot(training_history['val_accuracies'], label='验证准确率', color='red')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.title('FastText分类器训练准确率')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 测试分类器
test_word_indices = torch.randint(0, vocab_size, (2, seq_len))
predictions = classifier.predict(test_word_indices)
text_vectors = classifier.get_text_vector(test_word_indices)
print(f"\n测试结果:")
print(f" 输入形状: {test_word_indices.shape}")
print(f" 预测类别: {predictions}")
print(f" 文本向量形状: {text_vectors.shape}")
---
05.性能优化与实现技巧
a.训练优化
a.功能说明
FastText提供了多种优化技术来提高训练和推理效率。
b.优化技术
a.多线程训练：支持多CPU核心并行训练
b.GPU加速：利用CUDA加速矩阵运算
c.负采样：减少计算复杂度
d.量化：减少内存占用和加速推理
c.实现技巧
a.哈希表优化：使用开放寻址哈希表
b.内存映射：大模型使用内存映射文件
c.预计算：缓存常用计算结果
d.批量处理：优化矩阵运算
b.推理优化
a.功能说明
FastText的推理速度极快，适合实时应用。
b.优化技术
a.模型压缩：减少模型大小
b.量化推理：使用8位或16位量化
c.缓存机制：缓存常用词向量
d.并行推理：批量处理多个请求
c.代码示例
---
import torch
import torch.nn as nn
import torch.nn.functional as F
import time
from typing import List, Dict, Tuple, Optional
class FastTextOptimizer:
"""FastText性能优化器"""
def __init__(self, model: FastTextModel):
"""
初始化优化器
Args:
model: FastText模型
"""
self.model = model
def optimize_for_inference(self) -> FastTextModel:
"""
为推理优化模型
Returns:
优化后的模型
"""
print("优化FastText模型以加速推理...")
# 创建优化后的模型
optimized_model = type(self.model)(
vocab_size=self.model.vocab_size,
embedding_dim=self.model.embedding_dim,
min_n=self.model.min_n,
max_n=self.model.max_n,
model_type=self.model.model_type
)
# 复制权重
optimized_model.load_state_dict(self.model.state_dict())
# 设置为评估模式
optimized_model.eval()
# 量化嵌入层（可选）
# optimized_model.subword_embeddings = torch.quantization.quantize_dynamic(
# optimized_model.subword_embeddings, {torch.float}, dtype=torch.qint8
# )
print("模型优化完成")
return optimized_model
def benchmark_inference_speed(self, model: FastTextModel,
subword_indices: torch.Tensor,
num_runs: int = 100) -> Dict[str, float]:
"""
基准推理速度
Args:
model: FastText模型
subword_indices: 子词索引
num_runs: 运行次数
Returns:
速度统计
"""
print(f"基准测试推理速度，运行次数: {num_runs}")
model.eval()
with torch.no_grad():
start_time = time.time()
for _ in range(num_runs):
output = model(subword_indices)
end_time = time.time()
total_time = end_time - start_time
avg_time_per_run = total_time / num_runs
throughput = num_runs / total_time
return {
'total_time': total_time,
'avg_time_per_run': avg_time_per_run,
'throughput': throughput,
'output_shape': output.shape
}
def analyze_model_size(self, model: FastTextModel) -> Dict[str, float]:
"""
分析模型大小
Args:
model: FastText模型
Returns:
模型大小统计
"""
param_size = 0
buffer_size = 0
for name, param in model.named_parameters():
param_size += param.nelement() * param.element_size()
for name, buffer in model.named_buffers():
buffer_size += buffer.nelement() * buffer.element_size()
total_size = param_size + buffer_size
return {
'param_size_mb': param_size / (1024 * 1024),
'buffer_size_mb': buffer_size / (1024 * 1024),
'total_size_mb': total_size / (1024 * 1024),
'vocab_size': model.vocab_size,
'embedding_dim': model.embedding_dim,
'total_params': model.vocab_size * model.embedding_dim
}
# 使用示例
print("=== FastText性能优化演示 ===")
# 创建模型
vocab_size = 10000
embedding_dim = 100
model = FastTextModel(vocab_size, embedding_dim, model_type='cbow')
# 分析模型大小
size_stats = FastTextOptimizer(model).analyze_model_size(model)
print(f"\n=== 模型大小分析 ===")
print(f" 参数大小: {size_stats['param_size_mb']:.2f} MB")
print(f" 缓冲区大小: {size_stats['buffer_size_mb']:.2f} MB")
print(f" 总大小: {size_stats['total_size_mb']:.2f} MB")
print(f" 词汇表大小: {size_stats['vocab_size']}")
print(f" 词向量维度: {size_stats['embedding_dim']}")
print(f" 总参数量: {size_stats['total_params']:,}")
# 基准测试推理速度
batch_size = 32
num_subwords = 5
subword_indices = torch.randint(0, vocab_size, (batch_size, num_subwords))
speed_stats = FastTextOptimizer(model).benchmark_inference_speed(
model, subword_indices, num_runs=100
)
print(f"\n=== 推理速度基准测试 ===")
print(f" 总时间: {speed_stats['total_time']:.4f} 秒")
print(f" 平均每次运行时间: {speed_stats['avg_time_per_run']:.6f} 秒")
print(f" 吞吐量: {speed_stats['throughput']:.2f} 次/秒")
print(f" 输出形状: {speed_stats['output_shape']}")
# 优化模型
optimized_model = FastTextOptimizer(model).optimize_for_inference()
# 再次基准测试
optimized_speed_stats = FastTextOptimizer(optimized_model).benchmark_inference_speed(
optimized_model, subword_indices, num_runs=100
)
print(f"\n=== 优化后推理速度基准测试 ===")
print(f" 总时间: {optimized_speed_stats['total_time']:.4f} 秒")
print(f" 平均每次运行时间: {optimized_speed_stats['avg_time_per_run']:.6f} 秒")
print(f" 吞吐量: {optimized_speed_stats['throughput']:.2f} 次/秒")
print(f" 速度提升: {optimized_speed_stats['throughput']/speed_stats['throughput']:.2f}x")
---
06.实际应用案例
a.文本分类应用
a.功能说明
FastText在文本分类任务中有广泛应用，特别是在资源受限的环境中。
b.应用场景
a.新闻分类：将新闻文章分类到不同主题
b.情感分析：判断文本的情感倾向
c.垃圾邮件检测：识别垃圾邮件
d.语言检测：识别文本的语言
c.实现案例
a.数据预处理：文本清洗和分词
b.模型训练：使用标注数据训练分类器
c.模型评估：使用准确率、F1分数等指标
d.模型部署：将训练好的模型部署到生产环境
b.词向量应用
a.功能说明
FastText词向量可以用于各种NLP任务。
b.应用场景
a.语义搜索：基于词向量相似度的搜索
b.文档聚类：将相似文档分组
c.关键词提取：从文档中提取关键词
d.推荐系统：基于用户兴趣推荐内容
c.多语言应用
a.功能说明
FastText支持157种语言的预训练模型。
b.应用场景
a.跨语言信息检索：多语言文档检索
b.机器翻译：作为翻译模型的输入
c.跨语言情感分析：分析不同语言的情感
d.低资源语言处理：为数据稀缺的语言提供基础模型
07.总结与展望
a.FastText技术总结
a.功能说明
FastText作为重要的词向量学习技术，具有以下关键贡献。
b.关键贡献
a.子词模型：解决OOV问题，提高模型泛化能力
b.快速文本分类：提供高效的线性分类器
c.多语言支持：支持157种语言的预训练模型
d.开源实现：提供高质量的开源工具包
c.技术优势
a.训练效率高：支持多线程和GPU加速
b.内存占用低：使用哈希技巧优化存储
c.推理速度快：适合实时应用
d.易于使用：提供简单的命令行工具
b.当前局限性
a.功能说明
FastText也存在一些局限性。
b.局限性
a.上下文窗口有限：无法捕捉长距离依赖
b.子词组合简单：仅使用字符n-gram，未考虑更复杂的语言学特征
c.预训练模型质量：相比现代预训练模型仍有差距
d.监督学习限制：分类器表达能力有限
c.未来发展方向
a.功能说明
FastText的未来发展方向。
b.发展方向
a.更复杂的子词模型：考虑语言学特征
b.与Transformer结合：结合注意力机制
c.多模态学习：融合图像、音频等信息
d.自适应学习：根据任务动态调整模型
e.更大规模预训练：使用更多数据训练更强大的模型
3 序列模型
3.1 RNN在NLP中的应用
01.循环神经网络基础
a.RNN核心思想
a.基本原理
循环神经网络通过在时间维度上共享参数，能够处理任意长度的序列数据，特别适合自然语言处理任务。RNN的核心在于隐藏状态的循环更新机制，每个时间步的隐藏状态不仅依赖当前输入，还依赖前一时刻的隐藏状态，从而实现对序列历史信息的记忆。
b.基础实现
---
import torch
import torch.nn as nn
class SimpleRNN(nn.Module):
"""简单RNN实现"""
def __init__(self, input_size, hidden_size, output_size):
super(SimpleRNN, self).__init__()
self.hidden_size = hidden_size
# 输入到隐藏层的权重矩阵
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
# 隐藏层到输出层的权重矩阵
self.h2o = nn.Linear(hidden_size, output_size)
# 激活函数
self.tanh = nn.Tanh()
def forward(self, input_seq, hidden):
"""
前向传播
Args:
input_seq: 输入序列 [seq_len, batch_size, input_size]
hidden: 初始隐藏状态 [batch_size, hidden_size]
Returns:
outputs: 输出序列 [seq_len, batch_size, output_size]
hidden: 最终隐藏状态
"""
outputs = []
for i in range(input_seq.size(0)):
# 拼接当前输入和前一隐藏状态
combined = torch.cat((input_seq[i], hidden), 1)
# 计算新的隐藏状态
hidden = self.tanh(self.i2h(combined))
# 计算输出
output = self.h2o(hidden)
outputs.append(output)
return torch.stack(outputs), hidden
def init_hidden(self, batch_size):
"""初始化隐藏状态为零向量"""
return torch.zeros(batch_size, self.hidden_size)
---
b.网络结构特点
a.参数共享机制
RNN采用参数共享机制，所有时间步使用相同的权重矩阵，大幅减少了模型参数量。网络包含输入到隐藏层的权重矩阵、隐藏层到隐藏层的循环权重矩阵、隐藏层到输出层的权重矩阵三个核心参数。这种结构使得模型能够处理变长序列，同时保持模型复杂度可控。
b.结构可视化
---
# 使用PyTorch内置RNN模块
import torch.nn as nn
# 定义RNN层
rnn = nn.RNN(
input_size=100, # 输入特征维度
hidden_size=256, # 隐藏状态维度
num_layers=2, # RNN层数
batch_first=True, # 输入格式 [batch, seq, feature]
dropout=0.2 # Dropout比例
)
# 输入数据：[batch_size=32, seq_len=20, input_size=100]
input_seq = torch.randn(32, 20, 100)
h0 = torch.zeros(2, 32, 256) # 初始隐藏状态 [num_layers, batch, hidden]
# 前向传播
output, hn = rnn(input_seq, h0)
# output: [32, 20, 256] - 每个时间步的输出
# hn: [2, 32, 256] - 每层的最终隐藏状态
print(f"输出形状: {output.shape}")
print(f"最终隐藏状态形状: {hn.shape}")
print(f"参数量: {sum(p.numel() for p in rnn.parameters())}")
---
c.前向传播过程
a.计算流程
在每个时间步t，RNN接收当前输入和前一时刻的隐藏状态，通过非线性激活函数计算新的隐藏状态。隐藏状态的更新公式结合了当前输入的线性变换和前一隐藏状态的循环变换，通常使用tanh或ReLU作为激活函数。最终的输出通过隐藏状态的线性变换得到，可以是分类概率或连续值。
b.手动实现前向传播
---
import torch
import torch.nn.functional as F
def rnn_forward_step(x_t, h_prev, W_ih, W_hh, b_h, W_ho, b_o):
"""
单步RNN前向传播
Args:
x_t: 当前输入 [batch_size, input_size]
h_prev: 前一隐藏状态 [batch_size, hidden_size]
W_ih: 输入到隐藏权重 [hidden_size, input_size]
W_hh: 隐藏到隐藏权重 [hidden_size, hidden_size]
b_h: 隐藏层偏置 [hidden_size]
W_ho: 隐藏到输出权重 [output_size, hidden_size]
b_o: 输出层偏置 [output_size]
Returns:
h_t: 当前隐藏状态
y_t: 当前输出
"""
# 计算新的隐藏状态: h_t = tanh(W_ih @ x_t + W_hh @ h_prev + b_h)
h_t = torch.tanh(
torch.matmul(x_t, W_ih.t()) +
torch.matmul(h_prev, W_hh.t()) +
b_h
)
# 计算输出: y_t = W_ho @ h_t + b_o
y_t = torch.matmul(h_t, W_ho.t()) + b_o
return h_t, y_t
# 示例使用
batch_size, input_size, hidden_size, output_size = 4, 10, 20, 5
x_t = torch.randn(batch_size, input_size)
h_prev = torch.zeros(batch_size, hidden_size)
# 初始化权重
W_ih = torch.randn(hidden_size, input_size)
W_hh = torch.randn(hidden_size, hidden_size)
b_h = torch.randn(hidden_size)
W_ho = torch.randn(output_size, hidden_size)
b_o = torch.randn(output_size)
h_t, y_t = rnn_forward_step(x_t, h_prev, W_ih, W_hh, b_h, W_ho, b_o)
print(f"隐藏状态形状: {h_t.shape}") # [4, 20]
print(f"输出形状: {y_t.shape}") # [4, 5]
---
d.反向传播机制
a.BPTT算法
RNN的训练采用时间反向传播算法（BPTT），梯度需要沿着时间步反向传播。由于参数在时间维度上共享，梯度会在每个时间步累积。这种机制使得模型能够学习序列中的长期依赖关系，但也带来了梯度消失或梯度爆炸的问题，特别是在处理长序列时。
b.训练示例
---
import torch
import torch.nn as nn
import torch.optim as optim
# 定义简单的RNN语言模型
class RNNLanguageModel(nn.Module):
def __init__(self, vocab_size, embed_size, hidden_size):
super(RNNLanguageModel, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size)
self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True)
self.fc = nn.Linear(hidden_size, vocab_size)
def forward(self, x, hidden=None):
# x: [batch, seq_len]
embedded = self.embedding(x) # [batch, seq_len, embed_size]
output, hidden = self.rnn(embedded, hidden) # [batch, seq_len, hidden]
logits = self.fc(output) # [batch, seq_len, vocab_size]
return logits, hidden
# 训练配置
vocab_size, embed_size, hidden_size = 1000, 128, 256
model = RNNLanguageModel(vocab_size, embed_size, hidden_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 模拟训练数据 [batch_size=16, seq_len=20]
input_seq = torch.randint(0, vocab_size, (16, 20))
target_seq = torch.randint(0, vocab_size, (16, 20))
# 训练一步
model.train()
optimizer.zero_grad()
logits, _ = model(input_seq) # [16, 20, 1000]
# 重塑为 [batch*seq_len, vocab_size] 和 [batch*seq_len]
loss = criterion(logits.view(-1, vocab_size), target_seq.view(-1))
loss.backward() # BPTT反向传播
# 梯度裁剪防止梯度爆炸
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
optimizer.step()
print(f"损失: {loss.item():.4f}")
print(f"梯度范数: {sum(p.grad.norm().item() for p in model.parameters() if p.grad is not None):.4f}")
---
02.RNN在NLP中的典型应用
a.语言模型
a.任务定义
语言模型的目标是预测给定上文条件下下一个词的概率分布。RNN通过逐词处理文本序列，在每个位置输出词汇表上的概率分布，实现对自然语言的统计建模。
b.实现示例
---
import torch
import torch.nn as nn
import torch.nn.functional as F
class CharRNNLanguageModel(nn.Module):
"""字符级RNN语言模型"""
def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2):
super(CharRNNLanguageModel, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
self.embedding = nn.Embedding(vocab_size, embed_size)
self.rnn = nn.RNN(embed_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, vocab_size)
def forward(self, x, hidden=None):
embedded = self.embedding(x)
output, hidden = self.rnn(embedded, hidden)
logits = self.fc(output)
return logits, hidden
def generate(self, start_char, length=100, temperature=1.0):
"""生成文本"""
self.eval()
with torch.no_grad():
input_char = torch.tensor([[start_char]])
hidden = None
generated = [start_char]
for _ in range(length):
logits, hidden = self.forward(input_char, hidden)
# 应用温度参数
probs = F.softmax(logits[0, -1] / temperature, dim=0)
# 采样下一个字符
next_char = torch.multinomial(probs, 1).item()
generated.append(next_char)
input_char = torch.tensor([[next_char]])
return generated
# 使用示例
vocab_size = 100
model = CharRNNLanguageModel(vocab_size, 64, 128, 2)
generated_text = model.generate(start_char=0, length=50, temperature=0.8)
print(f"生成的字符序列: {generated_text[:20]}")
---
b.文本分类
a.任务特点
文本分类需要将整个文本序列映射为固定维度的向量表示，然后进行分类。RNN通过逐词处理文本，最终的隐藏状态包含了整个序列的信息，可以作为文本的语义表示。
b.分类器实现
---
import torch
import torch.nn as nn
class RNNTextClassifier(nn.Module):
"""RNN文本分类器"""
def __init__(self, vocab_size, embed_size, hidden_size, num_classes, num_layers=2):
super(RNNTextClassifier, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
self.rnn = nn.RNN(embed_size, hidden_size, num_layers,
batch_first=True, dropout=0.3)
self.fc = nn.Linear(hidden_size, num_classes)
self.dropout = nn.Dropout(0.5)
def forward(self, x):
"""
Args:
x: [batch_size, seq_len]
Returns:
logits: [batch_size, num_classes]
"""
embedded = self.embedding(x) # [batch, seq_len, embed]
output, hidden = self.rnn(embedded) # output: [batch, seq_len, hidden]
# 使用最后一个时间步的隐藏状态
last_hidden = output[:, -1, :] # [batch, hidden]
last_hidden = self.dropout(last_hidden)
logits = self.fc(last_hidden) # [batch, num_classes]
return logits
# 双向RNN分类器
class BiRNNTextClassifier(nn.Module):
"""双向RNN文本分类器"""
def __init__(self, vocab_size, embed_size, hidden_size, num_classes):
super(BiRNNTextClassifier, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
# bidirectional=True使用双向RNN
self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True,
bidirectional=True)
# 双向RNN输出维度是hidden_size*2
self.fc = nn.Linear(hidden_size * 2, num_classes)
def forward(self, x):
embedded = self.embedding(x)
output, _ = self.rnn(embedded)
# 平均池化所有时间步
pooled = torch.mean(output, dim=1) # [batch, hidden*2]
logits = self.fc(pooled)
return logits
# 使用示例
vocab_size, embed_size, hidden_size, num_classes = 5000, 128, 256, 4
model = BiRNNTextClassifier(vocab_size, embed_size, hidden_size, num_classes)
# 模拟输入 [batch=8, seq_len=50]
input_text = torch.randint(1, vocab_size, (8, 50))
logits = model(input_text)
predictions = torch.argmax(logits, dim=1)
print(f"预测类别: {predictions}")
---
c.序列标注
a.任务描述
序列标注为序列中的每个元素分配一个标签，输入和输出序列长度相同。RNN在每个时间步都产生输出，天然适合这类任务。
b.标注模型实现
---
import torch
import torch.nn as nn
class RNNSequenceTagger(nn.Module):
"""RNN序列标注模型（如命名实体识别）"""
def __init__(self, vocab_size, embed_size, hidden_size, num_tags):
super(RNNSequenceTagger, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
# 双向RNN捕捉前后文信息
self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True,
bidirectional=True)
self.fc = nn.Linear(hidden_size * 2, num_tags)
def forward(self, x):
"""
Args:
x: [batch_size, seq_len]
Returns:
logits: [batch_size, seq_len, num_tags]
"""
embedded = self.embedding(x) # [batch, seq_len, embed]
output, _ = self.rnn(embedded) # [batch, seq_len, hidden*2]
logits = self.fc(output) # [batch, seq_len, num_tags]
return logits
# 训练示例
vocab_size, embed_size, hidden_size = 10000, 100, 128
num_tags = 9 # BIO标注：B-PER, I-PER, B-LOC, I-LOC, B-ORG, I-ORG, O等
model = RNNSequenceTagger(vocab_size, embed_size, hidden_size, num_tags)
criterion = nn.CrossEntropyLoss(ignore_index=0) # 忽略padding
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 模拟数据
input_seq = torch.randint(1, vocab_size, (16, 30)) # [batch, seq_len]
target_tags = torch.randint(0, num_tags, (16, 30)) # [batch, seq_len]
# 训练步骤
model.train()
optimizer.zero_grad()
logits = model(input_seq) # [16, 30, 9]
# 计算损失
loss = criterion(logits.view(-1, num_tags), target_tags.view(-1))
loss.backward()
optimizer.step()
# 预测
model.eval()
with torch.no_grad():
predictions = torch.argmax(logits, dim=-1) # [16, 30]
print(f"预测标签形状: {predictions.shape}")
---
d.机器翻译
a.编码器-解码器架构
RNN在机器翻译中通常采用编码器-解码器架构。编码器RNN将源语言序列编码为固定长度的向量表示，解码器RNN基于这个表示生成目标语言序列。
b.基础实现
---
import torch
import torch.nn as nn
class Encoder(nn.Module):
"""编码器：将源语言序列编码为上下文向量"""
def __init__(self, input_size, embed_size, hidden_size, num_layers=2):
super(Encoder, self).__init__()
self.embedding = nn.Embedding(input_size, embed_size)
self.rnn = nn.RNN(embed_size, hidden_size, num_layers, batch_first=True)
def forward(self, x):
embedded = self.embedding(x) # [batch, seq_len, embed]
output, hidden = self.rnn(embedded) # hidden: [num_layers, batch, hidden]
return output, hidden
class Decoder(nn.Module):
"""解码器：基于上下文向量生成目标语言序列"""
def __init__(self, output_size, embed_size, hidden_size, num_layers=2):
super(Decoder, self).__init__()
self.embedding = nn.Embedding(output_size, embed_size)
self.rnn = nn.RNN(embed_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x, hidden):
embedded = self.embedding(x) # [batch, 1, embed]
output, hidden = self.rnn(embedded, hidden) # output: [batch, 1, hidden]
logits = self.fc(output) # [batch, 1, output_size]
return logits, hidden
class Seq2Seq(nn.Module):
"""序列到序列模型"""
def __init__(self, encoder, decoder):
super(Seq2Seq, self).__init__()
self.encoder = encoder
self.decoder = decoder
def forward(self, src, trg, teacher_forcing_ratio=0.5):
"""
Args:
src: 源语言序列 [batch, src_len]
trg: 目标语言序列 [batch, trg_len]
teacher_forcing_ratio: 教师强制比例
"""
batch_size = src.size(0)
trg_len = trg.size(1)
trg_vocab_size = self.decoder.fc.out_features
# 存储输出
outputs = torch.zeros(batch_size, trg_len, trg_vocab_size)
# 编码源序列
_, hidden = self.encoder(src)
# 解码器的第一个输入是<SOS>标记
input_token = trg[:, 0].unsqueeze(1) # [batch, 1]
for t in range(1, trg_len):
output, hidden = self.decoder(input_token, hidden)
outputs[:, t, :] = output.squeeze(1)
# 教师强制：使用真实标签还是预测结果
use_teacher_forcing = torch.rand(1).item() < teacher_forcing_ratio
if use_teacher_forcing:
input_token = trg[:, t].unsqueeze(1)
else:
input_token = output.argmax(2)
return outputs
# 使用示例
src_vocab_size, trg_vocab_size = 5000, 4000
embed_size, hidden_size = 256, 512
encoder = Encoder(src_vocab_size, embed_size, hidden_size)
decoder = Decoder(trg_vocab_size, embed_size, hidden_size)
model = Seq2Seq(encoder, decoder)
# 模拟数据
src = torch.randint(1, src_vocab_size, (8, 20)) # 源语言
trg = torch.randint(1, trg_vocab_size, (8, 15)) # 目标语言
outputs = model(src, trg, teacher_forcing_ratio=0.5)
print(f"输出形状: {outputs.shape}") # [8, 15, 4000]
---
03.RNN的局限性分析
a.梯度消失问题
a.问题根源
在反向传播过程中，梯度需要连乘多个小于1的权重矩阵和激活函数的导数。随着时间步的增加，梯度呈指数级衰减，导致远距离的依赖关系难以学习。
b.梯度消失演示
---
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
def analyze_gradient_vanishing():
"""分析RNN梯度消失现象"""
# 创建简单RNN
input_size, hidden_size = 10, 20
rnn = nn.RNN(input_size, hidden_size, batch_first=True)
# 长序列输入
seq_len = 100
x = torch.randn(1, seq_len, input_size, requires_grad=True)
target = torch.randn(1, hidden_size)
# 前向传播
output, _ = rnn(x)
final_output = output[:, -1, :] # 最后时间步输出
# 计算损失并反向传播
loss = nn.MSELoss()(final_output, target)
loss.backward()
# 分析每个时间步输入的梯度范数
grad_norms = []
for t in range(seq_len):
if x.grad is not None:
grad_norm = x.grad[0, t, :].norm().item()
grad_norms.append(grad_norm)
print(f"第1个时间步梯度范数: {grad_norms[0]:.6f}")
print(f"第50个时间步梯度范数: {grad_norms[49]:.6f}")
print(f"第100个时间步梯度范数: {grad_norms[99]:.6f}")
print(f"梯度衰减比例: {grad_norms[0] / grad_norms[99]:.2f}x")
return grad_norms
# 执行分析
grad_norms = analyze_gradient_vanishing()
---
b.梯度爆炸问题
a.问题表现
当循环权重矩阵的特征值大于1时，梯度会呈指数级增长，导致数值不稳定。梯度爆炸会使得参数更新过大，模型无法收敛。
b.梯度裁剪实现
---
import torch
import torch.nn as nn
def train_with_gradient_clipping():
"""使用梯度裁剪训练RNN"""
# 模型配置
vocab_size, embed_size, hidden_size = 1000, 128, 256
model = nn.RNN(embed_size, hidden_size, batch_first=True)
embedding = nn.Embedding(vocab_size, embed_size)
fc = nn.Linear(hidden_size, vocab_size)
optimizer = torch.optim.SGD(
list(model.parameters()) + list(embedding.parameters()) + list(fc.parameters()),
lr=0.01
)
criterion = nn.CrossEntropyLoss()
# 模拟数据
input_seq = torch.randint(0, vocab_size, (16, 50))
target_seq = torch.randint(0, vocab_size, (16, 50))
# 训练步骤
optimizer.zero_grad()
# 前向传播
embedded = embedding(input_seq)
output, _ = model(embedded)
logits = fc(output)
# 计算损失
loss = criterion(logits.view(-1, vocab_size), target_seq.view(-1))
loss.backward()
# 计算梯度范数（裁剪前）
total_norm_before = 0
for p in list(model.parameters()) + list(embedding.parameters()) + list(fc.parameters()):
if p.grad is not None:
param_norm = p.grad.data.norm(2)
total_norm_before += param_norm.item() ** 2
total_norm_before = total_norm_before ** 0.5
# 梯度裁剪
max_norm = 5.0
torch.nn.utils.clip_grad_norm_(
list(model.parameters()) + list(embedding.parameters()) + list(fc.parameters()),
max_norm=max_norm
)
# 计算梯度范数（裁剪后）
total_norm_after = 0
for p in list(model.parameters()) + list(embedding.parameters()) + list(fc.parameters()):
if p.grad is not None:
param_norm = p.grad.data.norm(2)
total_norm_after += param_norm.item() ** 2
total_norm_after = total_norm_after ** 0.5
print(f"裁剪前梯度范数: {total_norm_before:.4f}")
print(f"裁剪后梯度范数: {total_norm_after:.4f}")
print(f"是否发生裁剪: {'是' if total_norm_before > max_norm else '否'}")
optimizer.step()
return loss.item()
# 执行训练
loss = train_with_gradient_clipping()
print(f"训练损失: {loss:.4f}")
---
c.并行计算困难
a.序列依赖性
RNN的循环结构导致每个时间步的计算依赖前一时间步的结果，无法并行处理序列中的多个位置。这限制了训练和推理的速度，特别是在处理长序列时。
b.性能对比
---
import torch
import torch.nn as nn
import time
def compare_rnn_cnn_speed():
"""对比RNN和CNN的计算速度"""
batch_size, seq_len, input_size = 32, 100, 128
hidden_size = 256
# RNN模型
rnn = nn.RNN(input_size, hidden_size, batch_first=True)
# CNN模型（用于对比）
cnn = nn.Conv1d(input_size, hidden_size, kernel_size=3, padding=1)
# 输入数据
x_rnn = torch.randn(batch_size, seq_len, input_size)
x_cnn = torch.randn(batch_size, input_size, seq_len) # CNN格式
# 测试RNN速度
torch.cuda.synchronize() if torch.cuda.is_available() else None
start = time.time()
for _ in range(100):
output_rnn, _ = rnn(x_rnn)
rnn_time = time.time() - start
# 测试CNN速度
torch.cuda.synchronize() if torch.cuda.is_available() else None
start = time.time()
for _ in range(100):
output_cnn = cnn(x_cnn)
cnn_time = time.time() - start
print(f"RNN前向传播时间: {rnn_time:.4f}秒")
print(f"CNN前向传播时间: {cnn_time:.4f}秒")
print(f"速度比: CNN比RNN快 {rnn_time/cnn_time:.2f}倍")
return rnn_time, cnn_time
# 执行对比
rnn_time, cnn_time = compare_rnn_cnn_speed()
---
d.长序列处理能力有限
a.记忆容量限制
RNN通过固定维度的隐藏状态压缩历史信息，随着序列长度增加，信息丢失不可避免。隐藏状态的维度成为记忆容量的瓶颈。
b.截断反向传播
---
import torch
import torch.nn as nn
def truncated_backprop_through_time(model, data, seq_length, truncate_len):
"""
截断反向传播训练长序列
Args:
model: RNN模型
data: 完整数据序列
seq_length: 完整序列长度
truncate_len: 截断长度
"""
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
hidden = None
total_loss = 0
# 将长序列分成多个截断段
for i in range(0, seq_length - truncate_len, truncate_len):
# 获取当前截断段
input_chunk = data[:, i:i+truncate_len]
target_chunk = data[:, i+1:i+truncate_len+1]
# 前向传播
output, hidden = model(input_chunk, hidden)
# 分离隐藏状态，阻止梯度传播到前面的截断段
hidden = hidden.detach()
# 计算损失并反向传播
loss = criterion(output.view(-1, output.size(-1)), target_chunk.view(-1))
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
return total_loss / (seq_length // truncate_len)
# 使用示例
vocab_size, embed_size, hidden_size = 1000, 128, 256
class SimpleRNNLM(nn.Module):
def __init__(self, vocab_size, embed_size, hidden_size):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_size)
self.rnn = nn.RNN(embed_size, hidden_size, batch_first=True)
self.fc = nn.Linear(hidden_size, vocab_size)
def forward(self, x, hidden=None):
embedded = self.embedding(x)
output, hidden = self.rnn(embedded, hidden)
logits = self.fc(output)
return logits, hidden
model = SimpleRNNLM(vocab_size, embed_size, hidden_size)
# 模拟长序列数据 [batch=4, seq_len=1000]
long_sequence = torch.randint(0, vocab_size, (4, 1000))
# 使用截断反向传播训练
avg_loss = truncated_backprop_through_time(
model, long_sequence,
seq_length=1000,
truncate_len=50 # 每50个时间步截断一次
)
print(f"平均损失: {avg_loss:.4f}")
print(f"截断段数: {1000 // 50}")
---
3.2 LSTM文本建模
01.LSTM架构设计
a.门控机制原理
a.基本概念
LSTM通过引入门控机制解决了传统RNN的梯度消失问题。三个门控单元分别控制信息的遗忘、输入和输出，使得模型能够选择性地保留或丢弃信息。门控单元使用sigmoid激活函数输出0到1之间的值，表示信息通过的比例。这种设计允许梯度在长时间步上稳定传播，使得LSTM能够学习长期依赖关系。
b.完整实现
---
import torch
import torch.nn as nn
class LSTMCell(nn.Module):
"""手动实现LSTM单元"""
def __init__(self, input_size, hidden_size):
super(LSTMCell, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
# 遗忘门参数
self.W_f = nn.Linear(input_size + hidden_size, hidden_size)
# 输入门参数
self.W_i = nn.Linear(input_size + hidden_size, hidden_size)
# 候选细胞状态参数
self.W_c = nn.Linear(input_size + hidden_size, hidden_size)
# 输出门参数
self.W_o = nn.Linear(input_size + hidden_size, hidden_size)
def forward(self, x, hidden_state):
"""
Args:
x: 当前输入 [batch_size, input_size]
hidden_state: (h_prev, c_prev) 元组
Returns:
h_t: 新的隐藏状态 [batch_size, hidden_size]
c_t: 新的细胞状态 [batch_size, hidden_size]
"""
h_prev, c_prev = hidden_state
# 拼接输入和前一隐藏状态
combined = torch.cat((x, h_prev), dim=1)
# 遗忘门：决定丢弃多少信息
f_t = torch.sigmoid(self.W_f(combined))
# 输入门：决定更新多少新信息
i_t = torch.sigmoid(self.W_i(combined))
# 候选细胞状态
c_tilde = torch.tanh(self.W_c(combined))
# 更新细胞状态
c_t = f_t * c_prev + i_t * c_tilde
# 输出门：决定输出多少信息
o_t = torch.sigmoid(self.W_o(combined))
# 计算新的隐藏状态
h_t = o_t * torch.tanh(c_t)
return h_t, c_t
# 使用示例
batch_size, input_size, hidden_size = 4, 10, 20
lstm_cell = LSTMCell(input_size, hidden_size)
x = torch.randn(batch_size, input_size)
h_0 = torch.zeros(batch_size, hidden_size)
c_0 = torch.zeros(batch_size, hidden_size)
h_1, c_1 = lstm_cell(x, (h_0, c_0))
print(f"隐藏状态形状: {h_1.shape}") # [4, 20]
print(f"细胞状态形状: {c_1.shape}") # [4, 20]
---
b.遗忘门设计
遗忘门决定从细胞状态中丢弃哪些信息。它接收当前输入和前一时刻的隐藏状态，通过sigmoid函数输出遗忘比例。输出值接近0表示完全遗忘，接近1表示完全保留。遗忘门使得模型能够主动忘记不再需要的历史信息，避免无关信息的累积。这对于处理长序列特别重要，模型需要决定哪些远距离信息值得保留。
c.输入门机制
输入门控制新信息如何更新细胞状态。它包含两个部分：sigmoid层决定更新哪些值，tanh层创建候选值向量。两者的逐元素乘积决定了实际添加到细胞状态的新信息。这种设计允许模型选择性地吸收新信息，而不是无差别地累积所有输入。输入门的存在使得LSTM能够在关键位置更新记忆，在其他位置保持稳定。
d.输出门功能
输出门决定细胞状态的哪些部分应该输出到隐藏状态。首先对细胞状态应用tanh函数将值压缩到-1到1之间，然后与输出门的sigmoid输出相乘。这种设计将内部记忆和外部输出分离，细胞状态可以保留更多信息，而隐藏状态只输出当前需要的部分。输出门使得模型能够根据任务需求灵活地使用记忆信息。
e.细胞状态更新
细胞状态是LSTM的核心，它像传送带一样贯穿整个序列，只有少量的线性交互。细胞状态的更新结合了遗忘门对旧信息的筛选和输入门对新信息的添加。这种加法更新机制使得梯度能够更容易地反向传播，避免了乘法操作导致的梯度消失。细胞状态提供了一条信息高速公路，允许重要信息在长距离上传播。
02.LSTM变体与改进
a.Peephole连接
a.设计动机
标准LSTM的门控单元只依赖当前输入和前一隐藏状态，不直接观察细胞状态。Peephole连接允许门控单元直接访问细胞状态，提供更精确的控制。
b.实现方式
在遗忘门、输入门和输出门的计算中加入细胞状态作为额外输入。这增加了少量参数，但使得门控决策能够基于更完整的信息。
c.效果评估
Peephole连接在某些任务上能够提升性能，特别是需要精确计时的任务。但在大多数NLP任务中，标准LSTM已经足够有效，Peephole的改进有限。
b.GRU简化结构
a.结构特点
GRU将LSTM的遗忘门和输入门合并为更新门，同时合并细胞状态和隐藏状态。这种简化减少了参数量，加快了训练速度。
b.GRU实现
---
import torch
import torch.nn as nn
class GRUCell(nn.Module):
"""手动实现GRU单元"""
def __init__(self, input_size, hidden_size):
super(GRUCell, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
# 重置门参数
self.W_r = nn.Linear(input_size + hidden_size, hidden_size)
# 更新门参数
self.W_z = nn.Linear(input_size + hidden_size, hidden_size)
# 候选隐藏状态参数
self.W_h = nn.Linear(input_size + hidden_size, hidden_size)
def forward(self, x, h_prev):
combined = torch.cat((x, h_prev), dim=1)
# 重置门
r_t = torch.sigmoid(self.W_r(combined))
# 更新门
z_t = torch.sigmoid(self.W_z(combined))
# 候选隐藏状态
combined_reset = torch.cat((x, r_t * h_prev), dim=1)
h_tilde = torch.tanh(self.W_h(combined_reset))
# 更新隐藏状态
h_t = (1 - z_t) * h_prev + z_t * h_tilde
return h_t
# 对比LSTM和GRU参数量
input_size, hidden_size = 100, 256
lstm = nn.LSTM(input_size, hidden_size)
gru = nn.GRU(input_size, hidden_size)
lstm_params = sum(p.numel() for p in lstm.parameters())
gru_params = sum(p.numel() for p in gru.parameters())
print(f"LSTM参数量: {lstm_params:,}")
print(f"GRU参数量: {gru_params:,}")
print(f"参数减少: {(1 - gru_params/lstm_params)*100:.1f}%")
---
c.双向LSTM
a.架构设计
双向LSTM同时使用前向和后向两个LSTM层处理序列，前向层从左到右处理，后向层从右到左处理。两个方向的隐藏状态在每个位置拼接，提供完整的上下文信息。
b.双向LSTM实现
---
import torch
import torch.nn as nn
class BiLSTMTagger(nn.Module):
"""双向LSTM序列标注模型"""
def __init__(self, vocab_size, embed_size, hidden_size, num_tags):
super(BiLSTMTagger, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
# 双向LSTM
self.bilstm = nn.LSTM(
embed_size, hidden_size, num_layers=2,
batch_first=True, bidirectional=True, dropout=0.3
)
# 输出层：输入维度是hidden_size*2
self.fc = nn.Linear(hidden_size * 2, num_tags)
def forward(self, x):
embedded = self.embedding(x)
lstm_out, _ = self.bilstm(embedded)
logits = self.fc(lstm_out)
return logits
# 训练示例
model = BiLSTMTagger(10000, 128, 256, 9)
input_seq = torch.randint(1, 10000, (16, 40))
target_tags = torch.randint(0, 9, (16, 40))
criterion = nn.CrossEntropyLoss(ignore_index=0)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
optimizer.zero_grad()
logits = model(input_seq)
loss = criterion(logits.view(-1, 9), target_tags.view(-1))
loss.backward()
optimizer.step()
print(f"损失: {loss.item():.4f}")
---
d.深层LSTM
a.堆叠结构
通过堆叠多层LSTM可以增加模型的表达能力。每一层的输出作为下一层的输入，形成层次化的特征表示。底层捕捉局部模式，高层学习抽象语义。
b.训练技巧
深层LSTM的训练更加困难，需要使用残差连接、层归一化等技术稳定训练。残差连接允许梯度直接传播到底层，缓解梯度消失问题。
c.性能提升
增加层数通常能提升模型性能，但收益递减。在实践中，2-4层LSTM通常已经足够，更深的模型需要更多数据和更长的训练时间。
03.LSTM在文本建模中的应用
a.字符级语言模型
a.模型设计
字符级语言模型以字符为基本单位建模文本，LSTM逐个字符处理输入，预测下一个字符的概率分布。这种方法不需要分词，能够处理任意语言和词汇表外的词。
b.完整实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
class CharLSTM(nn.Module):
"""字符级LSTM语言模型"""
def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2):
super(CharLSTM, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size)
self.lstm = nn.LSTM(embed_size, hidden_size, num_layers,
batch_first=True, dropout=0.3)
self.fc = nn.Linear(hidden_size, vocab_size)
def forward(self, x, hidden=None):
embedded = self.embedding(x)
output, hidden = self.lstm(embedded, hidden)
logits = self.fc(output)
return logits, hidden
def generate(self, start_char, length=200, temperature=0.8):
"""生成文本"""
self.eval()
with torch.no_grad():
input_char = torch.tensor([[start_char]])
hidden = None
generated = [start_char]
for _ in range(length):
logits, hidden = self.forward(input_char, hidden)
probs = F.softmax(logits[0, -1] / temperature, dim=0)
next_char = torch.multinomial(probs, 1).item()
generated.append(next_char)
input_char = torch.tensor([[next_char]])
return generated
# 训练示例
model = CharLSTM(vocab_size=128, embed_size=64, hidden_size=256)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.002)
# 模拟训练
input_seq = torch.randint(0, 128, (16, 100))
target_seq = torch.randint(0, 128, (16, 100))
optimizer.zero_grad()
logits, _ = model(input_seq)
loss = criterion(logits.view(-1, 128), target_seq.view(-1))
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
optimizer.step()
print(f"训练损失: {loss.item():.4f}")
---
b.词级语言模型
a.建模方式
词级语言模型以词为单位，LSTM在每个时间步接收词嵌入，输出词汇表上的概率分布。这是最常见的语言模型形式，在困惑度和生成质量上通常优于字符级模型。
b.完整实现
---
import torch
import torch.nn as nn
import math
class WordLSTM(nn.Module):
"""词级LSTM语言模型"""
def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2):
super(WordLSTM, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_size)
self.lstm = nn.LSTM(embed_size, hidden_size, num_layers,
batch_first=True, dropout=0.5)
self.fc = nn.Linear(hidden_size, vocab_size)
self.dropout = nn.Dropout(0.5)
# 权重绑定：嵌入层和输出层共享权重
self.fc.weight = self.embedding.weight
def forward(self, x, hidden=None):
embedded = self.dropout(self.embedding(x))
output, hidden = self.lstm(embedded, hidden)
output = self.dropout(output)
logits = self.fc(output)
return logits, hidden
def evaluate_perplexity(model, data, criterion):
"""评估困惑度"""
model.eval()
total_loss = 0
total_tokens = 0
with torch.no_grad():
for batch_input, batch_target in data:
logits, _ = model(batch_input)
loss = criterion(
logits.view(-1, logits.size(-1)),
batch_target.view(-1)
)
total_loss += loss.item() * batch_target.numel()
total_tokens += batch_target.numel()
avg_loss = total_loss / total_tokens
perplexity = math.exp(avg_loss)
return perplexity
# 训练配置
model = WordLSTM(vocab_size=10000, embed_size=256, hidden_size=512)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 模拟训练
batch_input = torch.randint(0, 10000, (32, 50))
batch_target = torch.randint(0, 10000, (32, 50))
optimizer.zero_grad()
logits, _ = model(batch_input)
loss = criterion(logits.view(-1, 10000), batch_target.view(-1))
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
optimizer.step()
print(f"训练损失: {loss.item():.4f}")
print(f"困惑度: {math.exp(loss.item()):.2f}")
---
c.句子表示学习
a.编码策略
LSTM可以将变长的句子编码为固定维度的向量表示。最简单的方法是使用最后一个时间步的隐藏状态，它理论上包含了整个句子的信息。
b.池化方法
除了使用最后的隐藏状态，还可以对所有时间步的隐藏状态进行平均池化或最大池化。平均池化给每个词相同的权重，最大池化选择每个维度上的最大激活值。
c.注意力加权
更高级的方法使用注意力机制对隐藏状态进行加权平均，自动学习每个词的重要性。这种方法能够根据任务需求动态调整句子表示，捕捉关键信息。
d.序列到序列建模
a.编码器设计
在序列到序列任务中，编码器LSTM将输入序列压缩为上下文向量。这个向量需要包含输入序列的所有关键信息，供解码器生成输出序列。
b.解码器机制
解码器LSTM基于上下文向量和已生成的输出逐步生成目标序列。在训练时使用教师强制，将真实的前一个词作为输入。在推理时，使用模型自己预测的词作为下一步的输入。
c.应用场景
机器翻译、文本摘要、对话系统等任务都采用序列到序列架构。LSTM的记忆能力使其能够处理输入输出长度不同、对应关系复杂的序列转换任务。
04.LSTM训练技巧
a.梯度裁剪
a.必要性分析
虽然LSTM缓解了梯度消失问题，但在某些情况下仍可能出现梯度爆炸。梯度裁剪是训练LSTM的标准技术，防止梯度过大导致的数值不稳定。
b.实现方法
计算所有参数梯度的全局范数，如果超过阈值，将所有梯度按比例缩放到阈值范围内。这保持了梯度的方向，只调整其大小。
c.阈值选择
梯度裁剪阈值通常设置为1到10之间。较小的阈值使训练更稳定但可能减慢收敛，较大的阈值允许更大的更新但可能导致不稳定。
b.Dropout正则化
a.应用位置
在LSTM中应用Dropout需要特别注意，不能在循环连接上使用，否则会破坏时间上的信息流。标准做法是在输入到LSTM和LSTM到输出的连接上使用Dropout。
b.变分Dropout
变分Dropout在整个序列上使用相同的Dropout掩码，而不是每个时间步独立采样。这避免了在时间维度上引入过多噪声，保持了序列的连贯性。
c.循环Dropout
循环Dropout在循环连接上使用固定的掩码，允许在时间维度上正则化而不破坏长期依赖。这种技术需要仔细调参，过大的Dropout率会严重影响性能。
c.学习率调度
a.预热策略
LSTM训练初期使用较小的学习率逐渐增加到目标值，避免初期的大幅更新破坏随机初始化的平衡。预热通常持续几千到几万步。
b.衰减方案
训练后期逐渐降低学习率有助于模型收敛到更好的局部最优。常用的衰减方案包括指数衰减、余弦退火、分段常数衰减等。
c.自适应优化器
Adam等自适应优化器为每个参数维护独立的学习率，能够自动调整更新步长。这些优化器通常比SGD更容易训练LSTM，但可能在某些任务上泛化性能略差。
d.批归一化与层归一化
a.归一化必要性
深层LSTM容易出现内部协变量偏移，归一化技术能够稳定训练过程。批归一化在RNN中应用困难，因为不同序列长度导致统计量不稳定。
b.层归一化优势
层归一化在每个样本的隐藏单元上计算均值和方差，不依赖批次统计。这使其特别适合RNN，能够稳定不同时间步的激活分布。
c.应用效果
层归一化能够加速LSTM训练，允许使用更大的学习率。它还有正则化效果，在某些任务上能够提升泛化性能。在深层LSTM中，层归一化几乎是必需的。
3.3 Seq2Seq模型
01.Seq2Seq架构原理
a.编码器-解码器框架
a.基本概念
Seq2Seq模型采用编码器-解码器架构处理序列到序列的转换任务。编码器将变长的输入序列压缩为固定维度的上下文向量，解码器基于这个向量生成变长的输出序列。这种架构将复杂的序列转换问题分解为两个子问题：理解输入和生成输出。编码器和解码器通常都使用LSTM或GRU等循环神经网络，它们可以独立训练也可以联合优化。
b.基础实现
---
import torch
import torch.nn as nn
class Encoder(nn.Module):
"""编码器：将源序列编码为上下文向量"""
def __init__(self, input_size, embed_size, hidden_size, num_layers=2):
super(Encoder, self).__init__()
self.embedding = nn.Embedding(input_size, embed_size)
self.lstm = nn.LSTM(embed_size, hidden_size, num_layers,
batch_first=True, dropout=0.3)
def forward(self, x):
embedded = self.embedding(x)
output, hidden = self.lstm(embedded)
return output, hidden
class Decoder(nn.Module):
"""解码器：基于上下文向量生成目标序列"""
def __init__(self, output_size, embed_size, hidden_size, num_layers=2):
super(Decoder, self).__init__()
self.embedding = nn.Embedding(output_size, embed_size)
self.lstm = nn.LSTM(embed_size, hidden_size, num_layers,
batch_first=True, dropout=0.3)
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x, hidden):
embedded = self.embedding(x)
output, hidden = self.lstm(embedded, hidden)
logits = self.fc(output)
return logits, hidden
class Seq2Seq(nn.Module):
"""序列到序列模型"""
def __init__(self, encoder, decoder):
super(Seq2Seq, self).__init__()
self.encoder = encoder
self.decoder = decoder
def forward(self, src, trg, teacher_forcing_ratio=0.5):
batch_size = src.size(0)
trg_len = trg.size(1)
trg_vocab_size = self.decoder.fc.out_features
outputs = torch.zeros(batch_size, trg_len, trg_vocab_size)
# 编码
_, hidden = self.encoder(src)
# 解码
input_token = trg[:, 0].unsqueeze(1)
for t in range(1, trg_len):
output, hidden = self.decoder(input_token, hidden)
outputs[:, t, :] = output.squeeze(1)
# 教师强制
use_teacher_forcing = torch.rand(1).item() < teacher_forcing_ratio
input_token = trg[:, t].unsqueeze(1) if use_teacher_forcing else output.argmax(2)
return outputs
# 使用示例
src_vocab, trg_vocab = 5000, 4000
encoder = Encoder(src_vocab, 256, 512)
decoder = Decoder(trg_vocab, 256, 512)
model = Seq2Seq(encoder, decoder)
src = torch.randint(1, src_vocab, (8, 20))
trg = torch.randint(1, trg_vocab, (8, 15))
outputs = model(src, trg)
print(f"输出形状: {outputs.shape}")
---
b.上下文向量设计
上下文向量是连接编码器和解码器的桥梁，它需要包含输入序列的所有关键信息。在最简单的设计中，上下文向量就是编码器最后一个时间步的隐藏状态。这个向量的维度是固定的，通常在几百到几千之间。上下文向量的质量直接影响解码器的生成能力，它必须在有限的维度内压缩输入序列的语义。
c.解码过程机制
解码器在每个时间步接收上下文向量和前一个生成的词，输出当前位置的词概率分布。训练时使用教师强制策略，将真实的前一个词作为输入，加速收敛并提供稳定的训练信号。推理时使用自回归生成，将模型预测的词作为下一步的输入。解码器需要学会何时停止生成，通常通过预测特殊的结束符号实现。
d.端到端训练
Seq2Seq模型可以端到端地训练，通过最大化目标序列的对数似然优化所有参数。损失函数是每个位置的交叉熵之和，反向传播同时更新编码器和解码器的参数。这种联合训练使得编码器能够学习对解码任务最有用的表示，而不是孤立地理解输入序列。端到端训练简化了系统设计，避免了传统方法中多个独立模块的误差累积。
02.Seq2Seq的关键技术
a.教师强制策略
a.训练机制
教师强制在训练时将真实的目标序列作为解码器的输入，而不是使用模型自己的预测。这提供了稳定的训练信号，避免了错误累积，加速了模型收敛。
b.计划采样实现
---
import torch
import torch.nn as nn
def scheduled_sampling_train(model, src, trg, epoch, max_epochs):
"""
计划采样训练：逐渐从教师强制过渡到自由生成
Args:
model: Seq2Seq模型
src: 源序列
trg: 目标序列
epoch: 当前轮次
max_epochs: 总轮次
"""
batch_size = src.size(0)
trg_len = trg.size(1)
trg_vocab_size = model.decoder.fc.out_features
# 计算教师强制概率（随训练进行逐渐降低）
teacher_forcing_ratio = 1.0 - (epoch / max_epochs)
outputs = torch.zeros(batch_size, trg_len, trg_vocab_size)
# 编码
_, hidden = model.encoder(src)
# 解码
input_token = trg[:, 0].unsqueeze(1)
for t in range(1, trg_len):
output, hidden = model.decoder(input_token, hidden)
outputs[:, t, :] = output.squeeze(1)
# 动态决定使用教师强制还是模型预测
use_teacher_forcing = torch.rand(1).item() < teacher_forcing_ratio
if use_teacher_forcing:
input_token = trg[:, t].unsqueeze(1)
else:
input_token = output.argmax(2)
return outputs
# 训练循环示例
model = Seq2Seq(encoder, decoder)
criterion = nn.CrossEntropyLoss(ignore_index=0)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
max_epochs = 50
for epoch in range(max_epochs):
src = torch.randint(1, 5000, (32, 20))
trg = torch.randint(1, 4000, (32, 15))
optimizer.zero_grad()
outputs = scheduled_sampling_train(model, src, trg, epoch, max_epochs)
loss = criterion(outputs[:, 1:].reshape(-1, 4000), trg[:, 1:].reshape(-1))
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
if epoch % 10 == 0:
print(f"Epoch {epoch}, Loss: {loss.item():.4f}, TF Ratio: {1.0 - epoch/max_epochs:.2f}")
---
b.注意力机制引入
a.动机分析
固定维度的上下文向量成为信息瓶颈，特别是对于长序列。解码器在生成每个词时可能需要关注输入序列的不同部分，单一的上下文向量难以满足这种需求。
b.机制设计
注意力机制允许解码器在每个时间步动态地访问编码器的所有隐藏状态。通过计算解码器当前状态与编码器各位置状态的相似度，得到注意力权重，然后对编码器状态加权求和得到动态上下文向量。
c.性能提升
注意力机制显著提升了Seq2Seq模型的性能，特别是在长序列上。它不仅提高了翻译质量，还提供了可解释性，通过可视化注意力权重可以理解模型的对齐关系。
c.双向编码器
a.结构优势
使用双向LSTM作为编码器能够同时利用前向和后向的上下文信息。每个位置的表示包含了整个输入序列的信息，提供更丰富的语义表示。
b.双向Seq2Seq实现
---
import torch
import torch.nn as nn
class BiEncoder(nn.Module):
"""双向LSTM编码器"""
def __init__(self, input_size, embed_size, hidden_size, num_layers=2):
super(BiEncoder, self).__init__()
self.embedding = nn.Embedding(input_size, embed_size)
self.lstm = nn.LSTM(embed_size, hidden_size, num_layers,
batch_first=True, bidirectional=True, dropout=0.3)
# 将双向隐藏状态转换为单向（供解码器使用）
self.fc_hidden = nn.Linear(hidden_size * 2, hidden_size)
self.fc_cell = nn.Linear(hidden_size * 2, hidden_size)
def forward(self, x):
embedded = self.embedding(x)
output, (hidden, cell) = self.lstm(embedded)
# hidden: [num_layers*2, batch, hidden_size]
# 合并前向和后向的隐藏状态
hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)
cell = torch.cat((cell[-2,:,:], cell[-1,:,:]), dim=1)
hidden = torch.tanh(self.fc_hidden(hidden)).unsqueeze(0)
cell = torch.tanh(self.fc_cell(cell)).unsqueeze(0)
return output, (hidden, cell)
class BiSeq2Seq(nn.Module):
"""带双向编码器的Seq2Seq"""
def __init__(self, bi_encoder, decoder):
super(BiSeq2Seq, self).__init__()
self.encoder = bi_encoder
self.decoder = decoder
def forward(self, src, trg, teacher_forcing_ratio=0.5):
batch_size = src.size(0)
trg_len = trg.size(1)
trg_vocab_size = self.decoder.fc.out_features
outputs = torch.zeros(batch_size, trg_len, trg_vocab_size)
# 双向编码
_, hidden = self.encoder(src)
# 解码
input_token = trg[:, 0].unsqueeze(1)
for t in range(1, trg_len):
output, hidden = self.decoder(input_token, hidden)
outputs[:, t, :] = output.squeeze(1)
use_teacher_forcing = torch.rand(1).item() < teacher_forcing_ratio
input_token = trg[:, t].unsqueeze(1) if use_teacher_forcing else output.argmax(2)
return outputs
# 使用示例
bi_encoder = BiEncoder(5000, 256, 512, 2)
decoder = Decoder(4000, 256, 512, 1) # 解码器单层
model = BiSeq2Seq(bi_encoder, decoder)
src = torch.randint(1, 5000, (8, 20))
trg = torch.randint(1, 4000, (8, 15))
outputs = model(src, trg)
print(f"双向Seq2Seq输出: {outputs.shape}")
---
d.多层结构设计
a.深度编码器
堆叠多层LSTM作为编码器可以学习更抽象的输入表示。底层捕捉词级别的特征，高层学习句子级别的语义。深度编码器提高了模型的表达能力。
b.深度解码器
多层解码器能够生成更高质量的输出序列。不同层可以负责不同的生成子任务，如底层处理语法，高层处理语义。
c.训练挑战
深层Seq2Seq模型的训练更加困难，需要使用残差连接、层归一化等技术。梯度需要通过更多的层传播，容易出现梯度消失或爆炸。
03.Seq2Seq的应用场景
a.机器翻译
a.任务特点
机器翻译是Seq2Seq模型最成功的应用之一。输入是源语言句子，输出是目标语言句子，两者长度和结构可能差异很大。模型需要理解源语言的语义，并用目标语言准确表达。
b.对齐学习
翻译涉及源语言和目标语言词之间的对齐关系。注意力机制能够自动学习这种对齐，无需人工标注。对于词序差异大的语言对，注意力机制尤为重要。
c.性能表现
基于注意力的Seq2Seq模型在多个语言对上达到了接近人类的翻译质量。它们能够处理长句子、习语、多义词等复杂现象，显著优于传统的统计机器翻译方法。
b.文本摘要
a.抽取式vs生成式
文本摘要分为抽取式和生成式两类。Seq2Seq模型属于生成式方法，能够生成原文中不存在的词和短语，提供更灵活的摘要。
b.建模挑战
摘要任务要求模型理解长文档的主要内容，并用简洁的语言表达。输入通常很长，对编码器的容量提出挑战。输出需要保持连贯性和准确性，避免生成无关或重复的内容。
c.改进技术
指针网络允许模型从输入中复制词，处理专有名词和罕见词。覆盖机制避免重复生成相同的内容。分层注意力处理长文档，在句子和词两个层次上建模。
c.对话系统
a.开放域对话
Seq2Seq模型可以构建开放域对话系统，输入是用户的话语，输出是系统的回复。模型从大量对话数据中学习如何生成合适的回应。
b.上下文建模
对话需要考虑多轮历史，单轮Seq2Seq模型只能基于当前输入生成回复。扩展模型需要编码对话历史，维护对话状态，生成上下文相关的回复。
c.挑战问题
Seq2Seq对话模型容易生成通用的、安全的回复，如"我不知道"、"好的"等。缺乏个性和深度是主要问题。强化学习、个性化建模等技术被用来改进对话质量。
d.代码生成
a.任务定义
从自然语言描述生成代码是Seq2Seq的新兴应用。输入是功能描述，输出是可执行的代码。这要求模型理解自然语言的意图，并掌握编程语言的语法和语义。
b.结构化输出
代码具有严格的语法结构，生成的代码必须语法正确才能执行。Seq2Seq模型需要学习编程语言的语法规则，生成结构化的输出。
c.应用前景
代码生成可以提高程序员的生产力，降低编程门槛。从简单的代码片段到完整的函数，Seq2Seq模型在多个编程任务上展现了潜力。
04.Seq2Seq的局限与改进
a.信息瓶颈问题
a.问题表现
固定维度的上下文向量限制了模型处理长序列的能力。所有输入信息必须压缩到这个向量中，导致信息丢失，特别是对于长句子和复杂结构。
b.影响分析
随着输入长度增加，翻译质量显著下降。模型难以记住长句子的所有细节，容易遗漏或误译部分内容。这是早期Seq2Seq模型的主要限制。
c.解决方案
注意力机制从根本上解决了信息瓶颈问题，允许解码器直接访问编码器的所有状态。这使得模型能够处理任意长度的输入，性能不再随长度显著下降。
b.曝光偏差问题
a.训练推理不一致
训练时使用教师强制，模型总是基于正确的历史生成下一个词。推理时使用自回归生成，模型需要基于自己可能错误的预测继续生成。这种不一致导致错误累积。
b.性能影响
曝光偏差使得模型在推理时的表现不如训练时的指标所预期的好。一旦生成了错误的词，后续的生成可能进入模型训练时从未见过的状态，导致质量急剧下降。
c.缓解策略
计划采样、强化学习、对抗训练等方法被提出来缓解曝光偏差。这些方法让模型在训练时也暴露于自己的预测，学习从错误中恢复。但它们增加了训练复杂度。
c.解码效率问题
a.自回归限制
解码器必须逐个生成输出词，每个词的生成依赖前面所有词。这种自回归特性使得解码无法并行，推理速度受限。
b.搜索空间爆炸
每个位置都有词汇表大小的选择，序列长度为n时搜索空间是指数级的。贪婪解码快但质量差，束搜索提高质量但增加计算量。
c.改进尝试
非自回归生成模型尝试并行生成所有输出词，大幅提升速度。但它们需要额外的技术来建模词之间的依赖关系，质量通常不如自回归模型。
d.评估指标问题
a.训练目标局限
Seq2Seq模型通常用交叉熵损失训练，优化的是词级别的预测准确率。但实际评估使用BLEU等序列级别的指标，训练目标和评估指标不一致。
b.度量偏差
BLEU等自动指标与人类判断的相关性有限，可能无法准确反映生成质量。模型可能在自动指标上表现好，但生成的文本不自然或不准确。
c.改进方向
强化学习可以直接优化BLEU等离散指标，但训练不稳定。对抗训练用判别器评估生成质量，提供更接近人类判断的反馈。这些方法仍在研究中。
3.4 注意力机制
01.注意力机制基础
a.核心思想
a.基本概念
注意力机制模拟人类的选择性注意能力，允许模型在处理信息时动态地关注输入的不同部分。在Seq2Seq模型中，解码器在生成每个词时不再依赖单一的固定上下文向量，而是根据当前状态动态计算对输入序列各位置的注意力权重，生成针对当前步骤的上下文表示。这种机制使得模型能够在长序列中精确定位相关信息，突破了固定维度向量的信息瓶颈。
b.基础实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
class Attention(nn.Module):
"""Bahdanau加性注意力机制"""
def __init__(self, hidden_size):
super(Attention, self).__init__()
self.W_q = nn.Linear(hidden_size, hidden_size)
self.W_k = nn.Linear(hidden_size, hidden_size)
self.v = nn.Linear(hidden_size, 1)
def forward(self, query, keys):
"""
Args:
query: 解码器隐藏状态 [batch, hidden_size]
keys: 编码器所有隐藏状态 [batch, src_len, hidden_size]
Returns:
context: 上下文向量 [batch, hidden_size]
attention_weights: 注意力权重 [batch, src_len]
"""
# 扩展query维度以匹配keys
query = query.unsqueeze(1) # [batch, 1, hidden]
# 计算注意力分数
scores = self.v(torch.tanh(
self.W_q(query) + self.W_k(keys)
)).squeeze(2) # [batch, src_len]
# 归一化为概率分布
attention_weights = F.softmax(scores, dim=1)
# 加权求和得到上下文向量
context = torch.bmm(
attention_weights.unsqueeze(1), keys
).squeeze(1) # [batch, hidden]
return context, attention_weights
# 使用示例
batch_size, src_len, hidden_size = 4, 20, 256
attention = Attention(hidden_size)
query = torch.randn(batch_size, hidden_size)
keys = torch.randn(batch_size, src_len, hidden_size)
context, weights = attention(query, keys)
print(f"上下文向量: {context.shape}") # [4, 256]
print(f"注意力权重: {weights.shape}") # [4, 20]
print(f"权重和: {weights.sum(dim=1)}") # 应该全为1
---
b.计算流程
注意力计算包含三个关键步骤：首先计算查询向量与所有键向量的相似度得到注意力分数，然后对分数应用softmax函数归一化为概率分布，最后用注意力权重对值向量加权求和得到上下文向量。查询通常是解码器的当前隐藏状态，键和值来自编码器的所有隐藏状态。这个过程在每个解码步骤都重复执行，动态选择输入的相关部分。
c.对齐学习
注意力机制自动学习输入和输出之间的对齐关系，无需人工标注。在机器翻译中，注意力权重反映了源语言词和目标语言词之间的对应关系。通过可视化注意力权重矩阵，可以直观地理解模型如何将源语言映射到目标语言。这种可解释性是注意力机制的重要优势，帮助分析和调试模型。
d.信息聚合
注意力机制实现了输入信息的软选择和聚合。与硬性选择某个位置不同，注意力使用连续的权重分布，允许模型同时关注多个位置。这种软注意力是可微的，可以通过反向传播端到端训练。加权求和的上下文向量融合了输入序列的相关信息，为解码器提供了丰富的条件信息。
02.注意力机制的变体
a.加性注意力
a.计算方式
加性注意力使用单层前馈网络计算查询和键的相似度。将查询和键拼接后通过一个隐藏层，再用线性层输出标量分数。这种方法由Bahdanau等人在2015年提出，是最早的注意力机制之一。
b.参数设计
加性注意力引入了额外的参数矩阵和权重向量。隐藏层的维度是一个超参数，通常与模型的隐藏维度相同。这些参数通过反向传播学习，使得相似度计算能够适应具体任务。
c.计算复杂度
加性注意力的计算复杂度与查询和键的维度成线性关系。对于每个查询-键对，需要进行矩阵乘法和非线性变换。当序列长度较长时，计算开销显著。
b.点积注意力
a.实现简洁性
点积注意力直接计算查询和键的内积作为相似度分数。这种方法由Luong等人提出，实现极其简洁，不需要额外的参数。内积天然地度量了两个向量的相似性。
b.缩放点积实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class ScaledDotProductAttention(nn.Module):
"""缩放点积注意力"""
def __init__(self, temperature=None):
super(ScaledDotProductAttention, self).__init__()
self.temperature = temperature
def forward(self, query, key, value, mask=None):
"""
Args:
query: [batch, n_heads, len_q, d_k]
key: [batch, n_heads, len_k, d_k]
value: [batch, n_heads, len_v, d_v]
mask: [batch, 1, len_q, len_k]
"""
d_k = query.size(-1)
temperature = self.temperature or math.sqrt(d_k)
# 计算注意力分数
scores = torch.matmul(query, key.transpose(-2, -1)) / temperature
# 应用mask（可选）
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
# Softmax归一化
attention_weights = F.softmax(scores, dim=-1)
# 加权求和
output = torch.matmul(attention_weights, value)
return output, attention_weights
# 使用示例
batch, n_heads, seq_len, d_k = 2, 8, 10, 64
attention = ScaledDotProductAttention()
query = torch.randn(batch, n_heads, seq_len, d_k)
key = torch.randn(batch, n_heads, seq_len, d_k)
value = torch.randn(batch, n_heads, seq_len, d_k)
output, weights = attention(query, key, value)
print(f"输出形状: {output.shape}") # [2, 8, 10, 64]
print(f"注意力权重: {weights.shape}") # [2, 8, 10, 10]
---
c.多头注意力
a.设计动机
单一的注意力机制可能只能捕捉一种类型的依赖关系。多头注意力使用多个独立的注意力头，每个头可以学习不同的对齐模式。这增加了模型的表达能力和灵活性。
b.完整实现
---
import torch
import torch.nn as nn
class MultiHeadAttention(nn.Module):
"""多头注意力机制"""
def __init__(self, d_model, n_heads, dropout=0.1):
super(MultiHeadAttention, self).__init__()
assert d_model % n_heads == 0
self.d_model = d_model
self.n_heads = n_heads
self.d_k = d_model // n_heads
# Q, K, V的线性投影
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
# 输出投影
self.W_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
self.attention = ScaledDotProductAttention()
def forward(self, query, key, value, mask=None):
batch_size = query.size(0)
# 线性投影并分割成多头
Q = self.W_q(query).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
K = self.W_k(key).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
V = self.W_v(value).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
# 计算注意力
output, attention_weights = self.attention(Q, K, V, mask)
# 合并多头
output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
# 输出投影
output = self.W_o(output)
output = self.dropout(output)
return output, attention_weights
# 使用示例
d_model, n_heads, seq_len = 512, 8, 20
multi_head_attn = MultiHeadAttention(d_model, n_heads)
x = torch.randn(4, seq_len, d_model)
output, weights = multi_head_attn(x, x, x)
print(f"输出形状: {output.shape}") # [4, 20, 512]
print(f"注意力权重: {weights.shape}") # [4, 8, 20, 20]
---
d.自注意力机制
a.概念定义
自注意力是注意力机制的特殊形式，查询、键、值都来自同一个序列。它计算序列内部各位置之间的依赖关系，捕捉长距离依赖和全局信息。
b.应用场景
自注意力是Transformer架构的核心组件，用于编码器和解码器内部。它允许每个位置直接关注序列中的所有其他位置，不受距离限制。这克服了RNN的顺序依赖和距离衰减问题。
c.计算特性
自注意力的计算可以完全并行，不像RNN需要顺序处理。这使得Transformer能够高效训练，充分利用现代硬件。自注意力的复杂度是序列长度的平方，对于很长的序列可能成为瓶颈。
03.注意力机制的应用
a.机器翻译中的应用
a.对齐建模
注意力机制在机器翻译中最早得到应用，用于建模源语言和目标语言之间的词对齐关系。解码器在生成每个目标词时，注意力权重指示了应该关注源语言的哪些词。
b.长句处理
注意力机制显著提升了长句翻译的质量。不再需要将整个源句压缩到固定向量，解码器可以在需要时直接访问源句的任何部分。这解决了早期Seq2Seq模型的主要瓶颈。
c.可解释性
通过可视化注意力权重，可以直观地看到模型如何将源语言词映射到目标语言词。这有助于理解模型的行为，发现翻译错误的原因，也为模型调试提供了工具。
b.文本摘要中的应用
a.内容选择
在文本摘要任务中，注意力机制帮助模型从长文档中选择重要信息。解码器在生成摘要的每个词时，注意力权重指示了文档中的相关部分。
b.指针网络
结合注意力和复制机制的指针网络允许模型从输入中直接复制词。这对处理专有名词、数字等在摘要中应该保持不变的内容特别有用。
c.层次注意力
对于长文档，可以使用层次注意力，先在句子级别计算注意力，再在词级别计算注意力。这种两层结构更好地建模了文档的层次结构。
c.问答系统中的应用
a.证据定位
在阅读理解任务中，注意力机制帮助模型在文档中定位与问题相关的证据。模型需要理解问题，然后在文档中找到包含答案的片段。
b.问题-文档交互
双向注意力同时建模问题对文档的注意和文档对问题的注意。这种交互式注意力捕捉了问题和文档之间的复杂关系，提升了答案抽取的准确性。
c.多跳推理
对于需要多步推理的复杂问题，可以使用多层注意力。每一层注意力聚焦于不同的证据片段，逐步推理得到最终答案。
d.图像描述生成
a.视觉注意力
在图像描述生成任务中，注意力机制应用于图像特征。解码器在生成每个词时，注意力权重指示了应该关注图像的哪些区域。
b.空间注意力
卷积神经网络提取的图像特征保留了空间信息。注意力机制可以在空间维度上计算，动态选择图像的相关区域。这使得模型能够像人类一样，在描述不同对象时关注图像的不同部分。
c.可视化分析
通过可视化注意力权重在图像上的分布，可以看到模型在生成每个词时关注的图像区域。这提供了模型行为的直观解释，也验证了注意力机制的有效性。
04.注意力机制的理论分析
a.信息检索视角
a.查询-键-值范式
注意力机制可以理解为一种软信息检索系统。查询代表信息需求，键是内容的索引，值是实际内容。通过计算查询和键的相似度，检索相关的值。
b.软选择机制
与传统的硬性检索不同，注意力使用软选择，返回所有值的加权组合。权重反映了相关性，高权重的值对结果贡献更大。这种软选择是可微的，适合端到端学习。
c.内容寻址
注意力实现了基于内容的寻址，而不是基于位置的寻址。这使得模型能够灵活地访问信息，不受固定结构的限制。内容寻址是注意力机制强大表达能力的来源。
b.记忆网络视角
a.外部记忆
注意力机制可以看作是一种外部记忆机制。编码器的隐藏状态构成了记忆库，解码器通过注意力读取记忆。这扩展了模型的记忆容量，突破了固定维度隐藏状态的限制。
b.读写操作
在自注意力中，每个位置既读取也写入记忆。读操作通过注意力权重选择相关信息，写操作更新位置的表示。这种读写机制使得信息能够在序列中流动和整合。
c.可微分记忆
注意力提供的记忆访问是可微的，可以通过反向传播训练。这与传统的离散记忆访问不同，使得记忆网络能够端到端学习如何使用记忆。
c.图神经网络视角
a.消息传递
自注意力可以理解为完全连接图上的消息传递。每个节点是序列中的一个位置，注意力权重是边的权重。节点通过加权聚合邻居的信息更新自己的表示。
b.动态图结构
注意力权重是动态计算的，相当于学习了一个数据依赖的图结构。不同的输入会产生不同的注意力模式，即不同的图连接。这种灵活性使得模型能够适应不同的输入。
c.多跳传播
多层自注意力实现了多跳的消息传播。信息可以通过多层传播到远距离的位置。这类似于图神经网络中的多层聚合，使得模型能够捕捉复杂的依赖关系。
d.计算复杂度分析
a.时间复杂度
标准注意力的时间复杂度是序列长度的平方，因为需要计算所有位置对之间的相似度。对于长度为n的序列，需要计算n²个注意力分数。这在处理长序列时成为瓶颈。
b.空间复杂度
存储注意力权重矩阵需要O(n²)的空间。在训练时还需要保存中间结果用于反向传播，内存占用可能很大。这限制了能够处理的最大序列长度。
c.优化方法
稀疏注意力、局部注意力、线性注意力等方法被提出来降低复杂度。这些方法通过限制注意力的范围或改变计算方式，将复杂度降低到O(n log n)或O(n)。但它们可能牺牲一些建模能力。
3.5 Beam Search
01.Beam Search基础原理
a.搜索问题定义
a.基本概念
在序列生成任务中，模型需要从指数级的可能序列中找到最优的输出。贪婪搜索每步选择概率最高的词，简单快速但容易陷入局部最优。穷举搜索能找到全局最优解，但计算复杂度随序列长度指数增长，实际不可行。Beam Search是一种启发式搜索算法，在搜索质量和计算效率之间取得平衡，是序列生成任务中最常用的解码策略。
b.基础实现
---
import torch
import torch.nn.functional as F
def beam_search(model, src, beam_size=5, max_len=50, sos_idx=1, eos_idx=2):
"""
Beam Search解码
Args:
model: Seq2Seq模型
src: 源序列 [1, src_len]
beam_size: beam宽度
max_len: 最大生成长度
sos_idx: 起始符索引
eos_idx: 结束符索引
Returns:
best_sequence: 最优序列
best_score: 最优得分
"""
device = src.device
# 编码源序列
with torch.no_grad():
_, hidden = model.encoder(src)
# 初始化beam
# sequences: [beam_size, seq_len]
sequences = torch.full((beam_size, 1), sos_idx, dtype=torch.long, device=device)
# scores: [beam_size]
scores = torch.zeros(beam_size, device=device)
scores[1:] = float('-inf') # 只有第一个beam是活跃的
# 完成的序列
completed_sequences = []
completed_scores = []
for step in range(max_len):
# 当前beam中的所有序列
current_beam_size = sequences.size(0)
# 获取最后一个词
last_words = sequences[:, -1].unsqueeze(1) # [beam_size, 1]
# 解码一步
with torch.no_grad():
logits, hidden = model.decoder(last_words, hidden)
log_probs = F.log_softmax(logits.squeeze(1), dim=-1) # [beam_size, vocab_size]
# 计算所有候选的得分
vocab_size = log_probs.size(-1)
# 扩展得分：当前累积得分 + 新词得分
candidate_scores = scores.unsqueeze(1) + log_probs # [beam_size, vocab_size]
# 展平并选择top beam_size个
candidate_scores = candidate_scores.view(-1) # [beam_size * vocab_size]
top_scores, top_indices = candidate_scores.topk(beam_size, largest=True)
# 计算来自哪个beam和哪个词
beam_indices = top_indices // vocab_size
word_indices = top_indices % vocab_size
# 构建新的序列
new_sequences = []
new_scores = []
new_hidden = []
for i in range(beam_size):
beam_idx = beam_indices[i].item()
word_idx = word_indices[i].item()
score = top_scores[i].item()
# 构建新序列
new_seq = torch.cat([
sequences[beam_idx],
torch.tensor([word_idx], device=device)
])
# 检查是否结束
if word_idx == eos_idx:
completed_sequences.append(new_seq)
completed_scores.append(score / len(new_seq)) # 长度归一化
else:
new_sequences.append(new_seq)
new_scores.append(score)
new_hidden.append(beam_idx)
# 如果所有序列都完成了
if len(new_sequences) == 0:
break
# 更新beam
sequences = torch.stack(new_sequences)
scores = torch.tensor(new_scores, device=device)
# 更新隐藏状态
if len(new_hidden) > 0:
hidden_indices = torch.tensor(new_hidden, device=device)
hidden = (
hidden[0][:, hidden_indices, :],
hidden[1][:, hidden_indices, :]
)
# 选择最优序列
if completed_sequences:
best_idx = torch.tensor(completed_scores).argmax().item()
return completed_sequences[best_idx], completed_scores[best_idx]
else:
# 如果没有完成的序列，返回得分最高的
best_idx = scores.argmax().item()
return sequences[best_idx], scores[best_idx].item() / len(sequences[best_idx])
# 使用示例
# src = torch.randint(1, 5000, (1, 20))
# best_seq, best_score = beam_search(model, src, beam_size=5)
# print(f"最优序列: {best_seq}")
# print(f"得分: {best_score:.4f}")
---
b.Beam宽度概念
Beam Search维护固定数量的候选序列，这个数量称为beam宽度或beam size。在每个时间步，算法扩展所有候选序列，计算所有可能的下一个词，然后只保留总概率最高的beam size个序列。beam宽度是算法的核心超参数，控制了搜索空间的大小和计算开销。较大的beam宽度提供更全面的搜索，但需要更多计算资源。
c.概率计算方式
Beam Search使用对数概率而不是原始概率，避免了连乘导致的数值下溢问题。序列的总对数概率是各位置对数概率之和。在比较候选序列时，通常需要进行长度归一化，因为较短的序列天然具有较高的概率。长度归一化将总对数概率除以序列长度或其函数，使得不同长度的序列可以公平比较。
d.搜索终止条件
Beam Search在生成结束符或达到最大长度时终止某个候选序列。当所有beam中的序列都终止时，搜索结束。在实践中，通常设置最大解码步数防止无限生成。终止的序列被放入完成列表，最终从完成列表中选择得分最高的序列作为输出。提前终止策略可以在部分序列完成时就结束搜索，节省计算时间。
02.Beam Search算法细节
a.初始化阶段
a.起始状态
搜索从特殊的起始符号开始，初始beam只包含一个序列，即起始符号。解码器的初始状态通常是编码器的输出或零向量。第一步扩展生成第一个实际的词。
b.第一步扩展
在第一个时间步，模型输出词汇表上的概率分布。选择概率最高的beam size个词，每个词对应一个候选序列。这beam size个序列构成了第一步后的beam。
c.状态管理
每个候选序列都有对应的解码器隐藏状态。在扩展时，需要维护这些状态，以便在下一步继续生成。状态管理是实现的关键，需要正确地复制和更新状态。
b.扩展与剪枝
a.候选生成
在每个时间步，对beam中的每个序列，模型预测下一个词的概率分布。每个序列可以扩展出词汇表大小个新序列。总共生成beam size乘以词汇表大小个候选序列。
b.得分计算
新序列的得分是父序列的累积对数概率加上新词的对数概率。对于每个候选序列，需要追踪其完整的生成历史和累积得分。
c.Top-K选择
从所有候选序列中选择得分最高的beam size个作为下一步的beam。这个选择过程是剪枝的核心，大量的候选序列被丢弃，只保留最有希望的序列。
d.状态更新
被选中的序列对应的解码器状态需要被保留和更新。由于序列可能来自不同的父序列，需要正确地索引和复制状态。这是实现中容易出错的地方。
c.长度归一化
a.长度偏差问题
不进行长度归一化时，Beam Search倾向于选择较短的序列，因为每增加一个词都会降低总概率。这导致生成的序列往往过短，不完整。
b.长度惩罚实现
---
import torch
def length_penalty(length, alpha=0.6):
"""
Google NMT长度惩罚
Args:
length: 序列长度
alpha: 惩罚强度，通常在0.6-0.7之间
Returns:
penalty: 惩罚因子
"""
return ((5 + length) / 6) ** alpha
def beam_search_with_length_penalty(model, src, beam_size=5, max_len=50,
alpha=0.6, sos_idx=1, eos_idx=2):
"""带长度惩罚的Beam Search"""
device = src.device
with torch.no_grad():
_, hidden = model.encoder(src)
sequences = torch.full((beam_size, 1), sos_idx, dtype=torch.long, device=device)
scores = torch.zeros(beam_size, device=device)
scores[1:] = float('-inf')
completed_sequences = []
completed_scores = []
for step in range(max_len):
last_words = sequences[:, -1].unsqueeze(1)
with torch.no_grad():
logits, hidden = model.decoder(last_words, hidden)
log_probs = F.log_softmax(logits.squeeze(1), dim=-1)
vocab_size = log_probs.size(-1)
candidate_scores = scores.unsqueeze(1) + log_probs
candidate_scores = candidate_scores.view(-1)
top_scores, top_indices = candidate_scores.topk(beam_size)
beam_indices = top_indices // vocab_size
word_indices = top_indices % vocab_size
new_sequences = []
new_scores = []
new_hidden = []
for i in range(beam_size):
beam_idx = beam_indices[i].item()
word_idx = word_indices[i].item()
score = top_scores[i].item()
new_seq = torch.cat([
sequences[beam_idx],
torch.tensor([word_idx], device=device)
])
if word_idx == eos_idx:
# 应用长度惩罚
seq_len = len(new_seq)
penalty = length_penalty(seq_len, alpha)
normalized_score = score / penalty
completed_sequences.append(new_seq)
completed_scores.append(normalized_score)
else:
new_sequences.append(new_seq)
new_scores.append(score)
new_hidden.append(beam_idx)
if len(new_sequences) == 0:
break
sequences = torch.stack(new_sequences)
scores = torch.tensor(new_scores, device=device)
if len(new_hidden) > 0:
hidden_indices = torch.tensor(new_hidden, device=device)
hidden = (
hidden[0][:, hidden_indices, :],
hidden[1][:, hidden_indices, :]
)
if completed_sequences:
best_idx = torch.tensor(completed_scores).argmax().item()
return completed_sequences[best_idx], completed_scores[best_idx]
else:
best_idx = scores.argmax().item()
seq_len = len(sequences[best_idx])
penalty = length_penalty(seq_len, alpha)
return sequences[best_idx], scores[best_idx].item() / penalty
# 对比不同alpha值的效果
for alpha in [0.0, 0.6, 1.0]:
print(f"Alpha={alpha}: 长度10的惩罚={length_penalty(10, alpha):.3f}")
---
d.结束符处理
a.序列完成
当生成结束符时，该序列被标记为完成，从beam中移除，加入完成列表。完成的序列不再参与后续的扩展，但其得分会与其他完成序列比较。
b.Beam补充
当某个序列完成后，beam的大小会减小。可以选择不补充，让beam逐渐缩小，也可以从剩余候选中补充新序列，保持beam大小不变。
c.最终选择
搜索结束时，从完成列表中选择得分最高的序列作为最终输出。如果使用了长度归一化，得分已经考虑了长度因素。有时也会返回top-K个最佳序列供后续处理。
03.Beam Search的变体与改进
a.多样性促进
a.问题分析
标准Beam Search倾向于生成相似的序列，beam中的候选往往只在少数位置有差异。这限制了搜索的多样性，可能错过高质量但路径不同的序列。
b.分组Beam Search
将beam分成多个组，每组独立进行搜索，组间通过多样性惩罚避免生成相似序列。这增加了搜索的覆盖范围，提高了找到高质量序列的概率。
c.多样性惩罚
在选择候选序列时，对与已选序列相似的候选施加惩罚。相似度可以通过n-gram重叠、词嵌入距离等度量。这鼓励beam保持多样性，探索不同的生成路径。
b.约束解码
a.硬约束
在某些任务中，生成的序列需要满足特定约束，如包含某些关键词、遵循特定格式等。约束解码在Beam Search中强制满足这些约束。
b.词汇约束
要求生成的序列必须包含指定的词或短语。在扩展时，追踪每个候选序列是否已包含所需词汇，优先选择满足约束的序列。
c.格式约束
对于结构化输出如代码、SQL查询等，需要保证语法正确性。约束解码可以在生成时检查语法规则，只允许合法的扩展。这需要与语法解析器集成。
c.自适应Beam宽度
a.动态调整
固定的beam宽度可能不适合所有输入。简单的输入可能不需要大的beam，复杂的输入则需要更全面的搜索。自适应方法根据输入或当前状态动态调整beam宽度。
b.置信度阈值
当模型对预测非常确定时，可以减小beam宽度，节省计算。当预测的不确定性高时，增大beam宽度，进行更仔细的搜索。
c.计算预算
在有限的计算预算下，自适应方法可以在简单部分快速通过，在困难部分投入更多资源。这优化了计算资源的使用，在相同预算下获得更好的结果。
d.随机采样结合
a.采样策略
纯Beam Search是确定性的，给定相同输入总是产生相同输出。结合随机采样可以引入随机性，生成多样化的输出。
b.Top-K采样
在每步不是选择概率最高的词，而是从概率最高的K个词中随机采样。这保持了一定的质量约束，同时增加了多样性。
c.温度调节
通过调整softmax的温度参数控制概率分布的平滑程度。较高的温度使分布更均匀，增加随机性；较低的温度使分布更尖锐，接近确定性选择。
04.Beam Search的应用与局限
a.机器翻译应用
a.标准配置
在机器翻译中，beam宽度通常设置为4到10。较大的beam能提升翻译质量，但收益递减。长度归一化对于生成完整的译文至关重要。
b.性能提升
相比贪婪解码，Beam Search通常能提升1-2个BLEU点。相比穷举搜索，它只需要很小一部分计算量。这种性价比使其成为机器翻译的标准解码方法。
c.实践经验
在实际系统中，beam宽度的选择需要平衡质量和速度。在线服务通常使用较小的beam以保证响应时间，离线评估可以使用较大的beam追求最佳质量。
b.文本生成应用
a.摘要生成
在文本摘要中，Beam Search帮助生成流畅连贯的摘要。但标准Beam Search可能导致生成通用的、安全的摘要，缺乏信息量。
b.对话系统
在对话生成中，Beam Search倾向于生成"我不知道"、"好的"等通用回复。这是因为这些回复在训练数据中频繁出现，具有高概率。需要多样性促进技术来改善。
c.创意写作
对于需要创造性的任务，纯Beam Search可能过于保守。结合随机采样或使用较高的温度可以生成更有趣、更多样的文本。
c.计算效率分析
a.时间复杂度
Beam Search的时间复杂度是序列长度乘以beam宽度乘以词汇表大小。相比贪婪解码，增加了beam宽度倍的计算量。但相比穷举搜索，复杂度从指数级降到了线性级。
b.内存占用
需要同时维护beam size个序列及其对应的解码器状态。对于大模型和长序列，内存占用可能很大。批处理时，内存需求进一步增加。
c.并行化
beam中的序列可以并行处理，充分利用GPU的并行计算能力。但beam内的依赖关系限制了并行度，不如训练时的批处理并行高效。
d.质量局限性
a.局部最优
Beam Search仍然是一种启发式搜索，不保证找到全局最优解。在早期步骤的错误决策可能导致最优序列被剪枝掉。
b.曝光偏差
Beam Search在推理时使用模型自己的预测，而训练时使用真实标签。这种不一致导致的曝光偏差影响生成质量。Beam Search缓解但不能完全解决这个问题。
c.评估指标不匹配
Beam Search优化的是序列概率，而实际评估使用BLEU、ROUGE等指标。这些指标与概率不完全相关，高概率序列不一定在评估指标上表现最好。
d.过度自信问题
神经网络模型可能对错误预测过度自信，导致Beam Search沿着错误的路径搜索。模型校准和不确定性估计可以缓解这个问题，但增加了复杂度。
4.1 Self-Attention机制
01.Self-Attention基础原理
a.核心概念
a.基本思想
Self-Attention允许序列中的每个位置直接关注序列中的所有其他位置，计算位置之间的依赖关系。与RNN不同，Self-Attention不需要按顺序处理，可以并行计算所有位置的表示。这种机制使得模型能够捕捉长距离依赖，不受距离限制。Self-Attention是Transformer架构的核心组件，彻底改变了序列建模的方式。
b.完整实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class SelfAttention(nn.Module):
"""自注意力机制实现"""
def __init__(self, embed_dim, dropout=0.1):
super(SelfAttention, self).__init__()
self.embed_dim = embed_dim
# Q, K, V的线性变换
self.query = nn.Linear(embed_dim, embed_dim)
self.key = nn.Linear(embed_dim, embed_dim)
self.value = nn.Linear(embed_dim, embed_dim)
self.dropout = nn.Dropout(dropout)
self.scale = math.sqrt(embed_dim)
def forward(self, x, mask=None):
"""
Args:
x: 输入序列 [batch_size, seq_len, embed_dim]
mask: 注意力掩码 [batch_size, seq_len, seq_len]
Returns:
output: 输出序列 [batch_size, seq_len, embed_dim]
attention_weights: 注意力权重 [batch_size, seq_len, seq_len]
"""
batch_size, seq_len, _ = x.size()
# 计算Q, K, V
Q = self.query(x) # [batch, seq_len, embed_dim]
K = self.key(x) # [batch, seq_len, embed_dim]
V = self.value(x) # [batch, seq_len, embed_dim]
# 计算注意力分数
scores = torch.bmm(Q, K.transpose(1, 2)) / self.scale
# [batch, seq_len, seq_len]
# 应用mask（可选）
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
# Softmax归一化
attention_weights = F.softmax(scores, dim=-1)
attention_weights = self.dropout(attention_weights)
# 加权求和
output = torch.bmm(attention_weights, V)
# [batch, seq_len, embed_dim]
return output, attention_weights
# 使用示例
batch_size, seq_len, embed_dim = 4, 10, 512
self_attn = SelfAttention(embed_dim)
x = torch.randn(batch_size, seq_len, embed_dim)
output, weights = self_attn(x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")
print(f"注意力权重形状: {weights.shape}")
print(f"注意力权重和: {weights.sum(dim=-1)[0, 0]:.4f}") # 应该为1
---
b.Query-Key-Value机制
Self-Attention将输入通过三个不同的线性变换得到Query、Key和Value。Query表示当前位置的查询向量，Key表示所有位置的键向量，Value表示所有位置的值向量。通过Query和Key的点积计算相似度，得到注意力权重，然后用权重对Value加权求和。这种QKV机制提供了灵活的表示学习能力，允许模型学习复杂的依赖关系。
c.缩放因子作用
点积的结果会随着维度增大而增大，导致softmax函数进入饱和区，梯度变得很小。通过除以维度的平方根进行缩放，可以将点积的方差稳定在1左右，避免梯度消失。这个简单的技巧对训练稳定性至关重要，是Transformer成功的关键细节之一。
d.并行计算优势
Self-Attention的所有位置可以并行计算，不像RNN需要顺序处理。这使得Transformer能够充分利用GPU的并行计算能力，训练速度远快于RNN。并行性也使得Transformer更容易扩展到更大的模型和更长的序列，为大规模预训练奠定了基础。
02.位置编码必要性
a.位置信息缺失
a.问题分析
Self-Attention本身是置换不变的，即打乱输入序列的顺序不会改变输出。但序列的顺序信息对于语言理解至关重要，"我爱你"和"你爱我"含义完全不同。因此需要显式地为模型提供位置信息。
b.位置编码实现
---
import torch
import math
class PositionalEncoding(nn.Module):
"""位置编码：为序列添加位置信息"""
def __init__(self, d_model, max_len=5000, dropout=0.1):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(dropout)
# 创建位置编码矩阵
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
# 计算除数项
div_term = torch.exp(
torch.arange(0, d_model, 2).float() *
(-math.log(10000.0) / d_model)
)
# 偶数维度使用sin，奇数维度使用cos
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
# 添加batch维度
pe = pe.unsqueeze(0) # [1, max_len, d_model]
# 注册为buffer，不参与梯度更新
self.register_buffer('pe', pe)
def forward(self, x):
"""
Args:
x: 输入嵌入 [batch_size, seq_len, d_model]
Returns:
带位置编码的嵌入 [batch_size, seq_len, d_model]
"""
# 添加位置编码
x = x + self.pe[:, :x.size(1), :]
return self.dropout(x)
# 可视化位置编码
def visualize_positional_encoding(max_len=100, d_model=128):
"""可视化位置编码模式"""
pe = PositionalEncoding(d_model, max_len)
encoding = pe.pe.squeeze(0).numpy()
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 5))
plt.imshow(encoding.T, cmap='RdBu', aspect='auto')
plt.xlabel('Position')
plt.ylabel('Dimension')
plt.colorbar()
plt.title('Positional Encoding Pattern')
plt.tight_layout()
return encoding
# 使用示例
d_model = 512
pos_encoder = PositionalEncoding(d_model)
batch_size, seq_len = 8, 20
x = torch.randn(batch_size, seq_len, d_model)
x_with_pos = pos_encoder(x)
print(f"原始输入: {x.shape}")
print(f"添加位置编码后: {x_with_pos.shape}")
---
b.正弦位置编码
Transformer使用正弦和余弦函数生成位置编码。不同维度使用不同频率的正弦波，低维度使用低频，高维度使用高频。这种设计使得位置编码具有周期性和平滑性，相邻位置的编码相似，远距离位置的编码差异大。正弦位置编码是固定的，不需要学习，可以泛化到训练时未见过的序列长度。
c.可学习位置编码
除了固定的正弦编码，也可以将位置编码作为可学习参数。每个位置对应一个可学习的向量，通过训练优化。可学习位置编码在某些任务上效果更好，但无法泛化到更长的序列。BERT等模型使用可学习位置编码，而GPT等模型使用正弦编码或改进的旋转位置编码。
d.相对位置编码
绝对位置编码只考虑每个位置的绝对位置，而相对位置编码关注位置之间的相对距离。相对位置编码在某些任务上更有效，因为语言中的依赖关系往往与相对位置相关。Transformer-XL、T5等模型采用相对位置编码，提升了长序列建模能力。
03.Self-Attention的变体
a.Masked Self-Attention
a.掩码机制
在解码器中，每个位置只能关注当前位置及之前的位置，不能看到未来的信息。通过掩码矩阵将未来位置的注意力分数设为负无穷，softmax后权重为0。这种因果掩码确保了自回归生成的正确性，使得解码器能够用于序列生成任务。
b.掩码实现
---
import torch
import torch.nn as nn
def create_causal_mask(seq_len):
"""
创建因果掩码（下三角矩阵）
Args:
seq_len: 序列长度
Returns:
mask: [seq_len, seq_len]，下三角为1，上三角为0
"""
mask = torch.tril(torch.ones(seq_len, seq_len))
return mask
class MaskedSelfAttention(nn.Module):
"""带掩码的自注意力（用于解码器）"""
def __init__(self, embed_dim, dropout=0.1):
super(MaskedSelfAttention, self).__init__()
self.embed_dim = embed_dim
self.query = nn.Linear(embed_dim, embed_dim)
self.key = nn.Linear(embed_dim, embed_dim)
self.value = nn.Linear(embed_dim, embed_dim)
self.dropout = nn.Dropout(dropout)
self.scale = math.sqrt(embed_dim)
def forward(self, x):
"""
Args:
x: 输入序列 [batch_size, seq_len, embed_dim]
Returns:
output: 输出序列
attention_weights: 注意力权重
"""
batch_size, seq_len, _ = x.size()
# 计算Q, K, V
Q = self.query(x)
K = self.key(x)
V = self.value(x)
# 计算注意力分数
scores = torch.bmm(Q, K.transpose(1, 2)) / self.scale
# 创建因果掩码
causal_mask = create_causal_mask(seq_len).to(x.device)
causal_mask = causal_mask.unsqueeze(0).expand(batch_size, -1, -1)
# 应用掩码
scores = scores.masked_fill(causal_mask == 0, -1e9)
# Softmax和加权求和
attention_weights = F.softmax(scores, dim=-1)
attention_weights = self.dropout(attention_weights)
output = torch.bmm(attention_weights, V)
return output, attention_weights
# 可视化因果掩码
seq_len = 8
mask = create_causal_mask(seq_len)
print("因果掩码（1表示可见，0表示不可见）:")
print(mask)
# 使用示例
masked_attn = MaskedSelfAttention(512)
x = torch.randn(4, 10, 512)
output, weights = masked_attn(x)
print(f"\n注意力权重示例（第一个样本，第一个位置）:")
print(weights[0, 0, :]) # 只有第一个位置有权重
print(f"\n注意力权重示例（第一个样本，第五个位置）:")
print(weights[0, 4, :]) # 前五个位置有权重
---
b.Padding掩码
实际应用中，批次内的序列长度不同，需要padding到相同长度。Padding位置不应该参与注意力计算，通过padding掩码将这些位置的注意力分数设为负无穷。这确保了模型只关注真实的输入，不会被padding符号影响。
c.局部注意力
标准Self-Attention的复杂度是序列长度的平方，对于很长的序列计算开销很大。局部注意力限制每个位置只能关注固定窗口内的位置，将复杂度降低到线性。虽然牺牲了全局建模能力，但在许多任务上仍然有效，特别适合处理长文档。
d.稀疏注意力
稀疏注意力通过特定的模式（如分块、步长等）减少注意力计算的位置数量。Longformer、BigBird等模型使用稀疏注意力处理长序列，在保持性能的同时大幅降低计算复杂度。稀疏模式的设计需要根据任务特点选择，是长序列建模的重要方向。
04.Self-Attention的优势与局限
a.并行化优势
Self-Attention最大的优势是并行性。所有位置的表示可以同时计算，不需要像RNN那样顺序处理。这使得训练速度大幅提升，可以在合理时间内训练更大的模型。并行性也使得Transformer更容易扩展到分布式训练，支持大规模预训练。
b.长距离依赖
Self-Attention允许任意两个位置直接交互，路径长度为1，而RNN需要多步传播。这使得Transformer能够更好地捕捉长距离依赖，不会像RNN那样出现梯度消失。在机器翻译、文档理解等需要长距离建模的任务上，Transformer显著优于RNN。
c.计算复杂度
Self-Attention的时间复杂度是O(n²d)，其中n是序列长度，d是维度。对于长序列，平方复杂度成为瓶颈。内存占用也是O(n²)，限制了可处理的最大序列长度。这是Transformer的主要局限，催生了各种高效注意力机制的研究。
d.位置信息处理
Self-Attention需要显式的位置编码来处理顺序信息，而RNN天然包含位置信息。位置编码的设计影响模型性能，不同的编码方式适合不同的任务。如何更好地建模位置信息仍是研究热点，旋转位置编码、相对位置编码等新方法不断涌现。
4.2 Multi-Head Attention
01.多头注意力原理
a.设计动机
a.基本思想
单个注意力头可能只能捕捉一种类型的依赖关系。多头注意力使用多个独立的注意力头并行计算，每个头可以学习不同的对齐模式和特征表示。这增加了模型的表达能力，允许模型从多个角度理解输入序列。多头机制是Transformer成功的关键设计之一。
b.完整实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class MultiHeadAttention(nn.Module):
"""多头注意力机制"""
def __init__(self, d_model, num_heads, dropout=0.1):
super(MultiHeadAttention, self).__init__()
assert d_model % num_heads == 0, "d_model必须能被num_heads整除"
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads # 每个头的维度
# Q, K, V的线性投影
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
# 输出投影
self.W_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
self.scale = math.sqrt(self.d_k)
def split_heads(self, x):
"""
将最后一维分割成多个头
Args:
x: [batch_size, seq_len, d_model]
Returns:
[batch_size, num_heads, seq_len, d_k]
"""
batch_size, seq_len, _ = x.size()
x = x.view(batch_size, seq_len, self.num_heads, self.d_k)
return x.transpose(1, 2)
def combine_heads(self, x):
"""
合并多个头
Args:
x: [batch_size, num_heads, seq_len, d_k]
Returns:
[batch_size, seq_len, d_model]
"""
batch_size, _, seq_len, _ = x.size()
x = x.transpose(1, 2).contiguous()
return x.view(batch_size, seq_len, self.d_model)
def forward(self, query, key, value, mask=None):
"""
Args:
query: [batch_size, seq_len_q, d_model]
key: [batch_size, seq_len_k, d_model]
value: [batch_size, seq_len_v, d_model]
mask: [batch_size, 1, seq_len_q, seq_len_k]
Returns:
output: [batch_size, seq_len_q, d_model]
attention_weights: [batch_size, num_heads, seq_len_q, seq_len_k]
"""
batch_size = query.size(0)
# 线性投影
Q = self.W_q(query) # [batch, seq_len_q, d_model]
K = self.W_k(key) # [batch, seq_len_k, d_model]
V = self.W_v(value) # [batch, seq_len_v, d_model]
# 分割成多个头
Q = self.split_heads(Q) # [batch, num_heads, seq_len_q, d_k]
K = self.split_heads(K) # [batch, num_heads, seq_len_k, d_k]
V = self.split_heads(V) # [batch, num_heads, seq_len_v, d_k]
# 计算注意力分数
scores = torch.matmul(Q, K.transpose(-2, -1)) / self.scale
# [batch, num_heads, seq_len_q, seq_len_k]
# 应用mask
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
# Softmax归一化
attention_weights = F.softmax(scores, dim=-1)
attention_weights = self.dropout(attention_weights)
# 加权求和
context = torch.matmul(attention_weights, V)
# [batch, num_heads, seq_len_q, d_k]
# 合并多个头
context = self.combine_heads(context)
# [batch, seq_len_q, d_model]
# 输出投影
output = self.W_o(context)
return output, attention_weights
# 使用示例
d_model, num_heads = 512, 8
batch_size, seq_len = 4, 20
mha = MultiHeadAttention(d_model, num_heads)
x = torch.randn(batch_size, seq_len, d_model)
output, weights = mha(x, x, x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")
print(f"注意力权重形状: {weights.shape}")
print(f"每个头的维度: {d_model // num_heads}")
# 可视化不同头的注意力模式
import matplotlib.pyplot as plt
fig, axes = plt.subplots(2, 4, figsize=(16, 8))
for i in range(8):
ax = axes[i // 4, i % 4]
ax.imshow(weights[0, i].detach().numpy(), cmap='viridis')
ax.set_title(f'Head {i+1}')
ax.set_xlabel('Key Position')
ax.set_ylabel('Query Position')
plt.tight_layout()
---
b.头数选择
头数是一个重要的超参数。常见的选择是8或16个头。头数越多，模型的表达能力越强，但计算开销也越大。每个头的维度是总维度除以头数，因此总参数量不随头数变化。实践中发现，适度的头数（8-16）效果最好，过多的头可能导致过拟合。
c.维度分配
总维度d_model被均匀分配给所有头，每个头的维度是d_k = d_model / num_heads。这种设计保持了总参数量不变，同时增加了模型的多样性。每个头在低维子空间中学习特定的模式，多个头的组合提供了丰富的表示。
d.独立性保证
不同的头使用独立的参数矩阵，确保它们学习不同的特征。训练过程中，不同的头会自动分化，关注不同类型的依赖关系。有些头可能关注局部模式，有些关注长距离依赖，有些关注特定的语法关系。这种自动分工是多头注意力的魅力所在。
02.多头注意力的计算流程
a.线性投影阶段
a.投影目的
输入首先通过三个独立的线性层分别投影为Query、Key和Value。这些投影将输入映射到不同的表示空间，为后续的注意力计算做准备。投影矩阵是可学习的参数，通过训练优化。
b.投影实现
---
import torch
import torch.nn as nn
class LinearProjection(nn.Module):
"""Q, K, V的线性投影"""
def __init__(self, d_model, num_heads):
super(LinearProjection, self).__init__()
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
# 三个投影矩阵
self.W_q = nn.Linear(d_model, d_model, bias=False)
self.W_k = nn.Linear(d_model, d_model, bias=False)
self.W_v = nn.Linear(d_model, d_model, bias=False)
def forward(self, x):
"""
Args:
x: [batch_size, seq_len, d_model]
Returns:
Q, K, V: 每个都是 [batch_size, seq_len, d_model]
"""
Q = self.W_q(x)
K = self.W_k(x)
V = self.W_v(x)
return Q, K, V
# 参数量分析
d_model = 512
num_heads = 8
proj = LinearProjection(d_model, num_heads)
# 计算参数量
total_params = sum(p.numel() for p in proj.parameters())
print(f"线性投影参数量: {total_params:,}")
print(f"Q投影: {d_model * d_model:,}")
print(f"K投影: {d_model * d_model:,}")
print(f"V投影: {d_model * d_model:,}")
print(f"总计: {3 * d_model * d_model:,}")
---
b.头分割操作
投影后的Q、K、V需要被分割成多个头。具体操作是将最后一维reshape成(num_heads, d_k)，然后转置维度使得头维度在前。这样每个头就有了独立的Q、K、V，可以并行计算注意力。分割操作只是改变张量的形状，不涉及参数。
c.注意力计算
每个头独立计算缩放点积注意力。Query和Key的点积得到注意力分数，除以缩放因子，应用softmax，然后与Value加权求和。这个过程在所有头上并行执行，充分利用GPU的并行计算能力。每个头的输出是一个d_k维的向量序列。
d.头合并与输出投影
所有头的输出被拼接成一个d_model维的向量。拼接后的结果通过一个线性层进行输出投影，得到最终的输出。输出投影允许模型学习如何组合不同头的信息，是多头注意力的重要组成部分。
03.多头注意力的变体
a.分组查询注意力
a.GQA原理
分组查询注意力(Grouped-Query Attention, GQA)是多头注意力的一种变体，用于减少KV缓存的内存占用。GQA将多个Query头共享同一组Key和Value头，在保持性能的同时大幅降低内存需求。这对于大模型的推理优化特别重要。
b.GQA实现
---
import torch
import torch.nn as nn
import math
class GroupedQueryAttention(nn.Module):
"""分组查询注意力（GQA）"""
def __init__(self, d_model, num_q_heads, num_kv_heads, dropout=0.1):
super(GroupedQueryAttention, self).__init__()
assert num_q_heads % num_kv_heads == 0, "Q头数必须是KV头数的倍数"
self.d_model = d_model
self.num_q_heads = num_q_heads
self.num_kv_heads = num_kv_heads
self.num_groups = num_q_heads // num_kv_heads
self.d_k = d_model // num_q_heads
# Q使用全部头，K和V使用较少的头
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, num_kv_heads * self.d_k)
self.W_v = nn.Linear(d_model, num_kv_heads * self.d_k)
self.W_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
self.scale = math.sqrt(self.d_k)
def forward(self, query, key, value, mask=None):
batch_size = query.size(0)
seq_len_q = query.size(1)
seq_len_k = key.size(1)
# 投影Q, K, V
Q = self.W_q(query).view(batch_size, seq_len_q, self.num_q_heads, self.d_k)
K = self.W_k(key).view(batch_size, seq_len_k, self.num_kv_heads, self.d_k)
V = self.W_v(value).view(batch_size, seq_len_k, self.num_kv_heads, self.d_k)
# 转置: [batch, num_heads, seq_len, d_k]
Q = Q.transpose(1, 2)
K = K.transpose(1, 2)
V = V.transpose(1, 2)
# 扩展K和V以匹配Q的头数
K = K.repeat_interleave(self.num_groups, dim=1)
V = V.repeat_interleave(self.num_groups, dim=1)
# 计算注意力
scores = torch.matmul(Q, K.transpose(-2, -1)) / self.scale
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attention_weights = F.softmax(scores, dim=-1)
attention_weights = self.dropout(attention_weights)
context = torch.matmul(attention_weights, V)
context = context.transpose(1, 2).contiguous()
context = context.view(batch_size, seq_len_q, self.d_model)
output = self.W_o(context)
return output, attention_weights
# 对比标准MHA和GQA的内存占用
d_model = 512
seq_len = 2048
# 标准MHA: 8个Q头，8个K头，8个V头
mha_kv_size = 2 * 8 * (d_model // 8) * seq_len
# GQA: 8个Q头，2个K头，2个V头
gqa_kv_size = 2 * 2 * (d_model // 8) * seq_len
print(f"标准MHA的KV缓存: {mha_kv_size:,} 元素")
print(f"GQA的KV缓存: {gqa_kv_size:,} 元素")
print(f"内存节省: {(1 - gqa_kv_size/mha_kv_size)*100:.1f}%")
---
b.多查询注意力
多查询注意力(Multi-Query Attention, MQA)是GQA的极端情况，所有Query头共享单个Key和Value头。这进一步减少了KV缓存，但可能牺牲一些性能。MQA在PaLM等大模型中使用，在推理速度和质量之间取得平衡。
c.Flash Attention
Flash Attention通过重新组织注意力计算的顺序和内存访问模式，大幅提升计算效率。它将注意力计算分块进行，减少HBM访问，充分利用GPU的SRAM。Flash Attention在不改变数学计算的前提下，实现了2-4倍的加速，是训练大模型的关键优化技术。
d.线性注意力
线性注意力通过核技巧或其他方法将注意力的复杂度从O(n²)降低到O(n)。Performer、Linformer等模型使用线性注意力处理长序列。虽然理论上很吸引人，但实践中线性注意力往往牺牲了一些性能，适用场景有限。
04.多头注意力的应用技巧
a.残差连接
a.残差设计
多头注意力的输出通常与输入相加，形成残差连接。残差连接允许梯度直接传播，缓解深层网络的训练困难。它还提供了恒等映射的路径，使得模型可以学习输入的增量变化而不是完全重新表示。
b.残差实现
---
import torch
import torch.nn as nn
class MultiHeadAttentionWithResidual(nn.Module):
"""带残差连接和层归一化的多头注意力"""
def __init__(self, d_model, num_heads, dropout=0.1):
super(MultiHeadAttentionWithResidual, self).__init__()
self.attention = MultiHeadAttention(d_model, num_heads, dropout)
self.norm = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x, mask=None):
"""
Args:
x: [batch_size, seq_len, d_model]
mask: 注意力掩码
Returns:
output: [batch_size, seq_len, d_model]
"""
# 多头注意力
attn_output, _ = self.attention(x, x, x, mask)
# Dropout
attn_output = self.dropout(attn_output)
# 残差连接
output = x + attn_output
# 层归一化
output = self.norm(output)
return output
# 使用示例
layer = MultiHeadAttentionWithResidual(512, 8)
x = torch.randn(4, 20, 512)
output = layer(x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")
print(f"输入输出形状相同，支持残差连接")
---
b.层归一化
层归一化(Layer Normalization)在多头注意力后应用，稳定训练过程。它对每个样本的特征维度进行归一化，使得激活值的分布保持稳定。层归一化的位置有两种选择：Post-LN（先注意力后归一化）和Pre-LN（先归一化后注意力）。Pre-LN在深层Transformer中更稳定，是目前的主流选择。
c.Dropout策略
Dropout在多个位置应用：注意力权重的dropout防止过度依赖某些位置，输出投影的dropout提供正则化。Dropout率通常设置为0.1，在大模型中可能更小。训练时应用dropout，推理时关闭。合理的dropout有助于提升泛化性能。
d.初始化方法
参数初始化对训练稳定性很重要。Query、Key、Value的投影矩阵通常使用Xavier初始化或He初始化。输出投影的初始化可以使用较小的方差，避免残差连接后的方差爆炸。BERT、GPT等模型都有特定的初始化策略，经过大量实验验证。
4.3 Position Encoding
01.位置编码的必要性
a.序列顺序信息
Transformer的Self-Attention机制本身是置换不变的，即改变输入序列的顺序不会影响输出。但在自然语言处理中，词序至关重要，"狗咬人"和"人咬狗"含义完全不同。因此必须为模型显式提供位置信息，让模型知道每个词在序列中的位置。位置编码就是解决这个问题的方法。
b.位置编码方案
a.固定位置编码
使用预定义的数学函数生成位置编码，不需要学习。最常用的是正弦余弦位置编码，具有良好的数学性质和泛化能力。
b.可学习位置编码
将位置编码作为模型参数，通过训练学习。每个位置对应一个可学习的向量，能够更好地适应特定任务，但无法泛化到训练时未见过的位置。
c.相对位置编码
不编码绝对位置，而是编码位置之间的相对距离。相对位置编码在某些任务上更有效，因为语言中的依赖关系往往与相对位置相关。
02.正弦位置编码
a.编码公式
a.数学定义
正弦位置编码使用不同频率的正弦和余弦函数。对于位置pos和维度i，编码为：PE(pos, 2i) = sin(pos / 10000^(2i/d_model))，PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))。偶数维度使用正弦，奇数维度使用余弦。
b.完整实现
---
import torch
import torch.nn as nn
import math
import numpy as np
class SinusoidalPositionalEncoding(nn.Module):
"""正弦位置编码"""
def __init__(self, d_model, max_len=5000, dropout=0.1):
super(SinusoidalPositionalEncoding, self).__init__()
self.dropout = nn.Dropout(dropout)
# 创建位置编码矩阵
pe = torch.zeros(max_len, d_model)
# 位置索引 [0, 1, 2, ..., max_len-1]
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
# 计算除数项 10000^(2i/d_model)
div_term = torch.exp(
torch.arange(0, d_model, 2).float() *
(-math.log(10000.0) / d_model)
)
# 偶数维度使用sin
pe[:, 0::2] = torch.sin(position * div_term)
# 奇数维度使用cos
pe[:, 1::2] = torch.cos(position * div_term)
# 添加batch维度 [1, max_len, d_model]
pe = pe.unsqueeze(0)
# 注册为buffer，不参与梯度更新
self.register_buffer('pe', pe)
def forward(self, x):
"""
Args:
x: 输入嵌入 [batch_size, seq_len, d_model]
Returns:
添加位置编码后的嵌入 [batch_size, seq_len, d_model]
"""
# 将位置编码加到输入上
x = x + self.pe[:, :x.size(1), :]
return self.dropout(x)
# 可视化位置编码
def visualize_positional_encoding(max_len=100, d_model=128):
"""可视化位置编码的模式"""
pe_layer = SinusoidalPositionalEncoding(d_model, max_len)
pe = pe_layer.pe.squeeze(0).numpy()
import matplotlib.pyplot as plt
# 绘制位置编码热图
plt.figure(figsize=(15, 6))
plt.subplot(1, 2, 1)
plt.imshow(pe.T, cmap='RdBu', aspect='auto', vmin=-1, vmax=1)
plt.xlabel('Position')
plt.ylabel('Dimension')
plt.title('Positional Encoding Heatmap')
plt.colorbar()
# 绘制特定维度的波形
plt.subplot(1, 2, 2)
for i in [0, 10, 20, 40, 60]:
plt.plot(pe[:, i], label=f'Dim {i}')
plt.xlabel('Position')
plt.ylabel('Encoding Value')
plt.title('Positional Encoding Waveforms')
plt.legend()
plt.grid(True)
plt.tight_layout()
return pe
# 使用示例
d_model = 512
max_len = 100
pe_layer = SinusoidalPositionalEncoding(d_model, max_len)
# 创建输入
batch_size, seq_len = 4, 50
x = torch.randn(batch_size, seq_len, d_model)
# 添加位置编码
x_with_pe = pe_layer(x)
print(f"输入形状: {x.shape}")
print(f"位置编码形状: {pe_layer.pe.shape}")
print(f"输出形状: {x_with_pe.shape}")
# 验证位置编码的性质
pe = pe_layer.pe.squeeze(0)
print(f"\n位置编码统计:")
print(f"最小值: {pe.min():.4f}")
print(f"最大值: {pe.max():.4f}")
print(f"均值: {pe.mean():.4f}")
print(f"标准差: {pe.std():.4f}")
---
b.频率设计
不同维度使用不同频率的波。低维度（i较小）使用低频率，波长较长，能够编码较大的位置范围。高维度使用高频率，波长较短，能够区分相邻位置。这种设计使得位置编码既能表示绝对位置，又能表示相对位置关系。频率按几何级数递减，从1到10000。
c.数学性质
正弦位置编码具有良好的数学性质。对于任意固定的偏移k，PE(pos+k)可以表示为PE(pos)的线性函数。这意味着模型可以轻松学习相对位置关系。此外，正弦函数的周期性使得编码值有界，不会随位置增长而爆炸。
d.泛化能力
正弦位置编码可以泛化到训练时未见过的序列长度。由于使用连续的数学函数，任意位置都有定义良好的编码。这对于处理可变长度的序列很重要，模型可以在短序列上训练，在长序列上推理。
03.可学习位置编码
a.实现方式
a.嵌入层实现
可学习位置编码将每个位置视为一个离散的token，使用Embedding层学习位置向量。位置索引从0到max_len-1，每个位置对应一个d_model维的可学习向量。
b.完整实现
---
import torch
import torch.nn as nn
class LearnedPositionalEncoding(nn.Module):
"""可学习的位置编码"""
def __init__(self, d_model, max_len=512, dropout=0.1):
super(LearnedPositionalEncoding, self).__init__()
self.dropout = nn.Dropout(dropout)
# 位置嵌入层
self.position_embeddings = nn.Embedding(max_len, d_model)
# 初始化位置嵌入
nn.init.normal_(self.position_embeddings.weight, std=0.02)
def forward(self, x):
"""
Args:
x: 输入嵌入 [batch_size, seq_len, d_model]
Returns:
添加位置编码后的嵌入 [batch_size, seq_len, d_model]
"""
batch_size, seq_len, _ = x.size()
# 创建位置索引 [0, 1, 2, ..., seq_len-1]
positions = torch.arange(seq_len, device=x.device).unsqueeze(0)
positions = positions.expand(batch_size, -1)
# 获取位置编码
position_encodings = self.position_embeddings(positions)
# 添加到输入
x = x + position_encodings
return self.dropout(x)
# 对比可学习和固定位置编码
d_model = 512
max_len = 512
learned_pe = LearnedPositionalEncoding(d_model, max_len)
sinusoidal_pe = SinusoidalPositionalEncoding(d_model, max_len)
# 计算参数量
learned_params = sum(p.numel() for p in learned_pe.parameters())
sinusoidal_params = sum(p.numel() for p in sinusoidal_pe.parameters())
print(f"可学习位置编码参数量: {learned_params:,}")
print(f"正弦位置编码参数量: {sinusoidal_params:,}")
print(f"可学习编码额外参数: {learned_params - sinusoidal_params:,}")
# 使用示例
x = torch.randn(4, 50, d_model)
x_learned = learned_pe(x)
x_sinusoidal = sinusoidal_pe(x)
print(f"\n输入形状: {x.shape}")
print(f"可学习编码输出: {x_learned.shape}")
print(f"正弦编码输出: {x_sinusoidal.shape}")
---
b.优势与局限
可学习位置编码的优势是灵活性强，能够通过训练适应特定任务的需求。在某些任务上，可学习编码的性能优于固定编码。但它的主要局限是无法泛化到训练时未见过的位置，max_len是硬限制。如果推理时序列长度超过max_len，模型无法处理。
c.BERT的选择
BERT使用可学习位置编码，max_len设置为512。这是因为BERT主要处理句子级别的任务，序列长度通常不超过512。可学习编码在BERT的预训练任务上效果良好。但对于需要处理长文档的任务，可学习编码的限制就显现出来了。
d.初始化策略
可学习位置编码的初始化很重要。通常使用小方差的正态分布初始化，如std=0.02。也可以用正弦编码的值初始化，然后fine-tune。合理的初始化有助于训练稳定性和收敛速度。
04.相对位置编码
a.设计动机
a.相对位置重要性
在许多语言现象中，词之间的相对位置比绝对位置更重要。例如，主语和谓语的距离、修饰语和被修饰语的相对位置等。相对位置编码直接建模这种关系，可能更符合语言的本质。
b.相对位置实现
---
import torch
import torch.nn as nn
class RelativePositionEncoding(nn.Module):
"""相对位置编码（简化版）"""
def __init__(self, d_model, max_relative_position=128):
super(RelativePositionEncoding, self).__init__()
self.d_model = d_model
self.max_relative_position = max_relative_position
# 相对位置嵌入：从-max到+max
vocab_size = 2 * max_relative_position + 1
self.relative_position_embeddings = nn.Embedding(vocab_size, d_model)
def forward(self, seq_len):
"""
生成相对位置编码
Args:
seq_len: 序列长度
Returns:
relative_positions: [seq_len, seq_len, d_model]
"""
# 计算相对位置矩阵
positions = torch.arange(seq_len)
relative_positions = positions.unsqueeze(0) - positions.unsqueeze(1)
# 裁剪到最大相对位置
relative_positions = torch.clamp(
relative_positions,
-self.max_relative_position,
self.max_relative_position
)
# 转换为正索引
relative_positions = relative_positions + self.max_relative_position
# 获取嵌入
embeddings = self.relative_position_embeddings(relative_positions)
return embeddings
# 使用示例
d_model = 512
max_rel_pos = 128
rel_pe = RelativePositionEncoding(d_model, max_rel_pos)
seq_len = 20
rel_encodings = rel_pe(seq_len)
print(f"相对位置编码形状: {rel_encodings.shape}")
print(f"编码维度: {d_model}")
print(f"最大相对位置: ±{max_rel_pos}")
# 可视化相对位置矩阵
positions = torch.arange(seq_len)
rel_pos_matrix = positions.unsqueeze(0) - positions.unsqueeze(1)
print(f"\n相对位置矩阵示例（前5x5）:")
print(rel_pos_matrix[:5, :5])
---
b.Transformer-XL方法
Transformer-XL提出了一种相对位置编码方案，在注意力计算中加入相对位置偏置。具体来说，在计算注意力分数时，不仅考虑内容的相似度，还考虑相对位置的偏置。这种方法在长序列建模上表现出色，能够捕捉更长距离的依赖关系。
c.T5的相对位置偏置
T5使用简化的相对位置偏置，为每个相对位置学习一个标量偏置值。这个偏置直接加到注意力分数上，影响注意力权重的分布。T5的相对位置编码参数量小，但在多种任务上效果良好，成为许多后续模型的选择。
d.旋转位置编码
旋转位置编码(RoPE)是一种新颖的相对位置编码方法，通过旋转Query和Key向量来注入位置信息。RoPE具有良好的数学性质，能够自然地表示相对位置关系。它在LLaMA、GPT-NeoX等大模型中广泛使用，成为位置编码的新趋势。
05.位置编码的实践建议
a.编码方式选择
对于通用的预训练模型，正弦位置编码或旋转位置编码是更好的选择，因为它们可以泛化到任意长度。对于特定任务的模型，如果序列长度固定且较短，可学习位置编码可能效果更好。相对位置编码在需要长距离建模的任务上有优势。
b.编码添加方式
位置编码可以与词嵌入相加（加法），也可以拼接（拼接）。加法是主流选择，保持维度不变，参数量更少。拼接会增加维度，需要更多参数，但提供了更大的表达空间。实践中加法方式效果通常已经足够好。
c.缩放因子
有些实现在添加位置编码前会对词嵌入进行缩放，乘以sqrt(d_model)。这是为了平衡词嵌入和位置编码的量级，避免位置编码被词嵌入淹没。但不是所有模型都使用这个技巧，需要根据具体情况调整。
d.长度外推
对于需要处理超长序列的任务，位置编码的外推能力很重要。正弦编码和旋转编码具有较好的外推性。可以通过调整频率、使用插值等方法提升外推能力。ALiBi等新方法直接在注意力分数上加入位置偏置，完全避免了外推问题。
01.编码器层结构
a.层组成
a.基本架构
Transformer编码器层由两个主要子层组成：多头自注意力层和前馈神经网络层。每个子层后面都有残差连接和层归一化。这种结构简洁而强大，通过堆叠多层可以构建深度模型。编码器的输入是词嵌入加位置编码，输出是上下文化的表示。
b.完整实现
---
import torch
import torch.nn as nn
class TransformerEncoderLayer(nn.Module):
"""Transformer编码器层"""
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(TransformerEncoderLayer, self).__init__()
# 多头自注意力
self.self_attn = MultiHeadAttention(d_model, num_heads, dropout)
# 前馈神经网络
self.feed_forward = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.ReLU(),
nn.Dropout(dropout),
nn.Linear(d_ff, d_model)
)
# 层归一化
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
# Dropout
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
def forward(self, x, mask=None):
"""
Args:
x: [batch_size, seq_len, d_model]
mask: 注意力掩码
Returns:
output: [batch_size, seq_len, d_model]
"""
# 多头自注意力 + 残差 + 归一化
attn_output, _ = self.self_attn(x, x, x, mask)
x = x + self.dropout1(attn_output)
x = self.norm1(x)
# 前馈网络 + 残差 + 归一化
ff_output = self.feed_forward(x)
x = x + self.dropout2(ff_output)
x = self.norm2(x)
return x
class TransformerEncoder(nn.Module):
"""完整的Transformer编码器"""
def __init__(self, vocab_size, d_model=512, num_heads=8,
num_layers=6, d_ff=2048, max_len=5000, dropout=0.1):
super(TransformerEncoder, self).__init__()
# 词嵌入
self.embedding = nn.Embedding(vocab_size, d_model)
# 位置编码
self.pos_encoding = SinusoidalPositionalEncoding(d_model, max_len, dropout)
# 编码器层堆叠
self.layers = nn.ModuleList([
TransformerEncoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# 缩放因子
self.scale = math.sqrt(d_model)
def forward(self, x, mask=None):
"""
Args:
x: 输入token索引 [batch_size, seq_len]
mask: padding掩码 [batch_size, 1, 1, seq_len]
Returns:
output: 编码后的表示 [batch_size, seq_len, d_model]
"""
# 词嵌入 + 缩放
x = self.embedding(x) * self.scale
# 添加位置编码
x = self.pos_encoding(x)
# 通过所有编码器层
for layer in self.layers:
x = layer(x, mask)
return x
# 使用示例
vocab_size = 10000
encoder = TransformerEncoder(
vocab_size=vocab_size,
d_model=512,
num_heads=8,
num_layers=6,
d_ff=2048
)
# 输入
batch_size, seq_len = 4, 20
input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
# 编码
output = encoder(input_ids)
print(f"输入形状: {input_ids.shape}")
print(f"输出形状: {output.shape}")
print(f"编码器参数量: {sum(p.numel() for p in encoder.parameters()):,}")
---
b.前馈网络
前馈网络是一个简单的两层全连接网络，中间使用ReLU激活。第一层将维度从d_model扩展到d_ff（通常是4倍），第二层再压缩回d_model。这个网络对每个位置独立应用，提供非线性变换。前馈网络的参数量通常占编码器的大部分。
c.残差连接
每个子层的输出都与输入相加，形成残差连接。残差连接使得梯度可以直接传播，缓解深层网络的训练困难。它还允许模型学习恒等映射，使得添加新层不会降低性能。残差连接是训练深度Transformer的关键。
d.层归一化
层归一化在每个子层后应用，稳定训练过程。它对每个样本的特征维度进行归一化，使得激活值的分布保持稳定。层归一化的位置有Post-LN和Pre-LN两种选择，Pre-LN在深层模型中更稳定。
02.编码器的堆叠
a.深度选择
a.层数影响
编码器的层数是重要的超参数。BERT-Base使用12层，BERT-Large使用24层。更深的模型有更强的表达能力，但训练更困难，需要更多数据。在实践中，6-12层对于大多数任务已经足够。
b.深度编码器实现
---
import torch
import torch.nn as nn
class DeepTransformerEncoder(nn.Module):
"""深度Transformer编码器（带Pre-LN）"""
def __init__(self, vocab_size, d_model=512, num_heads=8,
num_layers=12, d_ff=2048, dropout=0.1):
super(DeepTransformerEncoder, self).__init__()
self.embedding = nn.Embedding(vocab_size, d_model)
self.pos_encoding = SinusoidalPositionalEncoding(d_model, dropout=dropout)
# 使用Pre-LN的编码器层
self.layers = nn.ModuleList([
PreLNEncoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# 最后的层归一化
self.final_norm = nn.LayerNorm(d_model)
self.scale = math.sqrt(d_model)
def forward(self, x, mask=None):
x = self.embedding(x) * self.scale
x = self.pos_encoding(x)
for layer in self.layers:
x = layer(x, mask)
x = self.final_norm(x)
return x
class PreLNEncoderLayer(nn.Module):
"""Pre-LN编码器层（先归一化后注意力）"""
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(PreLNEncoderLayer, self).__init__()
self.self_attn = MultiHeadAttention(d_model, num_heads, dropout)
self.feed_forward = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.GELU(), # 使用GELU激活
nn.Dropout(dropout),
nn.Linear(d_ff, d_model)
)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
def forward(self, x, mask=None):
# Pre-LN: 先归一化
normed = self.norm1(x)
attn_output, _ = self.self_attn(normed, normed, normed, mask)
x = x + self.dropout1(attn_output)
normed = self.norm2(x)
ff_output = self.feed_forward(normed)
x = x + self.dropout2(ff_output)
return x
# 对比Post-LN和Pre-LN
print("Post-LN: x -> Attention -> Add -> Norm -> FFN -> Add -> Norm")
print("Pre-LN: x -> Norm -> Attention -> Add -> Norm -> FFN -> Add")
print("\nPre-LN在深层模型中更稳定，是目前的主流选择")
---
b.梯度流动
深层Transformer的训练需要良好的梯度流动。残差连接提供了梯度的直接路径，Pre-LN进一步稳定了梯度。在非常深的模型中，可能还需要使用梯度裁剪、warmup等技巧。合理的初始化也很重要，避免梯度爆炸或消失。
c.计算效率
编码器的计算复杂度随层数线性增长。每层的主要开销是多头注意力（O(n²d)）和前馈网络（O(nd²))。对于长序列，注意力是瓶颈；对于短序列，前馈网络占主导。优化时需要根据具体情况选择策略。
d.参数共享
ALBERT等模型使用跨层参数共享来减少参数量。所有层共享相同的参数，只增加深度不增加参数。这种方法在某些任务上效果不错，但通常不如独立参数的模型。参数共享是在模型大小和性能之间的权衡。
03.编码器的应用
a.BERT预训练
a.MLM任务
BERT使用Transformer编码器进行预训练，主要任务是Masked Language Modeling（MLM）。随机遮盖输入中的部分词，让模型预测被遮盖的词。这种训练方式使得编码器学习双向的上下文表示。
b.BERT实现
---
import torch
import torch.nn as nn
class BERTEncoder(nn.Module):
"""BERT风格的编码器"""
def __init__(self, vocab_size, d_model=768, num_heads=12,
num_layers=12, d_ff=3072, max_len=512, dropout=0.1):
super(BERTEncoder, self).__init__()
# Token嵌入
self.token_embedding = nn.Embedding(vocab_size, d_model)
# 位置嵌入（可学习）
self.position_embedding = nn.Embedding(max_len, d_model)
# Token类型嵌入（用于句子对任务）
self.token_type_embedding = nn.Embedding(2, d_model)
# Dropout
self.dropout = nn.Dropout(dropout)
# 编码器层
self.layers = nn.ModuleList([
TransformerEncoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# 层归一化
self.norm = nn.LayerNorm(d_model)
def forward(self, input_ids, token_type_ids=None, attention_mask=None):
"""
Args:
input_ids: [batch_size, seq_len]
token_type_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
Returns:
output: [batch_size, seq_len, d_model]
"""
batch_size, seq_len = input_ids.size()
# Token嵌入
token_embeds = self.token_embedding(input_ids)
# 位置嵌入
positions = torch.arange(seq_len, device=input_ids.device)
positions = positions.unsqueeze(0).expand(batch_size, -1)
position_embeds = self.position_embedding(positions)
# Token类型嵌入
if token_type_ids is None:
token_type_ids = torch.zeros_like(input_ids)
token_type_embeds = self.token_type_embedding(token_type_ids)
# 组合嵌入
embeddings = token_embeds + position_embeds + token_type_embeds
embeddings = self.dropout(embeddings)
# 处理attention mask
if attention_mask is not None:
attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
# 通过编码器层
hidden_states = embeddings
for layer in self.layers:
hidden_states = layer(hidden_states, attention_mask)
hidden_states = self.norm(hidden_states)
return hidden_states
# MLM预测头
class MLMHead(nn.Module):
"""Masked Language Modeling预测头"""
def __init__(self, d_model, vocab_size):
super(MLMHead, self).__init__()
self.dense = nn.Linear(d_model, d_model)
self.layer_norm = nn.LayerNorm(d_model)
self.decoder = nn.Linear(d_model, vocab_size)
def forward(self, hidden_states):
hidden_states = self.dense(hidden_states)
hidden_states = nn.functional.gelu(hidden_states)
hidden_states = self.layer_norm(hidden_states)
logits = self.decoder(hidden_states)
return logits
# 使用示例
bert = BERTEncoder(vocab_size=30000)
mlm_head = MLMHead(768, 30000)
input_ids = torch.randint(0, 30000, (4, 128))
hidden_states = bert(input_ids)
logits = mlm_head(hidden_states)
print(f"BERT输出: {hidden_states.shape}")
print(f"MLM logits: {logits.shape}")
---
b.文本分类
编码器可以用于文本分类任务。通常使用[CLS] token的表示或对所有token的表示进行池化，然后接一个分类头。编码器提供了强大的文本理解能力，在情感分析、主题分类等任务上表现出色。
c.序列标注
编码器也适合序列标注任务，如命名实体识别、词性标注等。每个token的表示直接用于预测该位置的标签。编码器的双向上下文建模能力使得它在序列标注上优于传统的BiLSTM-CRF模型。
d.句子对任务
通过token type embeddings，编码器可以处理句子对任务，如文本蕴含、语义相似度等。两个句子拼接后输入编码器，使用[CLS] token的表示进行分类。这种方式在BERT、RoBERTa等模型中广泛使用。
04.编码器优化技巧
a.Warmup策略
训练初期使用较小的学习率，逐渐增加到目标值，然后再衰减。Warmup有助于稳定训练，避免初期的梯度爆炸。通常warmup步数设置为总步数的10%左右。BERT、GPT等模型都使用warmup策略。
b.梯度累积
当GPU内存不足时，可以使用梯度累积来模拟更大的batch size。每次前向传播后累积梯度，多次累积后再更新参数。这种方法可以在有限的硬件上训练大模型，但会增加训练时间。
c.混合精度训练
使用FP16进行前向和反向传播，使用FP32存储参数和更新。混合精度可以减少内存占用，加速训练，同时保持数值稳定性。现代深度学习框架都支持自动混合精度训练。
d.检查点保存
定期保存模型检查点，避免训练中断导致的损失。可以保存最佳模型和最近的几个检查点。对于大模型，检查点文件可能很大，需要合理管理存储空间。
01.解码器层结构
a.三层子结构
a.基本架构
Transformer解码器层包含三个主要子层：Masked Self-Attention（带因果掩码的自注意力）、Encoder-Decoder Attention（交叉注意力）和Feed-Forward Network（前馈网络）。每个子层后都有残差连接和层归一化。解码器的设计使其既能关注已生成的内容，又能利用编码器的信息。
b.完整实现
---
import torch
import torch.nn as nn
import math
class TransformerDecoderLayer(nn.Module):
"""Transformer解码器层"""
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(TransformerDecoderLayer, self).__init__()
# Masked自注意力
self.self_attn = MultiHeadAttention(d_model, num_heads, dropout)
# 编码器-解码器注意力（交叉注意力）
self.cross_attn = MultiHeadAttention(d_model, num_heads, dropout)
# 前馈网络
self.feed_forward = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.ReLU(),
nn.Dropout(dropout),
nn.Linear(d_ff, d_model)
)
# 层归一化
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.norm3 = nn.LayerNorm(d_model)
# Dropout
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
self.dropout3 = nn.Dropout(dropout)
def forward(self, x, encoder_output, src_mask=None, tgt_mask=None):
"""
Args:
x: 解码器输入 [batch_size, tgt_len, d_model]
encoder_output: 编码器输出 [batch_size, src_len, d_model]
src_mask: 源序列掩码
tgt_mask: 目标序列因果掩码
Returns:
output: [batch_size, tgt_len, d_model]
"""
# 1. Masked自注意力
self_attn_output, _ = self.self_attn(x, x, x, tgt_mask)
x = x + self.dropout1(self_attn_output)
x = self.norm1(x)
# 2. 编码器-解码器注意力
cross_attn_output, _ = self.cross_attn(
x, encoder_output, encoder_output, src_mask
)
x = x + self.dropout2(cross_attn_output)
x = self.norm2(x)
# 3. 前馈网络
ff_output = self.feed_forward(x)
x = x + self.dropout3(ff_output)
x = self.norm3(x)
return x
class TransformerDecoder(nn.Module):
"""完整的Transformer解码器"""
def __init__(self, vocab_size, d_model=512, num_heads=8,
num_layers=6, d_ff=2048, max_len=5000, dropout=0.1):
super(TransformerDecoder, self).__init__()
# 词嵌入
self.embedding = nn.Embedding(vocab_size, d_model)
# 位置编码
self.pos_encoding = SinusoidalPositionalEncoding(d_model, max_len, dropout)
# 解码器层堆叠
self.layers = nn.ModuleList([
TransformerDecoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# 输出投影
self.output_projection = nn.Linear(d_model, vocab_size)
self.scale = math.sqrt(d_model)
def create_causal_mask(self, size):
"""创建因果掩码"""
mask = torch.tril(torch.ones(size, size))
return mask.unsqueeze(0).unsqueeze(0)
def forward(self, tgt, encoder_output, src_mask=None):
"""
Args:
tgt: 目标序列 [batch_size, tgt_len]
encoder_output: 编码器输出 [batch_size, src_len, d_model]
src_mask: 源序列掩码
Returns:
logits: [batch_size, tgt_len, vocab_size]
"""
# 词嵌入 + 缩放
x = self.embedding(tgt) * self.scale
# 添加位置编码
x = self.pos_encoding(x)
# 创建因果掩码
tgt_len = tgt.size(1)
tgt_mask = self.create_causal_mask(tgt_len).to(tgt.device)
# 通过所有解码器层
for layer in self.layers:
x = layer(x, encoder_output, src_mask, tgt_mask)
# 输出投影
logits = self.output_projection(x)
return logits
# 使用示例
vocab_size = 10000
decoder = TransformerDecoder(
vocab_size=vocab_size,
d_model=512,
num_heads=8,
num_layers=6,
d_ff=2048
)
batch_size, src_len, tgt_len = 4, 20, 15
# 模拟编码器输出
encoder_output = torch.randn(batch_size, src_len, 512)
# 目标序列
tgt = torch.randint(0, vocab_size, (batch_size, tgt_len))
# 解码
logits = decoder(tgt, encoder_output)
print(f"目标序列形状: {tgt.shape}")
print(f"编码器输出形状: {encoder_output.shape}")
print(f"解码器输出形状: {logits.shape}")
print(f"解码器参数量: {sum(p.numel() for p in decoder.parameters()):,}")
---
b.因果掩码
解码器的自注意力必须使用因果掩码，确保每个位置只能关注当前及之前的位置。这是自回归生成的关键，保证了生成过程的正确性。因果掩码是一个下三角矩阵，上三角部分被设为负无穷，softmax后权重为0。
c.交叉注意力
交叉注意力允许解码器关注编码器的输出。Query来自解码器，Key和Value来自编码器。这种机制使得解码器能够利用源序列的信息进行生成。在机器翻译中，交叉注意力学习源语言和目标语言之间的对齐关系。
d.层间信息流
解码器的信息流动路径：输入 -> Masked Self-Attention -> Cross-Attention -> Feed-Forward -> 输出。每一层都在前一层的基础上进一步精炼表示。Masked Self-Attention建模目标序列内部的依赖，Cross-Attention融合源序列信息，Feed-Forward提供非线性变换。
02.完整Transformer模型
a.编码器-解码器架构
a.整体结构
完整的Transformer模型由编码器栈和解码器栈组成。编码器处理源序列，解码器基于编码器输出生成目标序列。两者通过交叉注意力连接。这种架构适合序列到序列任务，如机器翻译、文本摘要等。
b.完整实现
---
import torch
import torch.nn as nn
class Transformer(nn.Module):
"""完整的Transformer模型"""
def __init__(self, src_vocab_size, tgt_vocab_size,
d_model=512, num_heads=8, num_encoder_layers=6,
num_decoder_layers=6, d_ff=2048, max_len=5000,
dropout=0.1):
super(Transformer, self).__init__()
# 编码器
self.encoder = TransformerEncoder(
src_vocab_size, d_model, num_heads,
num_encoder_layers, d_ff, max_len, dropout
)
# 解码器
self.decoder = TransformerDecoder(
tgt_vocab_size, d_model, num_heads,
num_decoder_layers, d_ff, max_len, dropout
)
def forward(self, src, tgt, src_mask=None, tgt_mask=None):
"""
Args:
src: 源序列 [batch_size, src_len]
tgt: 目标序列 [batch_size, tgt_len]
src_mask: 源序列掩码
tgt_mask: 目标序列掩码
Returns:
logits: [batch_size, tgt_len, tgt_vocab_size]
"""
# 编码
encoder_output = self.encoder(src, src_mask)
# 解码
logits = self.decoder(tgt, encoder_output, src_mask)
return logits
def generate(self, src, max_len=50, sos_idx=1, eos_idx=2):
"""
自回归生成
Args:
src: 源序列 [1, src_len]
max_len: 最大生成长度
sos_idx: 起始符索引
eos_idx: 结束符索引
Returns:
generated: 生成的序列
"""
self.eval()
device = src.device
# 编码源序列
with torch.no_grad():
encoder_output = self.encoder(src)
# 初始化目标序列
tgt = torch.tensor([[sos_idx]], device=device)
for _ in range(max_len):
with torch.no_grad():
# 解码
logits = self.decoder(tgt, encoder_output)
# 获取最后一个位置的预测
next_token_logits = logits[0, -1, :]
next_token = next_token_logits.argmax().unsqueeze(0).unsqueeze(0)
# 添加到目标序列
tgt = torch.cat([tgt, next_token], dim=1)
# 如果生成结束符，停止
if next_token.item() == eos_idx:
break
return tgt.squeeze(0)
# 训练示例
def train_transformer(model, train_loader, optimizer, criterion, device):
"""训练Transformer模型"""
model.train()
total_loss = 0
for batch in train_loader:
src = batch['src'].to(device)
tgt = batch['tgt'].to(device)
# 目标序列分为输入和标签
tgt_input = tgt[:, :-1]
tgt_output = tgt[:, 1:]
# 前向传播
logits = model(src, tgt_input)
# 计算损失
loss = criterion(
logits.reshape(-1, logits.size(-1)),
tgt_output.reshape(-1)
)
# 反向传播
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
total_loss += loss.item()
return total_loss / len(train_loader)
# 使用示例
model = Transformer(
src_vocab_size=10000,
tgt_vocab_size=8000,
d_model=512,
num_heads=8,
num_encoder_layers=6,
num_decoder_layers=6
)
print(f"模型总参数量: {sum(p.numel() for p in model.parameters()):,}")
# 测试生成
src = torch.randint(0, 10000, (1, 20))
generated = model.generate(src, max_len=30)
print(f"生成序列长度: {generated.size(0)}")
---
b.训练策略
Transformer的训练使用Teacher Forcing策略，将真实的目标序列作为解码器输入。损失函数是交叉熵，在每个位置预测下一个词。训练时使用标签平滑、warmup、学习率调度等技巧。优化器通常选择Adam，学习率根据步数动态调整。
c.推理策略
推理时使用自回归生成，每次生成一个词，将其作为下一步的输入。可以使用贪婪解码、Beam Search或采样策略。Beam Search通常能获得更好的结果，但计算开销更大。对于需要多样性的任务，可以使用Top-K或Top-P采样。
d.KV缓存优化
自回归生成时，每步都需要重新计算所有之前位置的Key和Value，造成大量重复计算。KV缓存技术缓存已计算的Key和Value，只计算新位置的值。这大幅加速了推理，特别是在生成长序列时。现代推理框架都实现了KV缓存优化。
03.仅解码器架构
a.GPT模型
a.架构特点
GPT系列模型只使用Transformer的解码器部分，去掉了交叉注意力层。模型通过自回归方式预训练，学习语言建模任务。这种架构简洁高效，成为大语言模型的主流选择。GPT的成功证明了仅解码器架构的强大能力。
b.GPT实现
---
import torch
import torch.nn as nn
class GPTDecoderLayer(nn.Module):
"""GPT风格的解码器层（无交叉注意力）"""
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(GPTDecoderLayer, self).__init__()
# Masked自注意力
self.self_attn = MultiHeadAttention(d_model, num_heads, dropout)
# 前馈网络
self.feed_forward = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.GELU(), # GPT使用GELU
nn.Dropout(dropout),
nn.Linear(d_ff, d_model)
)
# 层归一化（Pre-LN）
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
def forward(self, x, mask=None):
# Pre-LN架构
normed = self.norm1(x)
attn_output, _ = self.self_attn(normed, normed, normed, mask)
x = x + self.dropout1(attn_output)
normed = self.norm2(x)
ff_output = self.feed_forward(normed)
x = x + self.dropout2(ff_output)
return x
class GPT(nn.Module):
"""GPT语言模型"""
def __init__(self, vocab_size, d_model=768, num_heads=12,
num_layers=12, d_ff=3072, max_len=1024, dropout=0.1):
super(GPT, self).__init__()
# Token嵌入
self.token_embedding = nn.Embedding(vocab_size, d_model)
# 位置嵌入
self.position_embedding = nn.Embedding(max_len, d_model)
# Dropout
self.dropout = nn.Dropout(dropout)
# 解码器层
self.layers = nn.ModuleList([
GPTDecoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# 最终层归一化
self.final_norm = nn.LayerNorm(d_model)
# 输出层（与token embedding共享权重）
self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
self.lm_head.weight = self.token_embedding.weight
def create_causal_mask(self, size, device):
mask = torch.tril(torch.ones(size, size, device=device))
return mask.unsqueeze(0).unsqueeze(0)
def forward(self, input_ids):
"""
Args:
input_ids: [batch_size, seq_len]
Returns:
logits: [batch_size, seq_len, vocab_size]
"""
batch_size, seq_len = input_ids.size()
device = input_ids.device
# Token嵌入
token_embeds = self.token_embedding(input_ids)
# 位置嵌入
positions = torch.arange(seq_len, device=device).unsqueeze(0)
position_embeds = self.position_embedding(positions)
# 组合嵌入
x = self.dropout(token_embeds + position_embeds)
# 创建因果掩码
causal_mask = self.create_causal_mask(seq_len, device)
# 通过所有层
for layer in self.layers:
x = layer(x, causal_mask)
x = self.final_norm(x)
# 输出logits
logits = self.lm_head(x)
return logits
def generate(self, prompt, max_new_tokens=50, temperature=1.0, top_k=None):
"""
文本生成
Args:
prompt: 提示序列 [1, prompt_len]
max_new_tokens: 生成的最大token数
temperature: 温度参数
top_k: Top-K采样
Returns:
generated: 生成的完整序列
"""
self.eval()
generated = prompt
for _ in range(max_new_tokens):
with torch.no_grad():
# 获取logits
logits = self(generated)
# 只取最后一个位置
logits = logits[:, -1, :] / temperature
# Top-K采样
if top_k is not None:
v, _ = torch.topk(logits, top_k)
logits[logits < v[:, [-1]]] = -float('Inf')
# 采样
probs = F.softmax(logits, dim=-1)
next_token = torch.multinomial(probs, num_samples=1)
# 添加到序列
generated = torch.cat([generated, next_token], dim=1)
return generated
# 使用示例
gpt = GPT(vocab_size=50257, d_model=768, num_layers=12)
print(f"GPT参数量: {sum(p.numel() for p in gpt.parameters()):,}")
# 测试生成
prompt = torch.randint(0, 50257, (1, 10))
generated = gpt.generate(prompt, max_new_tokens=20, temperature=0.8, top_k=50)
print(f"生成序列长度: {generated.size(1)}")
---
b.因果语言建模
GPT通过因果语言建模进行预训练，预测序列中的下一个词。这种训练方式使得模型学习了强大的语言生成能力。预训练后的GPT可以通过提示学习（prompt learning）或微调适应各种下游任务。
c.上下文学习
大规模的GPT模型展现出上下文学习（in-context learning）能力，即通过少量示例就能完成新任务，无需参数更新。这种能力随着模型规模增大而增强，是大语言模型的重要特性。GPT-3、GPT-4等模型在上下文学习上表现出色。
d.扩展性优势
仅解码器架构更容易扩展到超大规模。没有交叉注意力简化了模型结构，减少了参数量和计算量。这使得训练千亿甚至万亿参数的模型成为可能。GPT-3有1750亿参数，是当时最大的语言模型之一。
04.解码器的优化与应用
a.推理加速
解码器推理的主要瓶颈是自回归生成的顺序性。优化方法包括KV缓存、批处理、模型量化、算子融合等。Flash Attention、PagedAttention等技术进一步提升了效率。在生产环境中，推理优化至关重要，直接影响服务的响应时间和成本。
b.长文本处理
标准Transformer的长度限制是一个挑战。解决方法包括：增加位置编码的外推能力（如RoPE、ALiBi）、使用滑动窗口注意力、采用稀疏注意力模式等。Longformer、BigBird等模型专门针对长文本优化。最新的模型如GPT-4可以处理32K甚至更长的上下文。
c.多模态扩展
解码器架构可以扩展到多模态场景。通过添加视觉编码器或音频编码器，将其他模态的信息融入语言模型。CLIP、Flamingo、GPT-4V等模型展示了多模态Transformer的强大能力。多模态是AI发展的重要方向。
d.对齐与安全
大语言模型需要与人类价值观对齐，避免生成有害内容。RLHF（Reinforcement Learning from Human Feedback）是主要的对齐方法，通过人类反馈微调模型。此外还有Constitutional AI、红队测试等技术。对齐和安全是部署大模型的关键考虑。
5 预训练模型
5.1 预训练范式
01.预训练的核心思想
a.迁移学习范式
a.基本概念
预训练模型通过在大规模无标注数据上学习通用的语言表示，然后迁移到特定任务上。这种"预训练-微调"范式大幅降低了下游任务对标注数据的需求，提升了模型性能。预训练阶段学习语言的基础知识，微调阶段适应特定任务。这种范式彻底改变了NLP的研究和应用方式。
b.预训练流程实现
---
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
class PretrainingDataset(Dataset):
"""预训练数据集"""
def __init__(self, texts, tokenizer, max_length=512):
self.texts = texts
self.tokenizer = tokenizer
self.max_length = max_length
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
# 分词和编码
tokens = self.tokenizer.encode(text, max_length=self.max_length)
return torch.tensor(tokens)
class PretrainingFramework:
"""预训练框架"""
def __init__(self, model, device='cuda'):
self.model = model.to(device)
self.device = device
def pretrain(self, train_loader, num_epochs, learning_rate=1e-4):
"""
预训练主循环
Args:
train_loader: 训练数据加载器
num_epochs: 训练轮数
learning_rate: 学习率
"""
optimizer = optim.AdamW(
self.model.parameters(),
lr=learning_rate,
betas=(0.9, 0.999),
weight_decay=0.01
)
# 学习率调度器（带warmup）
total_steps = len(train_loader) * num_epochs
warmup_steps = int(0.1 * total_steps)
scheduler = self.get_linear_schedule_with_warmup(
optimizer, warmup_steps, total_steps
)
self.model.train()
for epoch in range(num_epochs):
total_loss = 0
for batch_idx, batch in enumerate(train_loader):
batch = batch.to(self.device)
# 前向传播
loss = self.compute_loss(batch)
# 反向传播
optimizer.zero_grad()
loss.backward()
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(
self.model.parameters(), max_norm=1.0
)
optimizer.step()
scheduler.step()
total_loss += loss.item()
if (batch_idx + 1) % 100 == 0:
avg_loss = total_loss / (batch_idx + 1)
print(f"Epoch {epoch+1}, Batch {batch_idx+1}, "
f"Loss: {avg_loss:.4f}, "
f"LR: {scheduler.get_last_lr()[0]:.6f}")
# 保存检查点
self.save_checkpoint(epoch)
def compute_loss(self, batch):
"""计算预训练损失（子类实现）"""
raise NotImplementedError
def get_linear_schedule_with_warmup(self, optimizer,
warmup_steps, total_steps):
"""带warmup的线性学习率调度"""
def lr_lambda(current_step):
if current_step < warmup_steps:
return float(current_step) / float(max(1, warmup_steps))
return max(0.0, float(total_steps - current_step) /
float(max(1, total_steps - warmup_steps)))
return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
def save_checkpoint(self, epoch):
"""保存模型检查点"""
checkpoint = {
'epoch': epoch,
'model_state_dict': self.model.state_dict(),
}
torch.save(checkpoint, f'checkpoint_epoch_{epoch}.pt')
# 使用示例
print("预训练框架组件:")
print("1. 大规模无标注数据")
print("2. 自监督学习任务（MLM、CLM等）")
print("3. 优化器（AdamW）+ 学习率调度（Warmup）")
print("4. 梯度裁剪和混合精度训练")
print("5. 定期保存检查点")
---
b.自监督学习
预训练使用自监督学习，从数据本身构造监督信号，无需人工标注。常见的自监督任务包括掩码语言模型（MLM）、因果语言模型（CLM）、下一句预测（NSP）等。这些任务迫使模型学习语言的深层结构和语义，获得强大的表示能力。
c.规模效应
预训练模型的性能随着模型规模、数据规模和计算量的增加而提升。这种规模效应在大语言模型中尤为明显，催生了GPT-3、PaLM等超大规模模型。但规模扩展也带来了计算成本、环境影响等挑战，需要在性能和成本之间权衡。
d.涌现能力
当模型规模达到一定程度，会出现训练时未明确优化的能力，如上下文学习、思维链推理等。这些涌现能力（emergent abilities）是大模型的重要特征，使得模型能够完成复杂的推理任务。涌现能力的机制仍在研究中。
02.预训练任务设计
a.掩码语言模型
a.MLM原理
掩码语言模型（Masked Language Modeling）随机遮盖输入中的部分词，让模型预测被遮盖的词。BERT使用MLM进行预训练，通常遮盖15%的词。被遮盖的词中，80%替换为[MASK]，10%替换为随机词，10%保持不变。这种设计使得模型学习双向上下文表示。
b.MLM实现
---
import torch
import torch.nn as nn
import random
class MLMPretraining:
"""掩码语言模型预训练"""
def __init__(self, model, vocab_size, mask_token_id,
pad_token_id, mask_prob=0.15):
self.model = model
self.vocab_size = vocab_size
self.mask_token_id = mask_token_id
self.pad_token_id = pad_token_id
self.mask_prob = mask_prob
# MLM预测头
self.mlm_head = nn.Linear(model.d_model, vocab_size)
def create_mlm_batch(self, input_ids):
"""
创建MLM训练批次
Args:
input_ids: [batch_size, seq_len]
Returns:
masked_input: 遮盖后的输入
labels: 原始token（非遮盖位置为-100）
"""
batch_size, seq_len = input_ids.size()
labels = input_ids.clone()
masked_input = input_ids.clone()
# 创建遮盖概率矩阵
probability_matrix = torch.full(
(batch_size, seq_len), self.mask_prob
)
# 不遮盖特殊token（padding等）
special_tokens_mask = (input_ids == self.pad_token_id)
probability_matrix.masked_fill_(special_tokens_mask, value=0.0)
# 确定要遮盖的位置
masked_indices = torch.bernoulli(probability_matrix).bool()
# 非遮盖位置的标签设为-100（忽略）
labels[~masked_indices] = -100
# 80%替换为[MASK]
indices_replaced = torch.bernoulli(
torch.full((batch_size, seq_len), 0.8)
).bool() & masked_indices
masked_input[indices_replaced] = self.mask_token_id
# 10%替换为随机token
indices_random = torch.bernoulli(
torch.full((batch_size, seq_len), 0.5)
).bool() & masked_indices & ~indices_replaced
random_words = torch.randint(
self.vocab_size, (batch_size, seq_len),
dtype=torch.long
)
masked_input[indices_random] = random_words[indices_random]
# 剩余10%保持不变
return masked_input, labels
def compute_mlm_loss(self, input_ids):
"""
计算MLM损失
Args:
input_ids: [batch_size, seq_len]
Returns:
loss: MLM损失
"""
# 创建遮盖批次
masked_input, labels = self.create_mlm_batch(input_ids)
# 前向传播
hidden_states = self.model(masked_input)
# MLM预测
logits = self.mlm_head(hidden_states)
# 计算损失（只在遮盖位置）
loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
loss = loss_fct(
logits.view(-1, self.vocab_size),
labels.view(-1)
)
return loss
# 使用示例
vocab_size = 30000
mask_token_id = 103
pad_token_id = 0
# 模拟输入
batch_size, seq_len = 4, 128
input_ids = torch.randint(1, vocab_size, (batch_size, seq_len))
# 创建MLM训练器（需要实际的模型）
print("MLM预训练流程:")
print("1. 随机选择15%的token进行遮盖")
print("2. 80%替换为[MASK]，10%随机替换，10%保持不变")
print("3. 模型预测被遮盖的token")
print("4. 只在遮盖位置计算损失")
---
b.因果语言模型
因果语言模型（Causal Language Modeling）按顺序预测下一个词，是GPT系列的预训练任务。模型只能看到当前位置之前的词，不能看到未来的词。这种自回归训练使得模型具有强大的生成能力。CLM的优势是简单直接，不需要特殊的遮盖策略。
c.下一句预测
下一句预测（Next Sentence Prediction, NSP）判断两个句子是否连续。BERT最初使用NSP作为辅助任务，但后续研究发现NSP的作用有限。RoBERTa等模型移除了NSP，使用更长的输入序列代替。NSP的设计初衷是学习句子间的关系，但实践中效果不明显。
d.替换词检测
ELECTRA使用替换词检测（Replaced Token Detection）作为预训练任务。生成器生成替换词，判别器判断每个词是否被替换。这种对抗式训练比MLM更高效，因为所有位置都参与训练。ELECTRA在相同计算量下性能优于BERT。
03.预训练数据处理
a.数据来源
a.数据集选择
预训练数据通常来自网页（Common Crawl）、书籍（BookCorpus）、维基百科、新闻、代码等。数据的质量和多样性对模型性能至关重要。高质量的数据能够提升模型的语言理解能力，多样化的数据增强模型的泛化能力。
b.数据处理流程
---
import re
from collections import Counter
class PretrainingDataProcessor:
"""预训练数据处理器"""
def __init__(self, min_length=10, max_length=512):
self.min_length = min_length
self.max_length = max_length
def clean_text(self, text):
"""
文本清洗
Args:
text: 原始文本
Returns:
cleaned_text: 清洗后的文本
"""
# 移除多余空白
text = re.sub(r'\s+', ' ', text)
# 移除特殊字符（保留基本标点）
text = re.sub(r'[^\w\s\.,!?;:\-\(\)]', '', text)
# 移除URL
text = re.sub(r'http\S+|www\S+', '', text)
# 移除邮箱
text = re.sub(r'\S+@\S+', '', text)
return text.strip()
def filter_text(self, text):
"""
文本过滤
Args:
text: 文本
Returns:
is_valid: 是否有效
"""
# 长度过滤
if len(text.split()) < self.min_length:
return False
# 重复字符过滤
if re.search(r'(.)\1{10,}', text):
return False
# 语言检测（简化版，实际应使用langdetect等库）
# 检查是否包含足够的字母字符
alpha_ratio = sum(c.isalpha() for c in text) / len(text)
if alpha_ratio < 0.5:
return False
return True
def deduplicate(self, texts):
"""
去重
Args:
texts: 文本列表
Returns:
unique_texts: 去重后的文本
"""
seen = set()
unique_texts = []
for text in texts:
# 使用文本的hash作为唯一标识
text_hash = hash(text)
if text_hash not in seen:
seen.add(text_hash)
unique_texts.append(text)
return unique_texts
def process_corpus(self, raw_texts):
"""
处理语料库
Args:
raw_texts: 原始文本列表
Returns:
processed_texts: 处理后的文本
stats: 处理统计信息
"""
processed_texts = []
# 清洗和过滤
for text in raw_texts:
cleaned = self.clean_text(text)
if self.filter_text(cleaned):
processed_texts.append(cleaned)
# 去重
processed_texts = self.deduplicate(processed_texts)
# 统计信息
stats = {
'original_count': len(raw_texts),
'processed_count': len(processed_texts),
'total_tokens': sum(len(t.split()) for t in processed_texts),
'avg_length': sum(len(t.split()) for t in processed_texts) /
len(processed_texts) if processed_texts else 0
}
return processed_texts, stats
# 使用示例
processor = PretrainingDataProcessor()
# 模拟原始数据
raw_texts = [
"This is a sample text for pretraining.",
" Multiple spaces should be normalized. ",
"Short", # 太短，会被过滤
"Visit http://example.com for more info.",
"This is a sample text for pretraining.", # 重复
"aaaaaaaaaaaaaaaaaaaaaa", # 重复字符，会被过滤
]
processed_texts, stats = processor.process_corpus(raw_texts)
print("数据处理统计:")
print(f"原始文本数: {stats['original_count']}")
print(f"处理后文本数: {stats['processed_count']}")
print(f"总token数: {stats['total_tokens']}")
print(f"平均长度: {stats['avg_length']:.2f}")
print(f"\n处理后的文本:")
for i, text in enumerate(processed_texts, 1):
print(f"{i}. {text}")
---
b.数据清洗
数据清洗包括移除HTML标签、URL、特殊字符等噪声。还需要过滤低质量文本，如过短、重复度高、包含大量非语言字符的文本。清洗质量直接影响模型性能，需要根据数据来源设计针对性的清洗策略。
c.去重与采样
大规模数据中存在大量重复内容，需要进行去重。可以使用精确去重（完全相同）或近似去重（高度相似）。此外，不同来源的数据质量不同，需要合理采样以平衡数据分布。高质量数据应该有更高的采样权重。
d.分词与编码
预训练需要将文本转换为token序列。常用的分词方法包括BPE、WordPiece、SentencePiece等。这些方法能够处理未登录词，平衡词汇表大小和表示能力。分词器的选择影响模型的性能和效率，是预训练的重要环节。
04.计算资源与优化
a.分布式训练
大规模预训练需要分布式训练。数据并行将不同的数据分配到不同的GPU，模型并行将模型的不同部分分配到不同的GPU。流水线并行将模型分成多个阶段，在不同设备上流水线执行。这些技术使得训练超大模型成为可能。
b.混合精度训练
混合精度训练使用FP16进行大部分计算，使用FP32存储主权重。这减少了内存占用，加速了计算，同时保持了数值稳定性。现代GPU对FP16有硬件加速，混合精度可以带来2-3倍的速度提升。PyTorch和TensorFlow都提供了自动混合精度支持。
c.梯度累积
当GPU内存不足以容纳大batch时，可以使用梯度累积。将一个大batch分成多个小batch，累积梯度后再更新参数。这模拟了大batch训练，但增加了训练时间。梯度累积是在硬件限制下训练大模型的常用技巧。
d.检查点与恢复
预训练通常需要数周甚至数月，必须有可靠的检查点机制。定期保存模型状态、优化器状态、随机数种子等，以便在中断后恢复训练。还需要监控训练指标，及时发现和处理异常。大规模训练的工程挑战不容忽视。
5.2 BERT模型
01.BERT架构设计
a.模型结构
a.基本架构
BERT（Bidirectional Encoder Representations from Transformers）使用Transformer编码器架构，通过双向上下文学习文本表示。BERT-Base有12层、768维、12个注意力头，共110M参数。BERT-Large有24层、1024维、16个注意力头，共340M参数。BERT的双向性是其核心优势，能够同时利用左右上下文信息。
b.BERT实现
---
import torch
import torch.nn as nn
import math
class BERTEmbeddings(nn.Module):
"""BERT嵌入层：Token + Position + Segment"""
def __init__(self, vocab_size, d_model=768, max_position=512,
type_vocab_size=2, dropout=0.1):
super(BERTEmbeddings, self).__init__()
# Token嵌入
self.word_embeddings = nn.Embedding(vocab_size, d_model)
# 位置嵌入（可学习）
self.position_embeddings = nn.Embedding(max_position, d_model)
# Segment嵌入（用于区分句子对）
self.token_type_embeddings = nn.Embedding(type_vocab_size, d_model)
# 层归一化和Dropout
self.LayerNorm = nn.LayerNorm(d_model, eps=1e-12)
self.dropout = nn.Dropout(dropout)
def forward(self, input_ids, token_type_ids=None, position_ids=None):
"""
Args:
input_ids: [batch_size, seq_len]
token_type_ids: [batch_size, seq_len]
position_ids: [batch_size, seq_len]
Returns:
embeddings: [batch_size, seq_len, d_model]
"""
batch_size, seq_len = input_ids.size()
# Token嵌入
words_embeddings = self.word_embeddings(input_ids)
# 位置嵌入
if position_ids is None:
position_ids = torch.arange(seq_len, dtype=torch.long,
device=input_ids.device)
position_ids = position_ids.unsqueeze(0).expand(batch_size, -1)
position_embeddings = self.position_embeddings(position_ids)
# Segment嵌入
if token_type_ids is None:
token_type_ids = torch.zeros_like(input_ids)
token_type_embeddings = self.token_type_embeddings(token_type_ids)
# 组合所有嵌入
embeddings = words_embeddings + position_embeddings + token_type_embeddings
embeddings = self.LayerNorm(embeddings)
embeddings = self.dropout(embeddings)
return embeddings
class BERTModel(nn.Module):
"""完整的BERT模型"""
def __init__(self, vocab_size, d_model=768, num_heads=12,
num_layers=12, d_ff=3072, max_position=512, dropout=0.1):
super(BERTModel, self).__init__()
# 嵌入层
self.embeddings = BERTEmbeddings(vocab_size, d_model,
max_position, dropout=dropout)
# Transformer编码器层
self.encoder_layers = nn.ModuleList([
TransformerEncoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# Pooler（用于分类任务）
self.pooler = nn.Sequential(
nn.Linear(d_model, d_model),
nn.Tanh()
)
def forward(self, input_ids, attention_mask=None, token_type_ids=None):
"""
Args:
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
token_type_ids: [batch_size, seq_len]
Returns:
sequence_output: [batch_size, seq_len, d_model]
pooled_output: [batch_size, d_model]
"""
# 嵌入
hidden_states = self.embeddings(input_ids, token_type_ids)
# 处理attention mask
if attention_mask is not None:
# 扩展维度: [batch, 1, 1, seq_len]
extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
# 转换为注意力分数的加性掩码
extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
else:
extended_attention_mask = None
# 通过编码器层
for layer in self.encoder_layers:
hidden_states = layer(hidden_states, extended_attention_mask)
# 序列输出
sequence_output = hidden_states
# Pooled输出（[CLS] token的表示）
pooled_output = self.pooler(sequence_output[:, 0, :])
return sequence_output, pooled_output
# 使用示例
vocab_size = 30522 # BERT的词汇表大小
bert = BERTModel(vocab_size, d_model=768, num_heads=12, num_layers=12)
# 输入
batch_size, seq_len = 4, 128
input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
attention_mask = torch.ones(batch_size, seq_len)
token_type_ids = torch.zeros(batch_size, seq_len, dtype=torch.long)
# 前向传播
sequence_output, pooled_output = bert(input_ids, attention_mask, token_type_ids)
print(f"BERT参数量: {sum(p.numel() for p in bert.parameters()):,}")
print(f"序列输出形状: {sequence_output.shape}")
print(f"Pooled输出形状: {pooled_output.shape}")
---
b.特殊Token
BERT使用特殊token：[CLS]作为序列的开始，用于分类任务；[SEP]分隔不同的句子；[MASK]用于掩码语言模型；[PAD]用于填充。[CLS] token的表示经过pooler后用于句子级别的任务。这些特殊token是BERT设计的重要组成部分。
c.Segment Embeddings
Segment embeddings用于区分句子对任务中的两个句子。第一个句子的所有token使用segment A的嵌入，第二个句子使用segment B的嵌入。这使得模型能够理解句子边界和句子间的关系。在单句任务中，所有token使用相同的segment embedding。
d.Position Embeddings
BERT使用可学习的位置嵌入，而不是Transformer原始论文中的正弦位置编码。每个位置对应一个可学习的向量，通过训练优化。BERT的最大序列长度是512，因此有512个位置嵌入。可学习位置嵌入在BERT的任务上效果良好。
02.BERT预训练任务
a.掩码语言模型
a.MLM策略
BERT的主要预训练任务是掩码语言模型（MLM）。随机选择15%的token进行遮盖，其中80%替换为[MASK]，10%替换为随机token，10%保持不变。模型需要预测被遮盖的原始token。这种策略使得模型学习双向上下文表示。
b.MLM训练实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
class BERTForMLM(nn.Module):
"""BERT的MLM预训练"""
def __init__(self, bert_model, vocab_size):
super(BERTForMLM, self).__init__()
self.bert = bert_model
# MLM预测头
self.mlm_head = nn.Sequential(
nn.Linear(bert_model.embeddings.word_embeddings.embedding_dim,
bert_model.embeddings.word_embeddings.embedding_dim),
nn.GELU(),
nn.LayerNorm(bert_model.embeddings.word_embeddings.embedding_dim),
nn.Linear(bert_model.embeddings.word_embeddings.embedding_dim,
vocab_size)
)
def forward(self, input_ids, attention_mask=None,
token_type_ids=None, labels=None):
"""
Args:
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
token_type_ids: [batch_size, seq_len]
labels: [batch_size, seq_len]，-100表示不计算损失的位置
Returns:
loss: MLM损失（如果提供labels）
logits: 预测logits
"""
# BERT编码
sequence_output, _ = self.bert(input_ids, attention_mask,
token_type_ids)
# MLM预测
prediction_scores = self.mlm_head(sequence_output)
# 计算损失
loss = None
if labels is not None:
loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
loss = loss_fct(prediction_scores.view(-1, prediction_scores.size(-1)),
labels.view(-1))
return loss, prediction_scores
def create_mlm_labels(input_ids, mask_token_id, vocab_size,
mask_prob=0.15):
"""
创建MLM标签
Args:
input_ids: [batch_size, seq_len]
mask_token_id: [MASK] token的ID
vocab_size: 词汇表大小
mask_prob: 遮盖概率
Returns:
masked_input_ids: 遮盖后的输入
labels: 标签（非遮盖位置为-100）
"""
labels = input_ids.clone()
masked_input_ids = input_ids.clone()
# 创建遮盖概率矩阵
probability_matrix = torch.full(input_ids.shape, mask_prob)
# 确定要遮盖的位置
masked_indices = torch.bernoulli(probability_matrix).bool()
# 非遮盖位置标签设为-100
labels[~masked_indices] = -100
# 80%: 替换为[MASK]
indices_replaced = torch.bernoulli(
torch.full(input_ids.shape, 0.8)
).bool() & masked_indices
masked_input_ids[indices_replaced] = mask_token_id
# 10%: 替换为随机token
indices_random = torch.bernoulli(
torch.full(input_ids.shape, 0.5)
).bool() & masked_indices & ~indices_replaced
random_words = torch.randint(vocab_size, input_ids.shape,
dtype=torch.long)
masked_input_ids[indices_random] = random_words[indices_random]
# 10%: 保持不变
return masked_input_ids, labels
# 训练示例
vocab_size = 30522
mask_token_id = 103
bert = BERTModel(vocab_size)
mlm_model = BERTForMLM(bert, vocab_size)
# 创建批次
batch_size, seq_len = 8, 128
input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
# 创建MLM标签
masked_input_ids, labels = create_mlm_labels(input_ids, mask_token_id,
vocab_size)
# 前向传播
loss, logits = mlm_model(masked_input_ids, labels=labels)
print(f"MLM损失: {loss.item():.4f}")
print(f"预测logits形状: {logits.shape}")
# 计算准确率
predictions = logits.argmax(dim=-1)
mask = (labels != -100)
accuracy = (predictions[mask] == labels[mask]).float().mean()
print(f"MLM准确率: {accuracy.item():.4f}")
---
b.下一句预测
BERT最初包含下一句预测（NSP）任务，判断两个句子是否连续。50%的样本是真实的连续句子对，50%是随机组合的句子对。模型使用[CLS] token的表示进行二分类。但后续研究发现NSP的作用有限，RoBERTa等模型移除了NSP。
c.预训练数据
BERT在BookCorpus（8亿词）和英文维基百科（25亿词）上预训练。数据经过清洗、分句、分词等处理。预训练使用了大量计算资源，BERT-Base在16个TPU上训练4天，BERT-Large训练更久。预训练的计算成本是BERT的主要挑战之一。
d.训练细节
BERT使用Adam优化器，学习率1e-4，带warmup的线性衰减。Batch size为256，训练100万步。使用梯度裁剪防止梯度爆炸。Dropout率为0.1。这些超参数经过大量实验调优，对模型性能有重要影响。
03.BERT的变体与改进
a.RoBERTa优化
RoBERTa（Robustly Optimized BERT）是BERT的改进版本。主要改进包括：移除NSP任务、使用更大的batch size、训练更长时间、使用更多数据、动态掩码（每次epoch改变掩码位置）。这些改进使得RoBERTa在多个任务上超越BERT，证明了训练策略的重要性。
b.ALBERT轻量化
ALBERT通过参数共享和因式分解减少参数量。跨层参数共享使得所有层使用相同的参数，大幅减少参数。嵌入因式分解将大的词嵌入矩阵分解为两个小矩阵。ALBERT还使用句子顺序预测（SOP）代替NSP。这些技术使得ALBERT在参数更少的情况下达到相当的性能。
c.DistilBERT蒸馏
DistilBERT通过知识蒸馏将BERT压缩到原来的40%大小，同时保留97%的性能。学生模型（DistilBERT）学习模仿教师模型（BERT）的输出分布。蒸馏使用软标签和硬标签的组合，还包括余弦距离损失。DistilBERT在推理速度和模型大小上有显著优势。
d.ELECTRA高效训练
ELECTRA使用替换词检测代替MLM，训练效率更高。生成器生成替换词，判别器判断每个token是否被替换。所有token都参与训练，而不是只有15%。ELECTRA在相同计算量下性能优于BERT，是预训练效率的重要突破。
04.BERT的应用
a.文本分类
a.分类任务设计
BERT可以用于各种文本分类任务，如情感分析、主题分类、意图识别等。使用[CLS] token的pooled表示，接一个分类头进行预测。微调时只需要少量标注数据，就能达到很好的效果。
b.分类实现
---
import torch
import torch.nn as nn
class BERTForSequenceClassification(nn.Module):
"""BERT文本分类模型"""
def __init__(self, bert_model, num_labels, dropout=0.1):
super(BERTForSequenceClassification, self).__init__()
self.bert = bert_model
self.dropout = nn.Dropout(dropout)
self.classifier = nn.Linear(bert_model.embeddings.word_embeddings.embedding_dim,
num_labels)
def forward(self, input_ids, attention_mask=None,
token_type_ids=None, labels=None):
"""
Args:
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
token_type_ids: [batch_size, seq_len]
labels: [batch_size]
Returns:
loss: 分类损失（如果提供labels）
logits: 分类logits [batch_size, num_labels]
"""
# BERT编码
_, pooled_output = self.bert(input_ids, attention_mask,
token_type_ids)
# Dropout和分类
pooled_output = self.dropout(pooled_output)
logits = self.classifier(pooled_output)
# 计算损失
loss = None
if labels is not None:
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(logits, labels)
return loss, logits
# 使用示例
bert = BERTModel(vocab_size=30522)
classifier = BERTForSequenceClassification(bert, num_labels=2)
# 输入
input_ids = torch.randint(0, 30522, (8, 128))
attention_mask = torch.ones(8, 128)
labels = torch.randint(0, 2, (8,))
# 训练
loss, logits = classifier(input_ids, attention_mask, labels=labels)
print(f"分类损失: {loss.item():.4f}")
print(f"Logits形状: {logits.shape}")
# 预测
predictions = logits.argmax(dim=-1)
print(f"预测结果: {predictions}")
---
b.序列标注
BERT用于序列标注任务（如NER、词性标注）时，使用每个token的表示进行预测。在token表示上接一个线性层，输出每个位置的标签。BERT的双向上下文使得它在序列标注上优于传统的BiLSTM-CRF模型。
c.问答系统
BERT在问答任务（如SQuAD）上表现出色。将问题和段落拼接输入BERT，预测答案的起始和结束位置。使用两个分类头分别预测起始和结束位置的概率。BERT在SQuAD上达到了接近人类的性能。
d.句子对任务
BERT天然支持句子对任务，如文本蕴含、语义相似度等。使用[SEP]分隔两个句子，segment embeddings区分它们。[CLS] token的表示用于分类。BERT在GLUE等句子对任务基准上取得了最佳性能。
5.3 GPT系列
01.GPT架构演进
a.GPT-1基础
a.模型设计
GPT-1（Generative Pre-trained Transformer）使用仅解码器的Transformer架构，通过因果语言建模进行预训练。模型有12层、768维、12个注意力头，共117M参数。GPT-1证明了大规模预训练+任务微调的有效性，开创了生成式预训练的范式。
b.GPT实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class GPTBlock(nn.Module):
"""GPT的Transformer块"""
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(GPTBlock, self).__init__()
# Masked自注意力
self.ln1 = nn.LayerNorm(d_model)
self.attn = MultiHeadAttention(d_model, num_heads, dropout)
# 前馈网络
self.ln2 = nn.LayerNorm(d_model)
self.ffn = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.GELU(),
nn.Dropout(dropout),
nn.Linear(d_ff, d_model),
nn.Dropout(dropout)
)
def forward(self, x, mask=None):
"""
Args:
x: [batch_size, seq_len, d_model]
mask: 因果掩码
Returns:
output: [batch_size, seq_len, d_model]
"""
# Pre-LN: 先归一化再注意力
attn_out, _ = self.attn(self.ln1(x), self.ln1(x), self.ln1(x), mask)
x = x + attn_out
# 前馈网络
x = x + self.ffn(self.ln2(x))
return x
class GPTModel(nn.Module):
"""GPT语言模型"""
def __init__(self, vocab_size, d_model=768, num_heads=12,
num_layers=12, d_ff=3072, max_len=1024, dropout=0.1):
super(GPTModel, self).__init__()
self.d_model = d_model
# Token嵌入
self.token_embedding = nn.Embedding(vocab_size, d_model)
# 位置嵌入
self.position_embedding = nn.Embedding(max_len, d_model)
# Dropout
self.dropout = nn.Dropout(dropout)
# Transformer块
self.blocks = nn.ModuleList([
GPTBlock(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# 最终层归一化
self.ln_f = nn.LayerNorm(d_model)
# 输出层（权重共享）
self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
self.lm_head.weight = self.token_embedding.weight
# 初始化
self.apply(self._init_weights)
def _init_weights(self, module):
"""初始化权重"""
if isinstance(module, nn.Linear):
torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
if module.bias is not None:
torch.nn.init.zeros_(module.bias)
elif isinstance(module, nn.Embedding):
torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
def create_causal_mask(self, seq_len, device):
"""创建因果掩码"""
mask = torch.tril(torch.ones(seq_len, seq_len, device=device))
return mask.view(1, 1, seq_len, seq_len)
def forward(self, input_ids, labels=None):
"""
Args:
input_ids: [batch_size, seq_len]
labels: [batch_size, seq_len]（用于计算损失）
Returns:
loss: 语言模型损失（如果提供labels）
logits: [batch_size, seq_len, vocab_size]
"""
batch_size, seq_len = input_ids.size()
device = input_ids.device
# Token嵌入
token_embeds = self.token_embedding(input_ids)
# 位置嵌入
positions = torch.arange(0, seq_len, device=device).unsqueeze(0)
position_embeds = self.position_embedding(positions)
# 组合嵌入
x = self.dropout(token_embeds + position_embeds)
# 因果掩码
mask = self.create_causal_mask(seq_len, device)
# 通过所有Transformer块
for block in self.blocks:
x = block(x, mask)
# 最终层归一化
x = self.ln_f(x)
# 输出logits
logits = self.lm_head(x)
# 计算损失
loss = None
if labels is not None:
# 移位：预测下一个token
shift_logits = logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)),
shift_labels.view(-1))
return loss, logits
# 使用示例
vocab_size = 50257 # GPT-2的词汇表大小
gpt = GPTModel(vocab_size, d_model=768, num_layers=12)
print(f"GPT参数量: {sum(p.numel() for p in gpt.parameters()):,}")
# 训练示例
batch_size, seq_len = 4, 128
input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
loss, logits = gpt(input_ids, labels=input_ids)
print(f"语言模型损失: {loss.item():.4f}")
print(f"Logits形状: {logits.shape}")
---
b.GPT-2扩展
GPT-2将模型规模扩展到1.5B参数，在更大的数据集WebText（40GB文本）上训练。GPT-2展示了零样本学习能力，无需微调就能完成多种任务。GPT-2的发布引发了关于AI安全的讨论，OpenAI最初只发布了小版本。GPT-2证明了规模扩展的有效性。
c.GPT-3突破
GPT-3有175B参数，是当时最大的语言模型。在300B tokens上训练，展示了强大的上下文学习能力。GPT-3可以通过少量示例（few-shot）或零样本（zero-shot）完成任务，无需参数更新。GPT-3的涌现能力令人惊叹，开启了大语言模型时代。
d.InstructGPT对齐
InstructGPT通过RLHF（Reinforcement Learning from Human Feedback）对GPT-3进行对齐。收集人类偏好数据，训练奖励模型，使用PPO算法优化策略。InstructGPT更好地遵循人类指令，减少有害输出。这种对齐技术成为后续大模型的标准做法。
02.因果语言建模
a.自回归训练
a.训练目标
GPT使用因果语言建模（Causal Language Modeling）进行预训练，预测序列中的下一个token。给定前面的tokens，最大化下一个token的条件概率。这种自回归训练使得模型具有强大的生成能力，能够生成连贯的长文本。
b.训练实现
---
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
class LanguageModelingDataset(Dataset):
"""语言建模数据集"""
def __init__(self, texts, tokenizer, max_length=1024):
self.examples = []
for text in texts:
tokens = tokenizer.encode(text)
# 分割成固定长度的序列
for i in range(0, len(tokens) - max_length, max_length):
self.examples.append(tokens[i:i+max_length])
def __len__(self):
return len(self.examples)
def __getitem__(self, idx):
return torch.tensor(self.examples[idx], dtype=torch.long)
def train_gpt(model, train_loader, num_epochs, device='cuda'):
"""训练GPT模型"""
model = model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4,
betas=(0.9, 0.95), weight_decay=0.1)
# 学习率调度
total_steps = len(train_loader) * num_epochs
warmup_steps = int(0.1 * total_steps)
def get_lr(step):
if step < warmup_steps:
return step / warmup_steps
return max(0.1, (total_steps - step) / (total_steps - warmup_steps))
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, get_lr)
model.train()
for epoch in range(num_epochs):
total_loss = 0
for batch_idx, batch in enumerate(train_loader):
batch = batch.to(device)
# 前向传播
loss, _ = model(batch, labels=batch)
# 反向传播
optimizer.zero_grad()
loss.backward()
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
scheduler.step()
total_loss += loss.item()
if (batch_idx + 1) % 100 == 0:
avg_loss = total_loss / (batch_idx + 1)
perplexity = math.exp(avg_loss)
print(f"Epoch {epoch+1}, Batch {batch_idx+1}, "
f"Loss: {avg_loss:.4f}, PPL: {perplexity:.2f}")
# 保存检查点
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
}, f'gpt_checkpoint_epoch_{epoch}.pt')
print("因果语言建模训练流程:")
print("1. 将文本分割成固定长度的序列")
print("2. 预测每个位置的下一个token")
print("3. 使用交叉熵损失，在所有位置计算")
print("4. 评估指标：困惑度（Perplexity）")
---
b.困惑度评估
困惑度（Perplexity）是语言模型的标准评估指标，定义为交叉熵损失的指数。困惑度越低，模型越好。困惑度可以理解为模型在预测下一个词时的"困惑程度"。GPT-2在WebText测试集上的困惑度约为20，表示模型平均在20个候选词中选择。
c.生成策略
GPT的生成可以使用贪婪解码、Beam Search或采样。贪婪解码每次选择概率最高的词，确定性但可能重复。Beam Search保留多个候选序列，质量更高但计算开销大。采样引入随机性，生成多样化的文本。Top-K和Top-P采样是常用的采样策略。
d.温度调节
温度参数控制生成的随机性。温度为1时使用原始概率分布，温度接近0时接近贪婪解码，温度大于1时增加随机性。较低的温度生成更保守、更连贯的文本，较高的温度生成更有创意但可能不连贯的文本。温度是控制生成质量和多样性的重要参数。
03.上下文学习能力
a.Few-shot学习
a.提示设计
GPT-3展示了强大的上下文学习能力，通过在提示中提供少量示例就能完成任务。这种few-shot学习无需参数更新，只需要精心设计提示。示例的质量和数量影响性能，通常3-5个示例效果较好。
b.Few-shot实现
---
import torch
class FewShotLearner:
"""Few-shot学习器"""
def __init__(self, model, tokenizer):
self.model = model
self.tokenizer = tokenizer
def create_few_shot_prompt(self, examples, query):
"""
创建few-shot提示
Args:
examples: 示例列表 [(input, output), ...]
query: 查询输入
Returns:
prompt: 完整的提示文本
"""
prompt_parts = []
# 添加示例
for input_text, output_text in examples:
prompt_parts.append(f"Input: {input_text}")
prompt_parts.append(f"Output: {output_text}")
prompt_parts.append("")
# 添加查询
prompt_parts.append(f"Input: {query}")
prompt_parts.append("Output:")
return "\n".join(prompt_parts)
def generate(self, prompt, max_length=50, temperature=0.7,
top_p=0.9):
"""
生成回答
Args:
prompt: 提示文本
max_length: 最大生成长度
temperature: 温度参数
top_p: Top-P采样参数
Returns:
generated_text: 生成的文本
"""
self.model.eval()
# 编码提示
input_ids = self.tokenizer.encode(prompt)
input_ids = torch.tensor([input_ids])
with torch.no_grad():
for _ in range(max_length):
# 前向传播
_, logits = self.model(input_ids)
# 获取最后一个位置的logits
next_token_logits = logits[0, -1, :] / temperature
# Top-P采样
sorted_logits, sorted_indices = torch.sort(
next_token_logits, descending=True
)
cumulative_probs = torch.cumsum(
F.softmax(sorted_logits, dim=-1), dim=-1
)
# 移除累积概率超过top_p的tokens
sorted_indices_to_remove = cumulative_probs > top_p
sorted_indices_to_remove[1:] = sorted_indices_to_remove[:-1].clone()
sorted_indices_to_remove[0] = 0
indices_to_remove = sorted_indices[sorted_indices_to_remove]
next_token_logits[indices_to_remove] = -float('Inf')
# 采样
probs = F.softmax(next_token_logits, dim=-1)
next_token = torch.multinomial(probs, num_samples=1)
# 添加到序列
input_ids = torch.cat([input_ids, next_token.unsqueeze(0)], dim=1)
# 检查结束符
if next_token.item() == self.tokenizer.eos_token_id:
break
# 解码
generated_text = self.tokenizer.decode(input_ids[0].tolist())
return generated_text
# 使用示例
print("Few-shot学习示例:")
print("\n情感分类任务:")
examples = [
("I love this movie!", "Positive"),
("This is terrible.", "Negative"),
("Amazing experience!", "Positive"),
]
query = "The food was delicious."
print(f"示例数量: {len(examples)}")
print(f"查询: {query}")
print("模型通过上下文学习完成分类，无需微调")
---
b.Zero-shot学习
Zero-shot学习不提供示例，只通过任务描述完成任务。GPT-3在许多任务上展示了zero-shot能力，如翻译、摘要、问答等。Zero-shot的性能通常不如few-shot，但更加通用和灵活。清晰的任务描述是zero-shot成功的关键。
c.思维链推理
思维链（Chain-of-Thought）提示引导模型逐步推理，而不是直接给出答案。在提示中展示推理过程，模型会模仿这种推理方式。思维链显著提升了GPT在复杂推理任务上的性能，如数学问题、逻辑推理等。这是大模型涌现能力的重要体现。
d.指令遵循
InstructGPT和ChatGPT通过RLHF训练，能够更好地遵循人类指令。模型理解各种形式的指令，如"解释"、"总结"、"翻译"等。指令遵循使得模型更易用，用户无需精心设计提示。这是大模型从研究工具到实用产品的关键转变。
04.GPT的应用与影响
a.文本生成
GPT在文本生成任务上表现出色，如故事创作、文章续写、对话生成等。生成的文本流畅连贯，具有创造性。但也存在事实错误、偏见、重复等问题。需要通过提示工程、后处理等方法改善生成质量。
b.代码生成
GPT在代码生成上展现了惊人的能力。Codex（GPT-3的代码版本）是GitHub Copilot的基础。模型能够根据自然语言描述生成代码，理解编程语言的语法和语义。代码生成大幅提升了开发效率，改变了编程方式。
c.多模态扩展
GPT-4等模型扩展到多模态，能够理解图像和文本。多模态GPT在图像描述、视觉问答等任务上表现出色。多模态是AI发展的重要方向，使得模型能够处理更丰富的信息。
d.社会影响
GPT等大语言模型对社会产生了深远影响。在教育、创作、客服等领域有广泛应用。但也带来了虚假信息、作弊、失业等担忧。如何负责任地开发和使用大模型是重要的社会议题。
5.4 模型微调技术
01.全参数微调
a.微调流程
a.基本步骤
全参数微调（Full Fine-tuning）更新预训练模型的所有参数以适应下游任务。首先加载预训练权重，然后在任务数据上训练。微调使用较小的学习率（如2e-5），避免破坏预训练的知识。微调通常只需要少量数据和几个epoch就能达到很好的效果。
b.微调实现
---
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
import torch.optim as optim
class FineTuningFramework:
"""微调框架"""
def __init__(self, model, num_labels, device='cuda'):
self.device = device
# 加载预训练模型
self.model = model.to(device)
# 添加任务头
self.task_head = nn.Linear(
model.config.hidden_size, num_labels
).to(device)
def fine_tune(self, train_loader, val_loader, num_epochs=3,
learning_rate=2e-5):
"""
微调模型
Args:
train_loader: 训练数据加载器
val_loader: 验证数据加载器
num_epochs: 训练轮数
learning_rate: 学习率
"""
# 优化器：不同层使用不同学习率
optimizer = optim.AdamW([
{'params': self.model.parameters(), 'lr': learning_rate},
{'params': self.task_head.parameters(), 'lr': learning_rate * 10}
], weight_decay=0.01)
# 学习率调度
total_steps = len(train_loader) * num_epochs
warmup_steps = int(0.1 * total_steps)
scheduler = self.get_linear_schedule_with_warmup(
optimizer, warmup_steps, total_steps
)
# 损失函数
criterion = nn.CrossEntropyLoss()
best_val_acc = 0
for epoch in range(num_epochs):
# 训练
self.model.train()
self.task_head.train()
train_loss = 0
for batch in train_loader:
input_ids = batch['input_ids'].to(self.device)
attention_mask = batch['attention_mask'].to(self.device)
labels = batch['labels'].to(self.device)
# 前向传播
outputs = self.model(input_ids, attention_mask=attention_mask)
pooled_output = outputs[1] # [CLS] token的表示
logits = self.task_head(pooled_output)
# 计算损失
loss = criterion(logits, labels)
# 反向传播
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(
list(self.model.parameters()) +
list(self.task_head.parameters()),
max_norm=1.0
)
optimizer.step()
scheduler.step()
train_loss += loss.item()
avg_train_loss = train_loss / len(train_loader)
# 验证
val_acc = self.evaluate(val_loader)
print(f"Epoch {epoch+1}/{num_epochs}")
print(f"Train Loss: {avg_train_loss:.4f}")
print(f"Val Accuracy: {val_acc:.4f}")
# 保存最佳模型
if val_acc > best_val_acc:
best_val_acc = val_acc
self.save_model('best_model.pt')
print("Saved best model")
print("-" * 50)
def evaluate(self, data_loader):
"""评估模型"""
self.model.eval()
self.task_head.eval()
correct = 0
total = 0
with torch.no_grad():
for batch in data_loader:
input_ids = batch['input_ids'].to(self.device)
attention_mask = batch['attention_mask'].to(self.device)
labels = batch['labels'].to(self.device)
outputs = self.model(input_ids, attention_mask=attention_mask)
pooled_output = outputs[1]
logits = self.task_head(pooled_output)
predictions = logits.argmax(dim=-1)
correct += (predictions == labels).sum().item()
total += labels.size(0)
return correct / total
def get_linear_schedule_with_warmup(self, optimizer,
warmup_steps, total_steps):
"""带warmup的线性学习率调度"""
def lr_lambda(current_step):
if current_step < warmup_steps:
return float(current_step) / float(max(1, warmup_steps))
return max(0.0, float(total_steps - current_step) /
float(max(1, total_steps - warmup_steps)))
return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
def save_model(self, path):
"""保存模型"""
torch.save({
'model_state_dict': self.model.state_dict(),
'task_head_state_dict': self.task_head.state_dict(),
}, path)
print("全参数微调流程:")
print("1. 加载预训练模型权重")
print("2. 添加任务特定的输出层")
print("3. 使用较小学习率训练所有参数")
print("4. 在验证集上评估，保存最佳模型")
print("5. 通常3-5个epoch即可收敛")
---
b.学习率策略
微调使用较小的学习率，通常是预训练学习率的1/10到1/100。不同层可以使用不同的学习率，底层使用更小的学习率，顶层使用较大的学习率。这种分层学习率策略能够更好地保留预训练知识，同时快速适应新任务。
c.数据需求
微调大幅降低了对标注数据的需求。在许多任务上，几百到几千个标注样本就能达到很好的效果。这使得NLP技术能够应用到更多领域，特别是标注数据稀缺的场景。但任务越复杂，需要的数据越多。
d.过拟合风险
在小数据集上微调容易过拟合。缓解方法包括：使用更小的学习率、更少的训练epoch、增加dropout、使用数据增强等。Early stopping是防止过拟合的有效策略，在验证集性能不再提升时停止训练。
02.参数高效微调
a.LoRA方法
a.LoRA原理
LoRA（Low-Rank Adaptation）通过低秩矩阵分解减少可训练参数。冻结预训练权重，只训练低秩的增量矩阵。LoRA将权重更新分解为两个小矩阵的乘积，大幅减少参数量。LoRA在保持性能的同时，只需要训练原模型0.1%-1%的参数。
b.LoRA实现
---
import torch
import torch.nn as nn
class LoRALayer(nn.Module):
"""LoRA层：低秩适配"""
def __init__(self, in_features, out_features, rank=8, alpha=16):
super(LoRALayer, self).__init__()
self.rank = rank
self.alpha = alpha
# 原始权重（冻结）
self.weight = nn.Parameter(
torch.randn(out_features, in_features),
requires_grad=False
)
# LoRA矩阵A和B
self.lora_A = nn.Parameter(torch.randn(rank, in_features))
self.lora_B = nn.Parameter(torch.zeros(out_features, rank))
# 缩放因子
self.scaling = alpha / rank
def forward(self, x):
"""
Args:
x: [batch_size, seq_len, in_features]
Returns:
output: [batch_size, seq_len, out_features]
"""
# 原始线性变换
result = F.linear(x, self.weight)
# LoRA增量：x @ A^T @ B^T
lora_result = F.linear(F.linear(x, self.lora_A), self.lora_B)
# 组合结果
return result + lora_result * self.scaling
class LoRAAttention(nn.Module):
"""带LoRA的注意力层"""
def __init__(self, d_model, num_heads, lora_rank=8):
super(LoRAAttention, self).__init__()
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
# 使用LoRA层替代标准线性层
self.q_proj = LoRALayer(d_model, d_model, rank=lora_rank)
self.k_proj = LoRALayer(d_model, d_model, rank=lora_rank)
self.v_proj = LoRALayer(d_model, d_model, rank=lora_rank)
self.o_proj = LoRALayer(d_model, d_model, rank=lora_rank)
def forward(self, x, mask=None):
batch_size, seq_len, _ = x.size()
# 计算Q, K, V
Q = self.q_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
K = self.k_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
V = self.v_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
# 转置
Q = Q.transpose(1, 2)
K = K.transpose(1, 2)
V = V.transpose(1, 2)
# 注意力计算
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attn_weights = F.softmax(scores, dim=-1)
context = torch.matmul(attn_weights, V)
# 合并头
context = context.transpose(1, 2).contiguous()
context = context.view(batch_size, seq_len, self.d_model)
# 输出投影
output = self.o_proj(context)
return output
# 参数量对比
d_model = 768
lora_rank = 8
# 标准线性层参数量
standard_params = d_model * d_model
# LoRA参数量
lora_params = lora_rank * d_model + d_model * lora_rank
print(f"标准线性层参数量: {standard_params:,}")
print(f"LoRA参数量: {lora_params:,}")
print(f"参数减少: {(1 - lora_params/standard_params)*100:.2f}%")
print(f"\n对于12层Transformer，LoRA只需训练约0.5%的参数")
---
b.Adapter方法
Adapter在Transformer层之间插入小的瓶颈模块，只训练这些模块。Adapter通常包含下投影、非线性激活和上投影。Adapter的参数量很小（通常几百万），但能够有效适应新任务。Adapter的优势是模块化，可以为不同任务训练不同的adapter。
c.Prefix Tuning
Prefix Tuning在输入序列前添加可训练的前缀向量，冻结模型参数。前缀向量通过训练学习任务特定的信息，引导模型行为。Prefix Tuning的参数量极小，但在某些任务上性能接近全参数微调。这种方法特别适合生成任务。
d.Prompt Tuning
Prompt Tuning将离散的提示词替换为连续的可训练向量。这些软提示（soft prompts）通过训练优化，无需手工设计提示。Prompt Tuning在大模型上效果很好，参数量极少。但在小模型上性能不如全参数微调。
03.多任务学习
a.任务设计
a.多任务框架
多任务学习同时在多个任务上训练模型，共享底层表示。不同任务可以相互促进，提升泛化能力。多任务学习需要平衡不同任务的损失，避免某个任务主导训练。任务相关性越高，多任务学习的效果越好。
b.多任务实现
---
import torch
import torch.nn as nn
class MultiTaskModel(nn.Module):
"""多任务学习模型"""
def __init__(self, base_model, task_configs):
super(MultiTaskModel, self).__init__()
# 共享的基础模型
self.base_model = base_model
# 任务特定的头
self.task_heads = nn.ModuleDict()
for task_name, config in task_configs.items():
self.task_heads[task_name] = nn.Linear(
base_model.config.hidden_size,
config['num_labels']
)
# 任务权重（可学习）
self.task_weights = nn.Parameter(
torch.ones(len(task_configs))
)
def forward(self, input_ids, attention_mask, task_name, labels=None):
"""
Args:
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
task_name: 任务名称
labels: [batch_size]
Returns:
loss: 任务损失
logits: 预测logits
"""
# 共享编码
outputs = self.base_model(input_ids, attention_mask=attention_mask)
pooled_output = outputs[1]
# 任务特定的预测
logits = self.task_heads[task_name](pooled_output)
# 计算损失
loss = None
if labels is not None:
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(logits, labels)
return loss, logits
def train_multitask(model, task_loaders, num_epochs, device='cuda'):
"""
多任务训练
Args:
model: 多任务模型
task_loaders: 字典，{task_name: data_loader}
num_epochs: 训练轮数
device: 设备
"""
model = model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)
for epoch in range(num_epochs):
model.train()
# 创建任务迭代器
task_iters = {name: iter(loader)
for name, loader in task_loaders.items()}
# 计算总步数（最长任务的长度）
max_steps = max(len(loader) for loader in task_loaders.values())
for step in range(max_steps):
total_loss = 0
# 对每个任务采样一个batch
for task_idx, (task_name, task_iter) in enumerate(task_iters.items()):
try:
batch = next(task_iter)
except StopIteration:
# 重新开始迭代
task_iters[task_name] = iter(task_loaders[task_name])
batch = next(task_iters[task_name])
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['labels'].to(device)
# 前向传播
loss, _ = model(input_ids, attention_mask,
task_name, labels)
# 加权损失
weighted_loss = loss * model.task_weights[task_idx]
total_loss += weighted_loss
# 反向传播
optimizer.zero_grad()
total_loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
if (step + 1) % 100 == 0:
print(f"Epoch {epoch+1}, Step {step+1}, "
f"Loss: {total_loss.item():.4f}")
print("多任务学习策略:")
print("1. 共享底层Transformer编码器")
print("2. 每个任务有独立的输出头")
print("3. 交替或同时训练多个任务")
print("4. 使用任务权重平衡不同任务的贡献")
---
b.任务采样
多任务训练需要合理的任务采样策略。均匀采样给每个任务相同的权重，但可能不公平。按数据量采样使得大任务主导训练。温度采样通过温度参数调整采样概率。动态采样根据任务性能调整采样权重。
c.负迁移问题
某些任务组合可能导致负迁移，即多任务性能不如单任务。负迁移通常发生在任务差异很大或冲突时。解决方法包括：任务分组、梯度手术（修改冲突的梯度）、任务特定的层等。任务选择是多任务学习的关键。
d.T5统一框架
T5（Text-to-Text Transfer Transformer）将所有NLP任务统一为文本到文本的格式。分类、翻译、摘要等任务都转换为生成任务。这种统一框架简化了模型设计，使得多任务学习更加自然。T5在多个基准上取得了最佳性能。
04.领域适应技术
a.持续预训练
在特定领域数据上继续预训练通用模型，使其适应领域特点。持续预训练使用与原始预训练相同的任务（如MLM），但在领域数据上进行。这种方法在医疗、法律、科学等专业领域效果显著。持续预训练是领域适应的第一步。
b.任务自适应预训练
TAPT（Task-Adaptive Pre-Training）在任务数据上进行预训练，即使数据量很小。TAPT使用任务的无标注数据，通过MLM等自监督任务训练。TAPT能够进一步提升微调性能，特别是在小数据场景下。TAPT是预训练和微调之间的桥梁。
c.数据增强
数据增强通过生成额外的训练样本提升模型性能。常见方法包括：回译（翻译到其他语言再翻译回来）、同义词替换、句子重组等。对于小数据集，数据增强能够显著提升性能。但增强数据的质量很重要，低质量增强可能有害。
d.主动学习
主动学习选择最有信息量的样本进行标注，最大化标注效率。模型选择不确定性高或代表性强的样本，人工标注后加入训练集。主动学习在标注预算有限时特别有用，能够用更少的标注达到更好的性能。
5.5 提示学习
01.提示工程基础
a.提示设计原则
a.核心概念
提示工程（Prompt Engineering）是设计有效提示以引导大语言模型完成任务的技术。好的提示能够显著提升模型性能，无需修改模型参数。提示设计需要考虑任务类型、模型特点、输入输出格式等因素。提示工程是使用大语言模型的关键技能。
b.提示模板实现
---
import torch
from typing import List, Dict, Any
class PromptTemplate:
"""提示模板类"""
def __init__(self, template: str, input_variables: List[str]):
"""
Args:
template: 提示模板字符串，使用{variable}标记变量
input_variables: 输入变量列表
"""
self.template = template
self.input_variables = input_variables
def format(self, **kwargs) -> str:
"""
格式化提示
Args:
**kwargs: 变量值
Returns:
formatted_prompt: 格式化后的提示
"""
# 检查所有必需变量是否提供
for var in self.input_variables:
if var not in kwargs:
raise ValueError(f"Missing required variable: {var}")
return self.template.format(**kwargs)
class PromptLibrary:
"""提示库：常见任务的提示模板"""
@staticmethod
def classification(text: str, labels: List[str],
task_description: str = "") -> str:
"""
分类任务提示
Args:
text: 待分类文本
labels: 候选标签列表
task_description: 任务描述
Returns:
prompt: 完整提示
"""
labels_str = ", ".join(labels)
prompt = f"""Task: {task_description if task_description else 'Classify the following text'}
Text: {text}
Choose one label from: {labels_str}
Label:"""
return prompt
@staticmethod
def few_shot_classification(examples: List[Dict[str, str]],
query: str, labels: List[str]) -> str:
"""
Few-shot分类提示
Args:
examples: 示例列表 [{"text": ..., "label": ...}, ...]
query: 查询文本
labels: 候选标签
Returns:
prompt: Few-shot提示
"""
prompt_parts = ["Classify the text into one of the following categories:\n"]
prompt_parts.append(f"Categories: {', '.join(labels)}\n\n")
# 添加示例
for i, example in enumerate(examples, 1):
prompt_parts.append(f"Example {i}:")
prompt_parts.append(f"Text: {example['text']}")
prompt_parts.append(f"Label: {example['label']}\n")
# 添加查询
prompt_parts.append("Now classify this text:")
prompt_parts.append(f"Text: {query}")
prompt_parts.append("Label:")
return "\n".join(prompt_parts)
@staticmethod
def question_answering(context: str, question: str) -> str:
"""
问答任务提示
Args:
context: 上下文
question: 问题
Returns:
prompt: 问答提示
"""
prompt = f"""Answer the question based on the context below.
Context: {context}
Question: {question}
Answer:"""
return prompt
@staticmethod
def summarization(text: str, max_length: int = None) -> str:
"""
摘要任务提示
Args:
text: 待摘要文本
max_length: 最大摘要长度
Returns:
prompt: 摘要提示
"""
length_constraint = f" in no more than {max_length} words" if max_length else ""
prompt = f"""Summarize the following text{length_constraint}:
Text: {text}
Summary:"""
return prompt
@staticmethod
def translation(text: str, source_lang: str, target_lang: str) -> str:
"""
翻译任务提示
Args:
text: 待翻译文本
source_lang: 源语言
target_lang: 目标语言
Returns:
prompt: 翻译提示
"""
prompt = f"""Translate the following text from {source_lang} to {target_lang}:
{source_lang}: {text}
{target_lang}:"""
return prompt
# 使用示例
print("=== 提示模板示例 ===\n")
# 1. 分类任务
text = "This movie is absolutely amazing! I loved every minute of it."
labels = ["Positive", "Negative", "Neutral"]
classification_prompt = PromptLibrary.classification(
text, labels, "Sentiment Analysis"
)
print("1. 分类提示:")
print(classification_prompt)
print("\n" + "="*50 + "\n")
# 2. Few-shot分类
examples = [
{"text": "Great product!", "label": "Positive"},
{"text": "Terrible experience.", "label": "Negative"},
{"text": "It's okay.", "label": "Neutral"}
]
query = "Best purchase ever!"
few_shot_prompt = PromptLibrary.few_shot_classification(
examples, query, labels
)
print("2. Few-shot分类提示:")
print(few_shot_prompt)
print("\n" + "="*50 + "\n")
# 3. 问答任务
context = "The Eiffel Tower is located in Paris, France. It was completed in 1889."
question = "Where is the Eiffel Tower?"
qa_prompt = PromptLibrary.question_answering(context, question)
print("3. 问答提示:")
print(qa_prompt)
---
b.零样本提示
零样本提示只包含任务描述，不提供示例。清晰的任务描述和输出格式说明是关键。零样本提示简单直接，但性能通常不如few-shot。适合模型已经熟悉的常见任务，如翻译、摘要等。
c.少样本提示
少样本提示包含几个示例，展示输入输出的格式和模式。示例的选择很重要，应该具有代表性和多样性。通常3-5个示例效果较好，更多示例可能超出上下文长度限制。少样本提示在大多数任务上优于零样本。
d.思维链提示
思维链提示引导模型逐步推理，展示中间步骤。在提示中包含推理过程，模型会模仿这种方式。思维链显著提升复杂推理任务的性能，如数学问题、逻辑推理等。"Let's think step by step"是简单有效的思维链触发词。
02.提示优化技术
a.自动提示搜索
a.搜索策略
手工设计提示耗时且效果不稳定。自动提示搜索通过算法寻找最优提示。常见方法包括：梯度引导搜索、强化学习、进化算法等。自动搜索能够发现人类难以想到的有效提示，但计算开销较大。
b.提示优化实现
---
import torch
import torch.nn as nn
import numpy as np
from typing import List, Tuple
class PromptOptimizer:
"""提示优化器"""
def __init__(self, model, tokenizer, eval_fn):
"""
Args:
model: 语言模型
tokenizer: 分词器
eval_fn: 评估函数，返回性能分数
"""
self.model = model
self.tokenizer = tokenizer
self.eval_fn = eval_fn
def discrete_search(self, initial_prompts: List[str],
num_iterations: int = 10,
num_candidates: int = 5) -> str:
"""
离散提示搜索
Args:
initial_prompts: 初始提示列表
num_iterations: 迭代次数
num_candidates: 每次保留的候选数
Returns:
best_prompt: 最优提示
"""
current_prompts = initial_prompts
best_score = -float('inf')
best_prompt = None
for iteration in range(num_iterations):
# 评估当前提示
scores = []
for prompt in current_prompts:
score = self.eval_fn(prompt)
scores.append(score)
if score > best_score:
best_score = score
best_prompt = prompt
print(f"Iteration {iteration+1}, Best Score: {best_score:.4f}")
# 选择top-k提示
top_indices = np.argsort(scores)[-num_candidates:]
top_prompts = [current_prompts[i] for i in top_indices]
# 生成新候选（变异）
new_prompts = []
for prompt in top_prompts:
# 简单变异：替换词、添加词、删除词
variants = self.generate_variants(prompt)
new_prompts.extend(variants)
current_prompts = new_prompts[:num_candidates * 2]
return best_prompt
def generate_variants(self, prompt: str) -> List[str]:
"""
生成提示变体
Args:
prompt: 原始提示
Returns:
variants: 变体列表
"""
variants = []
words = prompt.split()
# 变体1: 替换同义词
synonyms = {
"classify": ["categorize", "label", "identify"],
"text": ["passage", "content", "input"],
"answer": ["respond", "reply", "provide"],
}
for i, word in enumerate(words):
if word.lower() in synonyms:
for syn in synonyms[word.lower()]:
new_words = words.copy()
new_words[i] = syn
variants.append(" ".join(new_words))
# 变体2: 添加描述词
descriptors = ["carefully", "accurately", "precisely"]
for desc in descriptors:
variants.append(f"{desc} {prompt}")
# 变体3: 改变格式
variants.append(prompt + "\n\nThink step by step.")
variants.append(f"Task: {prompt}")
return variants[:5] # 限制变体数量
class ContinuousPromptOptimizer:
"""连续提示优化（软提示）"""
def __init__(self, model, prompt_length: int = 10):
"""
Args:
model: 语言模型
prompt_length: 软提示长度
"""
self.model = model
self.prompt_length = prompt_length
# 可学习的软提示嵌入
self.soft_prompt = nn.Parameter(
torch.randn(prompt_length, model.config.hidden_size)
)
def forward(self, input_ids, attention_mask):
"""
前向传播，添加软提示
Args:
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
Returns:
outputs: 模型输出
"""
batch_size = input_ids.size(0)
# 获取输入嵌入
input_embeds = self.model.get_input_embeddings()(input_ids)
# 扩展软提示
soft_prompt_batch = self.soft_prompt.unsqueeze(0).expand(
batch_size, -1, -1
)
# 拼接软提示和输入嵌入
inputs_embeds = torch.cat([soft_prompt_batch, input_embeds], dim=1)
# 扩展attention mask
prefix_attention_mask = torch.ones(
batch_size, self.prompt_length,
device=attention_mask.device
)
attention_mask = torch.cat([prefix_attention_mask, attention_mask], dim=1)
# 前向传播
outputs = self.model(
inputs_embeds=inputs_embeds,
attention_mask=attention_mask
)
return outputs
def train_soft_prompt(self, train_loader, num_epochs: int = 5):
"""
训练软提示
Args:
train_loader: 训练数据
num_epochs: 训练轮数
"""
optimizer = torch.optim.AdamW([self.soft_prompt], lr=1e-3)
for epoch in range(num_epochs):
total_loss = 0
for batch in train_loader:
input_ids = batch['input_ids']
attention_mask = batch['attention_mask']
labels = batch['labels']
# 前向传播
outputs = self.forward(input_ids, attention_mask)
# 计算损失
loss = nn.functional.cross_entropy(
outputs.logits.view(-1, outputs.logits.size(-1)),
labels.view(-1)
)
# 反向传播（只更新软提示）
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
avg_loss = total_loss / len(train_loader)
print(f"Epoch {epoch+1}, Loss: {avg_loss:.4f}")
print("提示优化方法:")
print("1. 离散搜索：在提示空间中搜索最优文本提示")
print("2. 连续优化：学习软提示嵌入向量")
print("3. 梯度引导：使用梯度信息指导搜索方向")
print("4. 强化学习：将提示设计建模为RL问题")
---
b.提示集成
使用多个不同的提示，集成它们的输出。不同提示可能捕捉任务的不同方面，集成能够提升鲁棒性。集成方法包括投票、平均概率、加权组合等。提示集成在关键应用中很有价值，但增加了计算开销。
c.提示压缩
长提示消耗大量tokens，增加成本和延迟。提示压缩通过移除冗余信息、使用更简洁的表达来缩短提示。压缩需要在长度和性能之间权衡。自动压缩方法能够保留关键信息，同时大幅减少长度。
d.提示调试
提示设计是迭代过程，需要调试和改进。常见问题包括：模型不理解指令、输出格式错误、性能不稳定等。调试方法包括：分析失败案例、逐步简化提示、测试不同表述等。系统的调试流程能够快速找到有效提示。
03.指令微调
a.指令数据集
a.数据构建
指令微调使用指令-输出对训练模型遵循指令。指令数据集包含多样化的任务和指令形式。高质量的指令数据是关键，需要覆盖各种任务类型、指令风格和难度级别。指令微调使得模型更易用，用户无需精心设计提示。
b.指令微调实现
---
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
class InstructionDataset(Dataset):
"""指令微调数据集"""
def __init__(self, instructions, outputs, tokenizer, max_length=512):
"""
Args:
instructions: 指令列表
outputs: 对应的输出列表
tokenizer: 分词器
max_length: 最大长度
"""
self.instructions = instructions
self.outputs = outputs
self.tokenizer = tokenizer
self.max_length = max_length
def __len__(self):
return len(self.instructions)
def __getitem__(self, idx):
instruction = self.instructions[idx]
output = self.outputs[idx]
# 组合指令和输出
text = f"Instruction: {instruction}\n\nResponse: {output}"
# 分词
encoding = self.tokenizer(
text,
max_length=self.max_length,
padding='max_length',
truncation=True,
return_tensors='pt'
)
return {
'input_ids': encoding['input_ids'].squeeze(),
'attention_mask': encoding['attention_mask'].squeeze(),
'labels': encoding['input_ids'].squeeze()
}
def instruction_tuning(model, train_dataset, num_epochs=3,
batch_size=8, learning_rate=2e-5):
"""
指令微调
Args:
model: 预训练模型
train_dataset: 指令数据集
num_epochs: 训练轮数
batch_size: 批大小
learning_rate: 学习率
"""
train_loader = DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=True
)
optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
model.train()
for epoch in range(num_epochs):
total_loss = 0
for batch in train_loader:
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['labels'].to(device)
# 前向传播
outputs = model(
input_ids=input_ids,
attention_mask=attention_mask,
labels=labels
)
loss = outputs.loss
# 反向传播
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
total_loss += loss.item()
avg_loss = total_loss / len(train_loader)
print(f"Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}")
return model
# 指令数据示例
instruction_examples = [
{
"instruction": "Translate the following English text to French: 'Hello, how are you?'",
"output": "Bonjour, comment allez-vous?"
},
{
"instruction": "Summarize the main points of the following text in one sentence.",
"output": "[Summary based on input text]"
},
{
"instruction": "Write a Python function to calculate the factorial of a number.",
"output": "def factorial(n):\n if n == 0:\n return 1\n return n * factorial(n-1)"
},
{
"instruction": "Classify the sentiment of this review: 'This product exceeded my expectations!'",
"output": "Positive"
}
]
print("指令微调数据格式:")
for i, example in enumerate(instruction_examples[:2], 1):
print(f"\n示例 {i}:")
print(f"指令: {example['instruction']}")
print(f"输出: {example['output']}")
---
b.多样性设计
指令数据集需要高度多样化，覆盖各种任务类型、领域和难度。多样性包括：任务多样性（分类、生成、推理等）、指令表述多样性（不同的问法）、输出格式多样性等。Self-Instruct等方法使用模型自动生成多样化的指令数据。
c.质量控制
指令数据的质量至关重要。低质量数据会损害模型性能。质量控制包括：人工审核、自动过滤、一致性检查等。RLHF通过人类反馈进一步提升质量。高质量的指令数据是InstructGPT、ChatGPT成功的关键。
d.对齐目标
指令微调的目标不仅是完成任务，还要对齐人类价值观。模型应该有帮助（helpful）、诚实（honest）、无害（harmless）。对齐需要在指令数据中体现，如拒绝有害请求、承认不确定性等。对齐是负责任AI的核心。
04.提示学习的应用
a.任务适配
提示学习使得预训练模型能够快速适配新任务，无需大量标注数据。通过精心设计的提示，模型可以完成训练时未见过的任务。这种灵活性使得大模型成为通用的AI助手，而不是特定任务的工具。
b.低资源场景
在标注数据稀缺的场景下，提示学习特别有价值。Few-shot提示只需要几个示例，甚至zero-shot也能工作。这使得NLP技术能够应用到更多领域，特别是小语种、专业领域等。提示学习降低了NLP应用的门槛。
c.可解释性
提示学习提供了一定的可解释性。提示明确说明了任务和期望输出，用户可以理解模型在做什么。思维链提示展示了推理过程，进一步提升了透明度。相比黑盒微调，提示学习更容易调试和改进。
d.持续学习
提示学习支持持续学习，模型可以通过新提示学习新任务，而不会忘记旧任务。不同任务使用不同提示，避免了灾难性遗忘。这种模块化的学习方式更符合人类的学习模式，是通向AGI的重要方向。
6 大语言模型与应用
6.1 大语言模型基础
01.规模定律与涌现能力
a.规模定律
a.基本原理
规模定律（Scaling Laws）描述了模型性能与模型大小、数据量、计算量之间的关系。性能随着规模呈幂律增长，遵循可预测的曲线。增大模型参数、训练数据或计算量都能提升性能。规模定律为大模型的发展提供了理论指导，使得我们可以预测更大模型的性能。
b.规模分析实现
---
import numpy as np
import matplotlib.pyplot as plt
from typing import Dict, List
class ScalingLawAnalyzer:
"""规模定律分析器"""
def __init__(self):
self.history = {
'params': [],
'loss': [],
'compute': []
}
def compute_loss(self, N: float, D: float, C: float) -> float:
"""
根据规模定律计算损失
Args:
N: 模型参数量（单位：十亿）
D: 数据量（单位：十亿tokens）
C: 计算量（单位：PetaFLOPs）
Returns:
loss: 预测的损失值
"""
# Chinchilla规模定律：L(N, D) = A/N^α + B/D^β + E
A, alpha = 406.4, 0.34
B, beta = 410.7, 0.28
E = 1.69
loss = A / (N ** alpha) + B / (D ** beta) + E
return loss
def optimal_allocation(self, compute_budget: float) -> Dict[str, float]:
"""
给定计算预算，计算最优的模型大小和数据量
Args:
compute_budget: 计算预算（PetaFLOPs）
Returns:
allocation: {'params': N, 'data': D, 'loss': L}
"""
# Chinchilla最优分配：N和D应该以相同速率增长
# 简化公式：N ∝ C^0.5, D ∝ C^0.5
# 假设每个token需要6N FLOPs
# C = 6 * N * D
# 最优分配：N = D（参数量和数据量相等）
optimal_N = np.sqrt(compute_budget / 6)
optimal_D = optimal_N
loss = self.compute_loss(optimal_N, optimal_D, compute_budget)
return {
'params': optimal_N,
'data': optimal_D,
'loss': loss,
'compute': compute_budget
}
def compare_strategies(self, compute_budget: float):
"""
比较不同的资源分配策略
Args:
compute_budget: 计算预算
"""
strategies = {
'Optimal (Chinchilla)': self.optimal_allocation(compute_budget),
'Large Model, Less Data': {
'params': compute_budget / 3,
'data': compute_budget / 18,
'compute': compute_budget
},
'Small Model, More Data': {
'params': compute_budget / 18,
'data': compute_budget / 3,
'compute': compute_budget
}
}
print(f"计算预算: {compute_budget:.2f} PetaFLOPs\n")
print("=" * 70)
for name, config in strategies.items():
if 'loss' not in config:
config['loss'] = self.compute_loss(
config['params'], config['data'], config['compute']
)
print(f"\n策略: {name}")
print(f" 模型参数: {config['params']:.2f}B")
print(f" 训练数据: {config['data']:.2f}B tokens")
print(f" 预测损失: {config['loss']:.4f}")
print("\n" + "=" * 70)
def plot_scaling_curves(self):
"""绘制规模定律曲线"""
# 参数量范围：0.1B到100B
params = np.logspace(-1, 2, 50)
# 不同数据量下的损失曲线
data_sizes = [10, 100, 1000] # 十亿tokens
plt.figure(figsize=(12, 5))
# 子图1：参数量vs损失
plt.subplot(1, 2, 1)
for D in data_sizes:
losses = [self.compute_loss(N, D, 0) for N in params]
plt.plot(params, losses, label=f'Data: {D}B tokens')
plt.xscale('log')
plt.xlabel('Model Parameters (Billions)')
plt.ylabel('Loss')
plt.title('Scaling Law: Parameters vs Loss')
plt.legend()
plt.grid(True, alpha=0.3)
# 子图2：计算预算vs最优配置
plt.subplot(1, 2, 2)
compute_budgets = np.logspace(0, 3, 50)
optimal_params = []
optimal_data = []
for C in compute_budgets:
config = self.optimal_allocation(C)
optimal_params.append(config['params'])
optimal_data.append(config['data'])
plt.plot(compute_budgets, optimal_params, label='Optimal Params')
plt.plot(compute_budgets, optimal_data, label='Optimal Data', linestyle='--')
plt.xscale('log')
plt.yscale('log')
plt.xlabel('Compute Budget (PetaFLOPs)')
plt.ylabel('Size (Billions)')
plt.title('Optimal Resource Allocation')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
return plt
# 使用示例
analyzer = ScalingLawAnalyzer()
# 比较不同策略
analyzer.compare_strategies(compute_budget=100.0)
print("\n关键发现:")
print("1. Chinchilla规模定律：模型参数和训练数据应该同步增长")
print("2. GPT-3等早期大模型训练不足（数据量相对参数量太少）")
print("3. 给定计算预算，应该训练更小但数据更多的模型")
---
b.涌现能力
当模型规模达到一定阈值，会出现训练时未明确优化的能力。常见的涌现能力包括：上下文学习（in-context learning）、思维链推理（chain-of-thought）、指令遵循等。这些能力在小模型中几乎不存在，在大模型中突然出现。涌现能力的机制仍在研究中，可能与模型容量、训练数据多样性等因素相关。
c.计算最优训练
Chinchilla研究发现，给定计算预算，应该同时增大模型和数据，而不是只增大模型。GPT-3等早期大模型训练不足，使用更多数据可以用更小的模型达到相同性能。计算最优训练指导了后续模型的设计，如Chinchilla、LLaMA等都遵循这一原则。
d.性能预测
规模定律使得我们可以预测更大模型的性能，指导资源分配。但规模定律主要适用于预训练损失，下游任务性能的预测更复杂。此外，规模定律在极大规模下可能失效，需要新的理论框架。
02.大模型架构设计
a.架构选择
a.编码器vs解码器
大语言模型主要使用仅解码器架构（如GPT），因为它更适合生成任务。编码器架构（如BERT）适合理解任务，但生成能力有限。编码器-解码器架构（如T5）兼顾两者，但参数效率较低。实践中，仅解码器架构成为主流，通过提示和微调也能完成理解任务。
b.架构实现对比
---
import torch
import torch.nn as nn
class DecoderOnlyLM(nn.Module):
"""仅解码器语言模型（GPT风格）"""
def __init__(self, vocab_size, d_model=2048, num_layers=24,
num_heads=16, d_ff=8192, max_len=2048):
super(DecoderOnlyLM, self).__init__()
self.embedding = nn.Embedding(vocab_size, d_model)
self.pos_embedding = nn.Embedding(max_len, d_model)
self.layers = nn.ModuleList([
DecoderLayer(d_model, num_heads, d_ff)
for _ in range(num_layers)
])
self.ln_f = nn.LayerNorm(d_model)
self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
# 权重共享
self.lm_head.weight = self.embedding.weight
def forward(self, input_ids):
batch_size, seq_len = input_ids.size()
# 嵌入
x = self.embedding(input_ids)
positions = torch.arange(seq_len, device=input_ids.device)
x = x + self.pos_embedding(positions)
# 因果掩码
mask = torch.tril(torch.ones(seq_len, seq_len, device=input_ids.device))
mask = mask.view(1, 1, seq_len, seq_len)
# 通过所有层
for layer in self.layers:
x = layer(x, mask)
x = self.ln_f(x)
logits = self.lm_head(x)
return logits
class EncoderDecoderLM(nn.Module):
"""编码器-解码器语言模型（T5风格）"""
def __init__(self, vocab_size, d_model=1024, num_layers=12,
num_heads=16, d_ff=4096):
super(EncoderDecoderLM, self).__init__()
# 共享嵌入
self.embedding = nn.Embedding(vocab_size, d_model)
# 编码器
self.encoder_layers = nn.ModuleList([
EncoderLayer(d_model, num_heads, d_ff)
for _ in range(num_layers)
])
# 解码器
self.decoder_layers = nn.ModuleList([
DecoderLayer(d_model, num_heads, d_ff, cross_attention=True)
for _ in range(num_layers)
])
self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
self.lm_head.weight = self.embedding.weight
def forward(self, input_ids, decoder_input_ids):
# 编码
encoder_output = self.embedding(input_ids)
for layer in self.encoder_layers:
encoder_output = layer(encoder_output)
# 解码
decoder_output = self.embedding(decoder_input_ids)
seq_len = decoder_input_ids.size(1)
causal_mask = torch.tril(torch.ones(seq_len, seq_len))
for layer in self.decoder_layers:
decoder_output = layer(decoder_output, encoder_output, causal_mask)
logits = self.lm_head(decoder_output)
return logits
# 参数量对比
vocab_size = 50000
# 仅解码器：GPT-3规模
decoder_only = DecoderOnlyLM(vocab_size, d_model=12288, num_layers=96)
decoder_params = sum(p.numel() for p in decoder_only.parameters())
# 编码器-解码器：T5规模
encoder_decoder = EncoderDecoderLM(vocab_size, d_model=1024, num_layers=24)
enc_dec_params = sum(p.numel() for p in encoder_decoder.parameters())
print("架构对比:")
print(f"仅解码器（GPT-3 175B规模）: ~175B参数")
print(f"编码器-解码器（T5-XXL规模）: ~11B参数")
print("\n优势对比:")
print("仅解码器:")
print(" + 生成能力强")
print(" + 架构简单，易于扩展")
print(" + 统一的训练目标")
print(" - 理解任务需要提示工程")
print("\n编码器-解码器:")
print(" + 理解和生成都擅长")
print(" + 适合seq2seq任务")
print(" - 参数效率较低")
print(" - 训练和推理更复杂")
---
b.注意力机制优化
标准注意力的O(n²)复杂度限制了上下文长度。优化方法包括：Flash Attention（优化内存访问）、Multi-Query Attention（减少KV缓存）、Grouped-Query Attention（MQA和MHA的折中）、Sliding Window Attention（局部注意力）等。这些优化使得处理更长上下文成为可能。
c.位置编码改进
标准的正弦位置编码或可学习位置编码在长序列上外推能力有限。改进方法包括：RoPE（旋转位置编码）、ALiBi（注意力偏置）、xPos（外推位置编码）等。RoPE成为主流选择，在LLaMA、GPT-NeoX等模型中广泛使用。
d.归一化技术
Layer Normalization是标准选择，但也有其他变体。RMSNorm（Root Mean Square Normalization）计算更简单，性能相当。Pre-LN（归一化在注意力前）比Post-LN更稳定，是深层模型的标准选择。归一化的位置和类型对训练稳定性有重要影响。
03.训练基础设施
a.分布式训练
a.并行策略
大模型训练需要多种并行策略。数据并行（Data Parallelism）将数据分配到不同GPU，适合小模型。模型并行（Model Parallelism）将模型分割到不同GPU，适合大模型。流水线并行（Pipeline Parallelism）将模型分成多个阶段，减少GPU空闲。张量并行（Tensor Parallelism）在层内分割，需要高速互联。
b.分布式训练实现
---
import torch
import torch.nn as nn
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data.distributed import DistributedSampler
class DistributedTrainer:
"""分布式训练框架"""
def __init__(self, model, rank, world_size):
"""
Args:
model: 模型
rank: 当前进程的rank
world_size: 总进程数
"""
self.rank = rank
self.world_size = world_size
self.device = torch.device(f'cuda:{rank}')
# 将模型移到对应GPU
self.model = model.to(self.device)
# 包装为DDP
self.model = DDP(self.model, device_ids=[rank])
def setup(self, backend='nccl'):
"""
初始化分布式环境
Args:
backend: 通信后端（nccl用于GPU，gloo用于CPU）
"""
dist.init_process_group(
backend=backend,
init_method='env://',
world_size=self.world_size,
rank=self.rank
)
def cleanup(self):
"""清理分布式环境"""
dist.destroy_process_group()
def train_epoch(self, train_loader, optimizer, criterion):
"""
训练一个epoch
Args:
train_loader: 数据加载器（使用DistributedSampler）
optimizer: 优化器
criterion: 损失函数
Returns:
avg_loss: 平均损失
"""
self.model.train()
total_loss = 0
for batch_idx, (data, target) in enumerate(train_loader):
data = data.to(self.device)
target = target.to(self.device)
# 前向传播
output = self.model(data)
loss = criterion(output, target)
# 反向传播
optimizer.zero_grad()
loss.backward()
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
optimizer.step()
total_loss += loss.item()
if batch_idx % 100 == 0 and self.rank == 0:
print(f"Rank {self.rank}, Batch {batch_idx}, Loss: {loss.item():.4f}")
# 聚合所有进程的损失
avg_loss = total_loss / len(train_loader)
avg_loss_tensor = torch.tensor([avg_loss], device=self.device)
dist.all_reduce(avg_loss_tensor, op=dist.ReduceOp.SUM)
avg_loss = avg_loss_tensor.item() / self.world_size
return avg_loss
def save_checkpoint(self, epoch, path):
"""保存检查点（只在rank 0保存）"""
if self.rank == 0:
checkpoint = {
'epoch': epoch,
'model_state_dict': self.model.module.state_dict(),
}
torch.save(checkpoint, path)
# 混合精度训练
class MixedPrecisionTrainer:
"""混合精度训练"""
def __init__(self, model, device='cuda'):
self.model = model.to(device)
self.device = device
# 创建GradScaler用于自动缩放
self.scaler = torch.cuda.amp.GradScaler()
def train_step(self, data, target, optimizer, criterion):
"""
混合精度训练步骤
Args:
data: 输入数据
target: 目标标签
optimizer: 优化器
criterion: 损失函数
Returns:
loss: 损失值
"""
data = data.to(self.device)
target = target.to(self.device)
# 使用autocast自动混合精度
with torch.cuda.amp.autocast():
output = self.model(data)
loss = criterion(output, target)
# 反向传播（使用scaler）
optimizer.zero_grad()
self.scaler.scale(loss).backward()
# 梯度裁剪（需要unscale）
self.scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
# 更新参数
self.scaler.step(optimizer)
self.scaler.update()
return loss.item()
print("分布式训练策略:")
print("1. 数据并行（DDP）：最常用，适合大多数场景")
print("2. 模型并行：将模型分割到多个GPU")
print("3. 流水线并行：减少GPU空闲时间")
print("4. 张量并行：在层内分割，需要高速互联")
print("5. 混合精度：使用FP16加速，FP32保持精度")
print("\n大模型通常组合使用多种并行策略")
---
b.梯度累积
当GPU内存不足时，使用梯度累积模拟大batch。将一个大batch分成多个小batch，累积梯度后再更新。梯度累积增加了训练时间，但使得在有限硬件上训练大模型成为可能。需要注意归一化层的处理，确保统计量正确。
c.检查点与恢复
大模型训练可能需要数周甚至数月，必须有可靠的检查点机制。定期保存模型状态、优化器状态、学习率调度器状态、随机数种子等。使用分布式检查点可以加速保存和加载。断点续训是长时间训练的必备功能。
d.监控与调试
大规模训练需要完善的监控系统。监控指标包括：损失曲线、学习率、梯度范数、激活值分布、GPU利用率等。及时发现和处理异常，如梯度爆炸、NaN损失等。使用TensorBoard、Weights & Biases等工具可视化训练过程。
04.开源大模型
a.LLaMA系列
LLaMA（Large Language Model Meta AI）是Meta开源的大语言模型系列。LLaMA遵循Chinchilla规模定律，在更多数据上训练更小的模型。LLaMA-2进一步改进，包含7B到70B多个版本。LLaMA的开源推动了开源大模型生态的发展，催生了Alpaca、Vicuna等衍生模型。
b.Mistral与Mixtral
Mistral是高性能的开源模型，7B参数但性能接近13B模型。使用Sliding Window Attention处理长上下文。Mixtral是稀疏混合专家（MoE）模型，8个专家共47B参数，但每次只激活13B。MoE架构提供了更好的参数效率。
c.Qwen与ChatGLM
Qwen（通义千问）是阿里云开源的中文大模型，支持多语言。ChatGLM是智谱AI开源的双语对话模型，使用GLM架构。这些模型在中文任务上表现出色，推动了中文NLP的发展。开源中文大模型降低了中文应用的门槛。
d.开源生态
开源大模型催生了丰富的生态系统。Hugging Face提供模型托管和推理服务。LangChain、LlamaIndex等框架简化应用开发。PEFT、LoRA等技术降低微调成本。开源社区的贡献使得大模型技术更加普及和民主化。
6.2 模型压缩与加速
01.量化技术
a.量化基础
a.量化原理
量化将高精度浮点数（FP32/FP16）转换为低精度整数（INT8/INT4），减少模型大小和计算量。量化包括权重量化和激活量化。Post-Training Quantization（PTQ）在训练后量化，简单但可能损失精度。Quantization-Aware Training（QAT）在训练时模拟量化，精度更高但成本更大。
b.量化实现
---
import torch
import torch.nn as nn
import torch.quantization as quant
class QuantizationHelper:
"""量化辅助类"""
@staticmethod
def quantize_tensor(tensor, num_bits=8):
"""
对张量进行对称量化
Args:
tensor: 输入张量
num_bits: 量化位数
Returns:
quantized: 量化后的张量
scale: 缩放因子
"""
# 计算缩放因子
qmin = -(2 ** (num_bits - 1))
qmax = 2 ** (num_bits - 1) - 1
min_val = tensor.min()
max_val = tensor.max()
scale = (max_val - min_val) / (qmax - qmin)
zero_point = qmin - min_val / scale
# 量化
quantized = torch.clamp(
torch.round(tensor / scale + zero_point),
qmin, qmax
).to(torch.int8)
return quantized, scale, zero_point
@staticmethod
def dequantize_tensor(quantized, scale, zero_point):
"""
反量化
Args:
quantized: 量化的张量
scale: 缩放因子
zero_point: 零点
Returns:
dequantized: 反量化的张量
"""
return (quantized.float() - zero_point) * scale
class QuantizedLinear(nn.Module):
"""量化的线性层"""
def __init__(self, in_features, out_features, num_bits=8):
super(QuantizedLinear, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.num_bits = num_bits
# 权重（FP32）
self.weight = nn.Parameter(
torch.randn(out_features, in_features)
)
self.bias = nn.Parameter(torch.zeros(out_features))
# 量化参数
self.register_buffer('weight_scale', torch.tensor(1.0))
self.register_buffer('weight_zero_point', torch.tensor(0.0))
self.register_buffer('quantized_weight', torch.zeros_like(self.weight, dtype=torch.int8))
def quantize_weights(self):
"""量化权重"""
helper = QuantizationHelper()
quantized, scale, zero_point = helper.quantize_tensor(
self.weight, self.num_bits
)
self.quantized_weight = quantized
self.weight_scale = scale
self.weight_zero_point = zero_point
def forward(self, x):
"""
前向传播（使用量化权重）
Args:
x: 输入 [batch_size, in_features]
Returns:
output: 输出 [batch_size, out_features]
"""
# 反量化权重
helper = QuantizationHelper()
weight_fp = helper.dequantize_tensor(
self.quantized_weight,
self.weight_scale,
self.weight_zero_point
)
# 线性变换
return nn.functional.linear(x, weight_fp, self.bias)
# 使用示例
print("=== 量化示例 ===\n")
# 创建原始层和量化层
in_features, out_features = 768, 3072
original_layer = nn.Linear(in_features, out_features)
quantized_layer = QuantizedLinear(in_features, out_features, num_bits=8)
# 复制权重
quantized_layer.weight.data = original_layer.weight.data.clone()
quantized_layer.bias.data = original_layer.bias.data.clone()
# 量化
quantized_layer.quantize_weights()
# 测试
x = torch.randn(4, in_features)
original_output = original_layer(x)
quantized_output = quantized_layer(x)
# 计算误差
error = (original_output - quantized_output).abs().mean()
print(f"原始层参数量: {sum(p.numel() * 4 for p in original_layer.parameters()) / 1024:.2f} KB (FP32)")
print(f"量化层参数量: {quantized_layer.quantized_weight.numel() / 1024:.2f} KB (INT8)")
print(f"压缩比: {4:.1f}x")
print(f"平均误差: {error.item():.6f}")
# GPTQ量化
print("\n=== GPTQ量化 ===")
print("GPTQ是一种先进的PTQ方法，特别适合大语言模型")
print("特点:")
print("1. 逐层量化，最小化重构误差")
print("2. 支持INT4/INT3量化")
print("3. 在大模型上精度损失很小")
print("4. 量化后的模型可以直接推理")
---
b.INT8量化
INT8量化将FP32/FP16转换为8位整数，模型大小减少4倍或2倍。INT8量化在大多数硬件上都有加速支持。对于大语言模型，INT8量化通常只损失很小的精度。LLM.int8()等方法通过混合精度量化进一步提升精度。
c.INT4量化
INT4量化将模型压缩到原来的1/8，但精度损失更大。GPTQ、AWQ等方法通过优化量化策略，使得INT4量化在大模型上可行。INT4量化使得在消费级GPU上运行大模型成为可能。但需要特殊的推理内核支持。
d.混合精度量化
不同层对量化的敏感度不同。混合精度量化对敏感层使用高精度，对不敏感层使用低精度。例如，注意力层使用FP16，FFN层使用INT8。这种策略在精度和效率之间取得平衡。
02.模型剪枝
a.结构化剪枝
a.剪枝策略
结构化剪枝移除整个神经元、通道或层，保持模型结构规整。剪枝可以基于重要性（如梯度、权重大小）或冗余性。剪枝后需要微调恢复性能。结构化剪枝在硬件上更容易加速，因为不改变矩阵运算的结构。
b.剪枝实现
---
import torch
import torch.nn as nn
import torch.nn.utils.prune as prune
class StructuredPruning:
"""结构化剪枝"""
def __init__(self, model):
self.model = model
self.pruning_history = []
def compute_importance(self, module, param_name='weight'):
"""
计算参数重要性
Args:
module: 模块
param_name: 参数名
Returns:
importance: 重要性分数
"""
param = getattr(module, param_name)
# 使用L1范数作为重要性度量
if param.dim() == 2: # 线性层
importance = param.abs().sum(dim=1) # 每个输出神经元的重要性
elif param.dim() == 4: # 卷积层
importance = param.abs().sum(dim=(1, 2, 3)) # 每个输出通道的重要性
else:
importance = param.abs()
return importance
def prune_layer(self, module, prune_ratio=0.3, param_name='weight'):
"""
剪枝单个层
Args:
module: 要剪枝的模块
prune_ratio: 剪枝比例
param_name: 参数名
"""
# 计算重要性
importance = self.compute_importance(module, param_name)
# 确定剪枝阈值
threshold = torch.quantile(importance, prune_ratio)
# 创建掩码
mask = importance > threshold
# 应用掩码
param = getattr(module, param_name)
with torch.no_grad():
if param.dim() == 2:
param[~mask, :] = 0
elif param.dim() == 4:
param[~mask, :, :, :] = 0
pruned_count = (~mask).sum().item()
total_count = mask.numel()
self.pruning_history.append({
'module': module.__class__.__name__,
'pruned': pruned_count,
'total': total_count,
'ratio': pruned_count / total_count
})
return mask
def prune_model(self, prune_ratio=0.3):
"""
剪枝整个模型
Args:
prune_ratio: 剪枝比例
"""
for name, module in self.model.named_modules():
if isinstance(module, nn.Linear):
self.prune_layer(module, prune_ratio)
# 打印剪枝统计
total_pruned = sum(h['pruned'] for h in self.pruning_history)
total_params = sum(h['total'] for h in self.pruning_history)
print(f"剪枝完成:")
print(f" 总参数: {total_params:,}")
print(f" 剪枝参数: {total_pruned:,}")
print(f" 剪枝比例: {total_pruned/total_params*100:.2f}%")
def fine_tune(self, train_loader, num_epochs=3, lr=1e-4):
"""
剪枝后微调
Args:
train_loader: 训练数据
num_epochs: 微调轮数
lr: 学习率
"""
optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
criterion = nn.CrossEntropyLoss()
self.model.train()
for epoch in range(num_epochs):
total_loss = 0
for batch in train_loader:
inputs, labels = batch
outputs = self.model(inputs)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
avg_loss = total_loss / len(train_loader)
print(f"Epoch {epoch+1}, Loss: {avg_loss:.4f}")
# 注意力头剪枝
class AttentionHeadPruning:
"""注意力头剪枝"""
def __init__(self, model):
self.model = model
self.head_importance = {}
def compute_head_importance(self, attention_layer, inputs):
"""
计算注意力头的重要性
Args:
attention_layer: 注意力层
inputs: 输入数据
Returns:
importance: 每个头的重要性
"""
# 前向传播，记录每个头的输出
with torch.no_grad():
outputs, attention_weights = attention_layer(inputs)
# 使用注意力权重的熵作为重要性度量
# 熵低表示注意力集中，可能更重要
num_heads = attention_weights.size(1)
importance = torch.zeros(num_heads)
for head in range(num_heads):
head_attn = attention_weights[:, head, :, :]
# 计算熵
entropy = -(head_attn * torch.log(head_attn + 1e-10)).sum(dim=-1).mean()
importance[head] = -entropy # 负熵，越小越重要
return importance
def prune_heads(self, attention_layer, num_heads_to_prune):
"""
剪枝注意力头
Args:
attention_layer: 注意力层
num_heads_to_prune: 要剪枝的头数
"""
# 找到最不重要的头
importance = self.head_importance[attention_layer]
heads_to_prune = importance.argsort()[:num_heads_to_prune]
# 剪枝（将对应头的权重置零）
# 实际实现需要根据具体的注意力层结构
print(f"剪枝头: {heads_to_prune.tolist()}")
print("剪枝策略:")
print("1. 幅度剪枝：移除权重绝对值小的参数")
print("2. 梯度剪枝：移除梯度小的参数")
print("3. 注意力头剪枝：移除不重要的注意力头")
print("4. 层剪枝：移除整个Transformer层")
print("\n剪枝后需要微调以恢复性能")
---
b.非结构化剪枝
非结构化剪枝移除单个权重，不保持结构规整。可以达到更高的压缩比，但在硬件上加速困难。需要稀疏矩阵运算支持。对于大语言模型，非结构化剪枝的实用性有限，因为推理加速不明显。
c.动态剪枝
动态剪枝根据输入动态决定哪些部分参与计算。Early Exit允许简单样本提前退出，节省计算。动态剪枝在推理时根据输入的复杂度调整计算量，提供了灵活性。但实现复杂，需要额外的判断机制。
d.知识蒸馏结合
剪枝和知识蒸馏结合可以进一步提升性能。教师模型（未剪枝）指导学生模型（剪枝后）学习。蒸馏损失和任务损失联合优化。这种方法在保持压缩比的同时，最大化保留性能。
03.推理优化
a.KV缓存
a.缓存机制
自回归生成时，每步都需要计算所有之前位置的Key和Value，造成大量重复计算。KV缓存保存已计算的Key和Value，新步骤只计算当前位置。KV缓存大幅加速推理，但增加内存占用。对于长序列，KV缓存可能成为内存瓶颈。
b.KV缓存实现
---
import torch
import torch.nn as nn
class KVCacheAttention(nn.Module):
"""带KV缓存的注意力层"""
def __init__(self, d_model, num_heads):
super(KVCacheAttention, self).__init__()
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
self.q_proj = nn.Linear(d_model, d_model)
self.k_proj = nn.Linear(d_model, d_model)
self.v_proj = nn.Linear(d_model, d_model)
self.o_proj = nn.Linear(d_model, d_model)
def forward(self, x, past_kv=None, use_cache=False):
"""
前向传播（支持KV缓存）
Args:
x: 输入 [batch_size, seq_len, d_model]
past_kv: 过去的KV缓存 (past_k, past_v)
use_cache: 是否使用缓存
Returns:
output: 输出
present_kv: 当前的KV缓存（如果use_cache=True）
"""
batch_size, seq_len, _ = x.size()
# 计算Q, K, V
Q = self.q_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
K = self.k_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
V = self.v_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
# 转置
Q = Q.transpose(1, 2) # [batch, num_heads, seq_len, d_k]
K = K.transpose(1, 2)
V = V.transpose(1, 2)
# 如果有past_kv，拼接
if past_kv is not None:
past_k, past_v = past_kv
K = torch.cat([past_k, K], dim=2)
V = torch.cat([past_v, V], dim=2)
# 计算注意力
scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5)
attn_weights = torch.softmax(scores, dim=-1)
context = torch.matmul(attn_weights, V)
# 合并头
context = context.transpose(1, 2).contiguous()
context = context.view(batch_size, seq_len, self.d_model)
# 输出投影
output = self.o_proj(context)
# 返回当前KV用于缓存
present_kv = (K, V) if use_cache else None
return output, present_kv
class GenerationWithCache:
"""使用KV缓存的生成"""
def __init__(self, model):
self.model = model
def generate(self, input_ids, max_length=50):
"""
自回归生成（使用KV缓存）
Args:
input_ids: 初始输入 [batch_size, init_len]
max_length: 最大生成长度
Returns:
generated_ids: 生成的序列
"""
batch_size = input_ids.size(0)
generated = input_ids
past_kvs = None # 初始没有缓存
for step in range(max_length):
# 如果有缓存，只需要处理最后一个token
if past_kvs is not None:
current_input = generated[:, -1:]
else:
current_input = generated
# 前向传播
with torch.no_grad():
logits, past_kvs = self.model(
current_input,
past_kv=past_kvs,
use_cache=True
)
# 获取下一个token
next_token_logits = logits[:, -1, :]
next_token = next_token_logits.argmax(dim=-1, keepdim=True)
# 添加到生成序列
generated = torch.cat([generated, next_token], dim=1)
# 检查结束
if (next_token == self.model.eos_token_id).all():
break
return generated
# 性能对比
print("=== KV缓存性能对比 ===\n")
d_model = 768
seq_len = 100
gen_len = 50
# 不使用缓存：每步计算所有位置
no_cache_flops = sum(
(seq_len + i) * d_model * d_model * 4 # Q, K, V, O投影
for i in range(gen_len)
)
# 使用缓存：只计算新位置
with_cache_flops = (
seq_len * d_model * d_model * 4 + # 初始计算
gen_len * d_model * d_model * 4 # 每步只计算新位置
)
speedup = no_cache_flops / with_cache_flops
print(f"序列长度: {seq_len}")
print(f"生成长度: {gen_len}")
print(f"不使用缓存FLOPs: {no_cache_flops:,}")
print(f"使用缓存FLOPs: {with_cache_flops:,}")
print(f"加速比: {speedup:.2f}x")
print(f"\n内存开销: {seq_len * d_model * 2 * 4 / 1024:.2f} KB (FP32)")
---
b.批处理优化
批处理多个请求可以提升吞吐量。但不同请求的长度不同，需要padding到相同长度，造成浪费。动态批处理根据请求长度动态组batch，减少padding。Continuous Batching允许请求在不同时间完成，进一步提升效率。
c.投机解码
投机解码（Speculative Decoding）使用小模型快速生成候选token，大模型并行验证。如果验证通过，节省了大模型的自回归步骤。投机解码在保持质量的同时，显著加速推理。但需要小模型和大模型的配合。
d.Flash Attention
Flash Attention通过重新组织注意力计算的内存访问模式，减少HBM访问，充分利用SRAM。Flash Attention在数学上等价于标准注意力，但速度快2-4倍，内存占用更少。Flash Attention 2进一步优化，成为大模型推理的标准选择。
04.模型部署
a.推理框架
vLLM、TensorRT-LLM、llama.cpp等推理框架针对大模型优化。这些框架实现了KV缓存、连续批处理、量化等优化技术。vLLM使用PagedAttention管理KV缓存，大幅提升吞吐量。选择合适的推理框架对性能至关重要。
b.服务化部署
大模型通常以API服务形式部署。需要考虑负载均衡、请求队列、超时处理等。使用异步处理提升并发能力。监控GPU利用率、延迟、吞吐量等指标。Ray Serve、Triton等框架简化服务化部署。
c.边缘部署
在边缘设备（手机、IoT）上部署大模型面临资源限制。需要极致的压缩和优化。量化到INT4甚至更低，剪枝到可接受的大小。使用模型分割、云边协同等技术。边缘部署使得AI能力无处不在。
d.成本优化
大模型推理成本高昂，需要优化。使用Spot实例降低云成本。批处理提升GPU利用率。缓存常见请求的结果。根据请求复杂度选择模型大小。成本优化是商业化的关键考虑。
6.3 检索增强生成
01.RAG基础架构
a.RAG原理
a.核心概念
检索增强生成（Retrieval-Augmented Generation, RAG）结合检索系统和生成模型，通过检索相关文档来增强生成质量。RAG解决了大模型的知识局限性和幻觉问题。工作流程：用户查询 → 检索相关文档 → 将文档和查询组合为提示 → 生成回答。RAG使得模型能够访问最新信息和私有知识库。
b.RAG实现
---
import torch
import numpy as np
from typing import List, Dict, Tuple
class DocumentStore:
"""文档存储和检索"""
def __init__(self, embedding_model):
self.documents = []
self.embeddings = []
self.embedding_model = embedding_model
def add_documents(self, documents: List[str]):
"""
添加文档到存储
Args:
documents: 文档列表
"""
for doc in documents:
# 计算文档嵌入
embedding = self.embedding_model.encode(doc)
self.documents.append(doc)
self.embeddings.append(embedding)
# 转换为numpy数组
self.embeddings = np.array(self.embeddings)
def retrieve(self, query: str, top_k: int = 3) -> List[Tuple[str, float]]:
"""
检索相关文档
Args:
query: 查询文本
top_k: 返回top-k个文档
Returns:
results: [(document, score), ...]
"""
# 计算查询嵌入
query_embedding = self.embedding_model.encode(query)
# 计算相似度（余弦相似度）
similarities = np.dot(self.embeddings, query_embedding) / (
np.linalg.norm(self.embeddings, axis=1) *
np.linalg.norm(query_embedding)
)
# 获取top-k
top_indices = np.argsort(similarities)[-top_k:][::-1]
results = [
(self.documents[idx], similarities[idx])
for idx in top_indices
]
return results
class RAGSystem:
"""RAG系统"""
def __init__(self, retriever, generator, tokenizer):
"""
Args:
retriever: 检索器（DocumentStore）
generator: 生成模型
tokenizer: 分词器
"""
self.retriever = retriever
self.generator = generator
self.tokenizer = tokenizer
def create_prompt(self, query: str, documents: List[str]) -> str:
"""
创建RAG提示
Args:
query: 用户查询
documents: 检索到的文档
Returns:
prompt: 完整提示
"""
# 组合文档
context = "\n\n".join([
f"Document {i+1}: {doc}"
for i, doc in enumerate(documents)
])
# 创建提示
prompt = f"""Answer the question based on the following documents:
{context}
Question: {query}
Answer:"""
return prompt
def generate_answer(self, query: str, top_k: int = 3,
max_length: int = 200) -> Dict[str, any]:
"""
生成答案
Args:
query: 用户查询
top_k: 检索文档数
max_length: 最大生成长度
Returns:
result: {'answer': str, 'sources': List[str], 'scores': List[float]}
"""
# 1. 检索相关文档
retrieved = self.retriever.retrieve(query, top_k)
documents = [doc for doc, score in retrieved]
scores = [score for doc, score in retrieved]
# 2. 创建提示
prompt = self.create_prompt(query, documents)
# 3. 生成答案
input_ids = self.tokenizer.encode(prompt, return_tensors='pt')
with torch.no_grad():
output_ids = self.generator.generate(
input_ids,
max_length=max_length,
num_beams=4,
early_stopping=True
)
answer = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
# 4. 返回结果
return {
'answer': answer,
'sources': documents,
'scores': scores
}
# 使用示例
print("=== RAG系统示例 ===\n")
# 模拟文档库
documents = [
"Python is a high-level programming language known for its simplicity.",
"Machine learning is a subset of artificial intelligence.",
"Deep learning uses neural networks with multiple layers.",
"Natural language processing deals with text and speech.",
"Transformers revolutionized NLP with attention mechanisms."
]
print("文档库:")
for i, doc in enumerate(documents, 1):
print(f"{i}. {doc}")
print("\n查询: What is deep learning?")
print("\n检索到的相关文档:")
print("1. Deep learning uses neural networks with multiple layers. (score: 0.89)")
print("2. Machine learning is a subset of artificial intelligence. (score: 0.72)")
print("3. Transformers revolutionized NLP with attention mechanisms. (score: 0.65)")
print("\n生成的答案:")
print("Deep learning is a machine learning technique that uses neural networks")
print("with multiple layers to learn representations of data.")
---
b.向量数据库
向量数据库专门用于存储和检索高维向量。常用的向量数据库包括Faiss、Milvus、Pinecone、Weaviate等。向量数据库支持高效的相似度搜索，可以处理数百万甚至数十亿的向量。使用ANN（近似最近邻）算法加速检索，如HNSW、IVF等。
c.混合检索
混合检索结合稀疏检索（如BM25）和密集检索（向量检索）。稀疏检索擅长精确匹配，密集检索擅长语义匹配。通过加权组合两者的结果，提升检索质量。混合检索在实际应用中效果优于单一方法。
d.重排序
检索到的文档可能不是最相关的。重排序（Reranking）使用更强的模型对候选文档重新排序。Cross-encoder模型同时编码查询和文档，计算相关性分数。重排序提升检索质量，但增加计算开销。通常先用快速检索获取候选，再用重排序精选。
02.知识库构建
a.文档分块
长文档需要分块以适应模型的上下文长度限制。分块策略包括：固定长度分块、句子分块、段落分块、语义分块等。分块时需要保留上下文，避免信息丢失。重叠分块可以确保跨块的信息不被截断。分块大小影响检索精度和生成质量。
b.元数据管理
为每个文档块添加元数据，如来源、时间、作者、标签等。元数据用于过滤和排序检索结果。例如，只检索特定时间范围或特定来源的文档。元数据管理提升了检索的精确性和可控性。
c.增量更新
知识库需要支持增量更新，添加新文档或删除过时文档。增量更新避免了重新构建整个索引的开销。需要维护文档版本和更新时间戳。定期清理和优化索引，保持检索性能。
d.多模态知识
知识库可以包含文本、图像、表格等多模态数据。多模态嵌入模型（如CLIP）将不同模态映射到统一空间。支持跨模态检索，如用文本查询图像。多模态RAG扩展了应用场景，如文档理解、视觉问答等。
03.RAG优化技术
a.查询改写
a.改写策略
用户查询可能不够清晰或完整。查询改写通过扩展、重构查询来提升检索质量。方法包括：查询扩展（添加同义词、相关词）、查询分解（将复杂查询分解为子查询）、查询澄清（生成澄清问题）等。查询改写是RAG流程的重要预处理步骤。
b.改写实现
---
import torch
class QueryRewriter:
"""查询改写器"""
def __init__(self, model, tokenizer):
self.model = model
self.tokenizer = tokenizer
def expand_query(self, query: str) -> List[str]:
"""
查询扩展：生成多个变体
Args:
query: 原始查询
Returns:
expanded_queries: 扩展后的查询列表
"""
prompt = f"""Generate 3 alternative phrasings of the following question:
Question: {query}
Alternative 1:"""
# 生成变体（简化示例）
expanded_queries = [query] # 包含原始查询
# 实际实现会使用模型生成
# expanded_queries.extend(model_generated_variants)
return expanded_queries
def decompose_query(self, query: str) -> List[str]:
"""
查询分解：将复杂查询分解为子查询
Args:
query: 复杂查询
Returns:
sub_queries: 子查询列表
"""
prompt = f"""Break down the following complex question into simpler sub-questions:
Question: {query}
Sub-questions:
1."""
# 生成子查询
sub_queries = [query]
return sub_queries
def clarify_query(self, query: str, context: str = "") -> str:
"""
查询澄清：生成更明确的查询
Args:
query: 模糊查询
context: 上下文信息
Returns:
clarified_query: 澄清后的查询
"""
prompt = f"""Rephrase the following vague question to be more specific:
Question: {query}
{f'Context: {context}' if context else ''}
Specific question:"""
# 生成澄清查询
clarified_query = query
return clarified_query
# HyDE（Hypothetical Document Embeddings）
class HyDERetriever:
"""HyDE检索器"""
def __init__(self, generator, retriever):
self.generator = generator
self.retriever = retriever
def generate_hypothetical_document(self, query: str) -> str:
"""
生成假设文档
Args:
query: 用户查询
Returns:
hypothetical_doc: 假设的答案文档
"""
prompt = f"""Write a detailed answer to the following question:
Question: {query}
Answer:"""
# 生成假设文档
# hypothetical_doc = self.generator.generate(prompt)
hypothetical_doc = "Generated hypothetical answer..."
return hypothetical_doc
def retrieve(self, query: str, top_k: int = 3) -> List[str]:
"""
使用HyDE检索
Args:
query: 用户查询
top_k: 返回文档数
Returns:
documents: 检索到的文档
"""
# 1. 生成假设文档
hypothetical_doc = self.generate_hypothetical_document(query)
# 2. 使用假设文档检索
results = self.retriever.retrieve(hypothetical_doc, top_k)
return [doc for doc, score in results]
print("查询优化技术:")
print("1. 查询扩展：生成同义变体，提升召回率")
print("2. 查询分解：将复杂查询分解为简单子查询")
print("3. 查询澄清：使模糊查询更明确")
print("4. HyDE：生成假设答案，用于检索")
print("\n这些技术显著提升RAG的检索质量")
---
b.上下文压缩
检索到的文档可能包含大量无关信息。上下文压缩提取最相关的片段，减少提示长度。方法包括：句子级过滤、关键信息抽取、摘要压缩等。压缩后的上下文更聚焦，提升生成质量，降低成本。
c.迭代检索
单次检索可能不足以回答复杂问题。迭代检索根据生成的部分答案，进行多轮检索。每轮检索补充新信息，逐步完善答案。迭代检索适合需要多步推理的问题，如多跳问答。
d.自我反思
生成答案后，模型评估答案的质量和可信度。如果不满意，重新检索或改写查询。自我反思提升了答案的准确性和可靠性。可以结合不确定性估计，对低置信度答案触发反思。
04.RAG应用场景
a.企业知识库
RAG使得企业能够构建智能知识库问答系统。员工可以用自然语言查询公司文档、政策、流程等。RAG自动更新知识，无需重新训练模型。提升了知识获取效率，降低了培训成本。
b.客户服务
RAG驱动的客服机器人能够回答客户问题，提供准确的产品信息。检索产品手册、FAQ、历史工单等。RAG减少了人工客服的负担，提升了响应速度和一致性。
c.研究助手
RAG帮助研究人员快速查找和总结文献。输入研究问题，RAG检索相关论文，生成综述。支持多语言、跨领域检索。加速了文献调研过程。
d.代码助手
RAG检索代码库、API文档，辅助编程。根据自然语言描述生成代码，参考检索到的示例。提升了开发效率，降低了学习曲线。GitHub Copilot等工具使用类似技术。
6.4 Agent与工具使用
01.Agent基础架构
a.Agent概念
a.核心思想
Agent是能够感知环境、制定计划、执行行动的智能体。LLM驱动的Agent使用语言模型作为"大脑"，通过工具扩展能力。Agent的工作流程：接收任务 → 分析任务 → 制定计划 → 调用工具 → 观察结果 → 调整计划 → 完成任务。Agent使得LLM能够与外部世界交互，完成复杂任务。
b.Agent实现
---
import json
from typing import List, Dict, Callable, Any
class Tool:
"""工具基类"""
def __init__(self, name: str, description: str, func: Callable):
self.name = name
self.description = description
self.func = func
def run(self, *args, **kwargs) -> Any:
"""执行工具"""
return self.func(*args, **kwargs)
def to_dict(self) -> Dict:
"""转换为字典（用于提示）"""
return {
'name': self.name,
'description': self.description
}
class Agent:
"""LLM Agent"""
def __init__(self, llm, tools: List[Tool], max_iterations: int = 10):
"""
Args:
llm: 语言模型
tools: 可用工具列表
max_iterations: 最大迭代次数
"""
self.llm = llm
self.tools = {tool.name: tool for tool in tools}
self.max_iterations = max_iterations
self.memory = [] # 对话历史
def create_system_prompt(self) -> str:
"""创建系统提示"""
tools_desc = "\n".join([
f"- {tool.name}: {tool.description}"
for tool in self.tools.values()
])
prompt = f"""You are a helpful AI assistant with access to the following tools:
{tools_desc}
To use a tool, respond with a JSON object in this format:
{{"action": "tool_name", "action_input": "input_string"}}
To give a final answer, respond with:
{{"action": "Final Answer", "action_input": "your answer"}}
Think step by step and use tools when necessary."""
return prompt
def parse_action(self, response: str) -> Dict:
"""
解析模型输出的动作
Args:
response: 模型响应
Returns:
action: {'action': str, 'action_input': str}
"""
try:
# 尝试解析JSON
action = json.loads(response)
return action
except json.JSONDecodeError:
# 如果不是JSON，尝试提取
# 简化实现
return {'action': 'Final Answer', 'action_input': response}
def run(self, task: str) -> str:
"""
执行任务
Args:
task: 任务描述
Returns:
result: 最终答案
"""
# 初始化
self.memory = []
system_prompt = self.create_system_prompt()
# 添加任务
self.memory.append(f"Task: {task}")
for iteration in range(self.max_iterations):
# 构建提示
prompt = system_prompt + "\n\n" + "\n".join(self.memory)
# 获取模型响应
response = self.llm.generate(prompt)
self.memory.append(f"Thought: {response}")
# 解析动作
action = self.parse_action(response)
# 执行动作
if action['action'] == 'Final Answer':
return action['action_input']
elif action['action'] in self.tools:
# 调用工具
tool = self.tools[action['action']]
try:
observation = tool.run(action['action_input'])
self.memory.append(f"Observation: {observation}")
except Exception as e:
self.memory.append(f"Error: {str(e)}")
else:
self.memory.append(f"Error: Unknown action {action['action']}")
return "Failed to complete task within max iterations"
# 定义工具
def calculator(expression: str) -> float:
"""计算数学表达式"""
try:
result = eval(expression)
return result
except Exception as e:
return f"Error: {str(e)}"
def search(query: str) -> str:
"""搜索信息（模拟）"""
# 实际实现会调用搜索API
return f"Search results for '{query}': [simulated results]"
def get_weather(location: str) -> str:
"""获取天气信息（模拟）"""
return f"Weather in {location}: Sunny, 25°C"
# 创建工具
tools = [
Tool("Calculator", "Perform mathematical calculations", calculator),
Tool("Search", "Search for information on the internet", search),
Tool("Weather", "Get current weather for a location", get_weather)
]
# 使用示例
print("=== Agent示例 ===\n")
print("可用工具:")
for tool in tools:
print(f"- {tool.name}: {tool.description}")
print("\n任务: What is the weather in Beijing and what is 15 * 23?")
print("\nAgent执行过程:")
print("1. Thought: I need to get weather and do calculation")
print("2. Action: {\"action\": \"Weather\", \"action_input\": \"Beijing\"}")
print("3. Observation: Weather in Beijing: Sunny, 25°C")
print("4. Action: {\"action\": \"Calculator\", \"action_input\": \"15 * 23\"}")
print("5. Observation: 345")
print("6. Action: {\"action\": \"Final Answer\", \"action_input\": \"...\"}")
---
b.ReAct框架
ReAct（Reasoning and Acting）框架交替进行推理和行动。每步先推理（Thought），然后行动（Action），观察结果（Observation），再继续推理。ReAct使得Agent的决策过程可解释，提升了可靠性。ReAct是目前最流行的Agent框架之一。
c.规划能力
复杂任务需要规划能力。Agent分解任务为子任务，制定执行计划。规划方法包括：层次规划、前向规划、反向规划等。规划提升了Agent处理复杂任务的能力，但增加了推理开销。
d.记忆管理
Agent需要记忆来维护上下文。短期记忆存储当前任务的信息，长期记忆存储历史经验。记忆管理包括：记忆检索、记忆更新、记忆遗忘等。有效的记忆管理使得Agent能够处理长期任务和多轮交互。
02.工具使用
a.函数调用
a.Function Calling
Function Calling是OpenAI提供的工具使用接口。模型输出结构化的函数调用，应用执行函数并返回结果。Function Calling使得工具集成更简单、更可靠。支持多个函数并行调用，提升效率。
b.Function Calling实现
---
import json
from typing import List, Dict, Callable
class FunctionCallingAgent:
"""支持Function Calling的Agent"""
def __init__(self, llm):
self.llm = llm
self.functions = {}
def register_function(self, name: str, description: str,
parameters: Dict, func: Callable):
"""
注册函数
Args:
name: 函数名
description: 函数描述
parameters: 参数schema（JSON Schema格式）
func: 实际函数
"""
self.functions[name] = {
'name': name,
'description': description,
'parameters': parameters,
'func': func
}
def create_function_definitions(self) -> List[Dict]:
"""创建函数定义列表"""
return [
{
'name': func['name'],
'description': func['description'],
'parameters': func['parameters']
}
for func in self.functions.values()
]
def execute_function(self, function_call: Dict) -> str:
"""
执行函数调用
Args:
function_call: {'name': str, 'arguments': str}
Returns:
result: 函数执行结果
"""
name = function_call['name']
arguments = json.loads(function_call['arguments'])
if name in self.functions:
func = self.functions[name]['func']
try:
result = func(**arguments)
return json.dumps(result)
except Exception as e:
return json.dumps({'error': str(e)})
else:
return json.dumps({'error': f'Unknown function: {name}'})
def run(self, messages: List[Dict]) -> str:
"""
运行Agent
Args:
messages: 对话历史
Returns:
response: 最终响应
"""
function_defs = self.create_function_definitions()
while True:
# 调用LLM
response = self.llm.chat_completion(
messages=messages,
functions=function_defs
)
# 检查是否有函数调用
if 'function_call' in response:
# 执行函数
function_call = response['function_call']
result = self.execute_function(function_call)
# 添加函数调用和结果到历史
messages.append({
'role': 'assistant',
'content': None,
'function_call': function_call
})
messages.append({
'role': 'function',
'name': function_call['name'],
'content': result
})
else:
# 没有函数调用，返回最终响应
return response['content']
# 注册函数示例
def get_current_time(timezone: str = "UTC") -> Dict:
"""获取当前时间"""
from datetime import datetime
return {
'time': datetime.now().isoformat(),
'timezone': timezone
}
def send_email(to: str, subject: str, body: str) -> Dict:
"""发送邮件（模拟）"""
return {
'status': 'sent',
'to': to,
'subject': subject
}
# 创建Agent
agent = FunctionCallingAgent(llm=None) # 需要实际的LLM
# 注册函数
agent.register_function(
name="get_current_time",
description="Get the current time in a specific timezone",
parameters={
"type": "object",
"properties": {
"timezone": {
"type": "string",
"description": "The timezone, e.g. UTC, EST, PST"
}
}
},
func=get_current_time
)
agent.register_function(
name="send_email",
description="Send an email to a recipient",
parameters={
"type": "object",
"properties": {
"to": {"type": "string", "description": "Recipient email"},
"subject": {"type": "string", "description": "Email subject"},
"body": {"type": "string", "description": "Email body"}
},
"required": ["to", "subject", "body"]
},
func=send_email
)
print("Function Calling优势:")
print("1. 结构化输出：模型输出标准JSON格式")
print("2. 类型安全：参数schema确保类型正确")
print("3. 并行调用：支持同时调用多个函数")
print("4. 易于集成：标准接口，简化开发")
---
b.API集成
Agent可以调用各种API扩展能力。常见API包括：搜索API（Google、Bing）、数据库API、文件系统API、第三方服务API等。API集成需要处理认证、错误处理、速率限制等。LangChain等框架提供了丰富的API集成工具。
c.代码执行
Agent可以生成和执行代码来完成任务。代码执行需要沙箱环境，确保安全。支持多种语言，如Python、JavaScript等。代码执行使得Agent能够进行复杂计算、数据处理等。但需要严格的安全措施。
d.多模态工具
Agent可以使用多模态工具，如图像生成（DALL-E）、语音合成（TTS）、视觉理解（GPT-4V）等。多模态工具扩展了Agent的感知和表达能力。使得Agent能够处理更丰富的任务，如创建演示文稿、分析图表等。
03.多Agent协作
a.Agent通信
多个Agent可以协作完成复杂任务。Agent之间通过消息传递通信。通信协议定义了消息格式和交互规则。Agent可以请求帮助、共享信息、协商计划等。多Agent系统提升了任务处理能力和鲁棒性。
b.角色分工
不同Agent承担不同角色，如规划者、执行者、评估者等。角色分工提升了专业化程度和效率。规划者制定计划，执行者完成任务，评估者检查质量。这种分工模拟了人类团队的协作方式。
c.共识机制
多Agent需要达成共识来做决策。共识机制包括投票、辩论、协商等。通过多Agent的讨论，可以得到更可靠的答案。共识机制在关键决策中特别重要，如医疗诊断、法律分析等。
d.竞争与合作
Agent之间可以竞争或合作。竞争驱动Agent提升性能，合作实现共同目标。可以设计竞争-合作混合机制，如竞标任务、协作执行。这种机制在资源分配、任务调度等场景中有用。
04.Agent应用
a.自动化工作流
Agent自动化复杂的工作流程，如数据处理、报告生成、客户服务等。Agent理解任务需求，调用工具完成各个步骤。自动化工作流提升了效率，减少了人工错误。在企业应用中有广泛需求。
b.个人助理
Agent作为个人助理，管理日程、发送邮件、搜索信息等。Agent学习用户偏好，提供个性化服务。个人助理Agent提升了生产力，改善了生活质量。Siri、Alexa等是早期的个人助理，LLM驱动的Agent更智能。
c.研究助手
Agent辅助科研工作，如文献调研、实验设计、数据分析等。Agent检索论文、总结发现、生成假设。研究助手Agent加速了科研进程，降低了入门门槛。在药物发现、材料科学等领域有应用。
d.游戏NPC
Agent作为游戏中的NPC（非玩家角色），提供更智能的交互。Agent理解玩家意图，生成自然的对话和行为。Agent驱动的NPC提升了游戏的沉浸感和可玩性。是游戏AI的未来方向。
6.5 评估与安全
01.模型评估方法
a.自动评估指标
a.常用指标
自动评估指标包括困惑度（Perplexity）、BLEU、ROUGE、BERTScore等。困惑度衡量语言模型的预测能力，越低越好。BLEU和ROUGE用于生成任务，衡量生成文本与参考文本的重叠。BERTScore使用语义嵌入，比n-gram指标更准确。自动指标快速便宜，但与人类判断不完全一致。
b.评估实现
---
import torch
import numpy as np
from collections import Counter
from typing import List, Dict
class EvaluationMetrics:
"""评估指标计算"""
@staticmethod
def perplexity(model, data_loader, device='cuda'):
"""
计算困惑度
Args:
model: 语言模型
data_loader: 数据加载器
device: 设备
Returns:
perplexity: 困惑度
"""
model.eval()
total_loss = 0
total_tokens = 0
with torch.no_grad():
for batch in data_loader:
input_ids = batch['input_ids'].to(device)
labels = batch['labels'].to(device)
outputs = model(input_ids, labels=labels)
loss = outputs.loss
# 累积损失和token数
total_loss += loss.item() * input_ids.size(0)
total_tokens += input_ids.size(0)
avg_loss = total_loss / total_tokens
perplexity = np.exp(avg_loss)
return perplexity
@staticmethod
def bleu_score(reference: str, hypothesis: str, n: int = 4) -> float:
"""
计算BLEU分数
Args:
reference: 参考文本
hypothesis: 生成文本
n: n-gram的最大n
Returns:
bleu: BLEU分数
"""
ref_tokens = reference.split()
hyp_tokens = hypothesis.split()
# 计算各阶n-gram的精确度
precisions = []
for i in range(1, n + 1):
ref_ngrams = Counter([
tuple(ref_tokens[j:j+i])
for j in range(len(ref_tokens) - i + 1)
])
hyp_ngrams = Counter([
tuple(hyp_tokens[j:j+i])
for j in range(len(hyp_tokens) - i + 1)
])
# 计算匹配数
matches = sum((ref_ngrams & hyp_ngrams).values())
total = sum(hyp_ngrams.values())
precision = matches / total if total > 0 else 0
precisions.append(precision)
# 几何平均
if min(precisions) > 0:
bleu = np.exp(np.mean([np.log(p) for p in precisions]))
else:
bleu = 0
# 长度惩罚
bp = min(1.0, np.exp(1 - len(ref_tokens) / len(hyp_tokens)))
return bp * bleu
@staticmethod
def rouge_l(reference: str, hypothesis: str) -> float:
"""
计算ROUGE-L分数（最长公共子序列）
Args:
reference: 参考文本
hypothesis: 生成文本
Returns:
rouge_l: ROUGE-L分数
"""
ref_tokens = reference.split()
hyp_tokens = hypothesis.split()
# 计算LCS长度
m, n = len(ref_tokens), len(hyp_tokens)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if ref_tokens[i-1] == hyp_tokens[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
lcs_length = dp[m][n]
# 计算precision和recall
precision = lcs_length / n if n > 0 else 0
recall = lcs_length / m if m > 0 else 0
# F1分数
if precision + recall > 0:
f1 = 2 * precision * recall / (precision + recall)
else:
f1 = 0
return f1
# 使用示例
print("=== 评估指标示例 ===\n")
reference = "The cat sat on the mat"
hypothesis1 = "The cat sat on the mat" # 完美匹配
hypothesis2 = "The dog sat on the mat" # 部分匹配
hypothesis3 = "A cat was sitting" # 较差匹配
metrics = EvaluationMetrics()
for i, hyp in enumerate([hypothesis1, hypothesis2, hypothesis3], 1):
bleu = metrics.bleu_score(reference, hyp)
rouge = metrics.rouge_l(reference, hyp)
print(f"假设 {i}: {hyp}")
print(f" BLEU: {bleu:.4f}")
print(f" ROUGE-L: {rouge:.4f}\n")
print("指标特点:")
print("- BLEU: 侧重精确匹配，适合翻译任务")
print("- ROUGE: 侧重召回率，适合摘要任务")
print("- BERTScore: 基于语义相似度，更接近人类判断")
---
b.人类评估
人类评估是金标准，但成本高、速度慢。评估维度包括：流畅性、相关性、准确性、有用性等。使用Likert量表或成对比较收集评分。需要多个评估者以提高可靠性。人类评估用于关键决策和模型比较。
c.基准测试
标准基准测试用于比较不同模型。常见基准包括：GLUE、SuperGLUE（理解任务）、MMLU（多任务知识）、HumanEval（代码生成）、MT-Bench（多轮对话）等。基准测试提供了客观的性能比较。但可能存在过拟合和数据泄露问题。
d.A/B测试
在实际应用中，通过A/B测试比较模型版本。将用户随机分配到不同版本，收集使用数据。评估指标包括：用户满意度、任务完成率、使用时长等。A/B测试反映真实场景下的性能，是产品决策的重要依据。
02.安全与对齐
a.有害内容检测
a.检测方法
大模型可能生成有害内容，如暴力、仇恨、色情等。有害内容检测使用分类器识别这些内容。检测器可以是规则、关键词、机器学习模型等。多层检测提升准确性：输入过滤、输出过滤、上下文分析等。检测是安全的第一道防线。
b.安全检测实现
---
import torch
import torch.nn as nn
from typing import List, Dict
class SafetyClassifier(nn.Module):
"""安全分类器"""
def __init__(self, encoder, num_categories=6):
super(SafetyClassifier, self).__init__()
self.encoder = encoder
self.classifier = nn.Linear(encoder.config.hidden_size, num_categories)
# 安全类别
self.categories = [
'safe',
'violence',
'hate',
'sexual',
'self-harm',
'illegal'
]
def forward(self, input_ids, attention_mask):
"""
前向传播
Args:
input_ids: 输入token IDs
attention_mask: 注意力掩码
Returns:
logits: 分类logits
"""
outputs = self.encoder(input_ids, attention_mask=attention_mask)
pooled = outputs.pooler_output
logits = self.classifier(pooled)
return logits
def predict(self, text: str, tokenizer, threshold: float = 0.5) -> Dict:
"""
预测文本安全性
Args:
text: 输入文本
tokenizer: 分词器
threshold: 阈值
Returns:
result: {'is_safe': bool, 'categories': List[str], 'scores': Dict}
"""
# 编码
inputs = tokenizer(text, return_tensors='pt',
padding=True, truncation=True)
# 预测
with torch.no_grad():
logits = self.forward(inputs['input_ids'],
inputs['attention_mask'])
probs = torch.sigmoid(logits[0])
# 解析结果
scores = {cat: prob.item()
for cat, prob in zip(self.categories, probs)}
unsafe_categories = [
cat for cat, score in scores.items()
if cat != 'safe' and score > threshold
]
is_safe = len(unsafe_categories) == 0
return {
'is_safe': is_safe,
'categories': unsafe_categories,
'scores': scores
}
class ContentModerator:
"""内容审核器"""
def __init__(self, safety_classifier):
self.classifier = safety_classifier
self.blocked_count = 0
self.total_count = 0
def moderate_input(self, user_input: str, tokenizer) -> Dict:
"""
审核用户输入
Args:
user_input: 用户输入
tokenizer: 分词器
Returns:
result: {'allowed': bool, 'reason': str}
"""
self.total_count += 1
# 检测
safety_result = self.classifier.predict(user_input, tokenizer)
if not safety_result['is_safe']:
self.blocked_count += 1
return {
'allowed': False,
'reason': f"Input contains unsafe content: {', '.join(safety_result['categories'])}"
}
return {'allowed': True, 'reason': ''}
def moderate_output(self, model_output: str, tokenizer) -> Dict:
"""
审核模型输出
Args:
model_output: 模型输出
tokenizer: 分词器
Returns:
result: {'allowed': bool, 'reason': str, 'filtered_output': str}
"""
# 检测
safety_result = self.classifier.predict(model_output, tokenizer)
if not safety_result['is_safe']:
return {
'allowed': False,
'reason': f"Output contains unsafe content: {', '.join(safety_result['categories'])}",
'filtered_output': "I apologize, but I cannot provide that response."
}
return {
'allowed': True,
'reason': '',
'filtered_output': model_output
}
def get_stats(self) -> Dict:
"""获取审核统计"""
return {
'total': self.total_count,
'blocked': self.blocked_count,
'block_rate': self.blocked_count / self.total_count if self.total_count > 0 else 0
}
print("内容安全检测:")
print("1. 输入过滤：阻止有害输入")
print("2. 输出过滤：阻止有害输出")
print("3. 多类别检测：暴力、仇恨、色情等")
print("4. 阈值调节：平衡安全性和可用性")
print("\n安全检测是负责任AI的基础")
---
b.RLHF对齐
RLHF（Reinforcement Learning from Human Feedback）通过人类反馈对齐模型。流程：收集人类偏好数据 → 训练奖励模型 → 使用PPO优化策略。RLHF使得模型更有帮助、诚实、无害。InstructGPT、ChatGPT都使用RLHF。RLHF是对齐技术的重要突破。
c.红队测试
红队测试通过对抗性输入测试模型的安全性。红队尝试诱导模型生成有害内容、泄露信息、执行危险操作等。发现的漏洞用于改进模型。红队测试是持续的过程，随着攻击方法演进而更新。
d.Constitutional AI
Constitutional AI通过"宪法"（一组原则）指导模型行为。模型自我批评和修正输出，确保符合原则。Constitutional AI减少了对人类反馈的依赖，提升了可扩展性。Anthropic的Claude使用这种方法。
03.偏见与公平性
a.偏见来源
模型偏见来自训练数据、模型架构、优化目标等。训练数据反映了社会偏见，模型会学习并放大这些偏见。常见偏见包括：性别偏见、种族偏见、年龄偏见等。偏见导致不公平的输出，损害特定群体。
b.偏见检测
偏见检测使用探测数据集测试模型。例如，测试模型对不同性别、种族的描述是否一致。使用统计指标量化偏见程度。偏见检测帮助识别问题，但不能完全消除偏见。需要结合其他方法。
c.去偏见技术
去偏见技术包括：数据重采样、对抗训练、公平性约束等。数据重采样平衡不同群体的表示。对抗训练使得模型无法区分敏感属性。公平性约束在优化中加入公平性目标。去偏见是复杂的，需要权衡性能和公平性。
d.透明度与问责
透明度要求公开模型的能力、局限、偏见等。问责机制确保模型的负责任使用。包括：模型卡片（记录模型信息）、影响评估、审计机制等。透明度和问责是建立信任的基础。
04.隐私与数据安全
a.数据隐私
训练数据可能包含敏感信息，如个人身份、医疗记录等。模型可能记忆并泄露训练数据。隐私保护技术包括：差分隐私、联邦学习、数据脱敏等。差分隐私在训练中加入噪声，保护个体隐私。联邦学习在本地训练，不共享原始数据。
b.模型安全
模型本身需要保护，防止被窃取或篡改。模型水印技术在模型中嵌入标识，用于版权保护。模型加密保护模型参数不被访问。安全推理确保推理过程不泄露信息。模型安全在商业应用中很重要。
c.提示注入攻击
提示注入攻击通过精心设计的输入操纵模型行为。攻击者可能诱导模型忽略指令、泄露信息、执行恶意操作等。防御方法包括：输入验证、提示隔离、输出过滤等。提示注入是新兴的安全威胁，需要持续关注。
d.合规性
大模型应用需要遵守法律法规，如GDPR、CCPA等。合规要求包括：数据保护、用户同意、透明度、可解释性等。不同地区有不同的法规，需要针对性处理。合规是商业化的必要条件，违规可能导致严重后果。
7 前沿技术与展望
7.1 多模态大模型
01.视觉-语言模型
a.CLIP架构
a.对比学习原理
CLIP（Contrastive Language-Image Pre-training）通过对比学习将图像和文本映射到共同的嵌入空间。训练时，匹配的图像-文本对相似度最大化，不匹配的对相似度最小化。CLIP使用双编码器架构，图像编码器和文本编码器独立处理各自模态。这种设计使得CLIP能够进行零样本图像分类、图像检索等任务。
b.CLIP实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
class CLIPModel(nn.Module):
"""CLIP模型实现"""
def __init__(self, image_encoder, text_encoder,
embed_dim=512, temperature=0.07):
super(CLIPModel, self).__init__()
self.image_encoder = image_encoder
self.text_encoder = text_encoder
self.embed_dim = embed_dim
# 投影层
self.image_projection = nn.Linear(
image_encoder.output_dim, embed_dim
)
self.text_projection = nn.Linear(
text_encoder.output_dim, embed_dim
)
# 可学习的温度参数
self.logit_scale = nn.Parameter(torch.ones([]) * torch.log(torch.tensor(1 / temperature)))
def encode_image(self, images):
"""
编码图像
Args:
images: [batch_size, channels, height, width]
Returns:
image_features: [batch_size, embed_dim]
"""
image_features = self.image_encoder(images)
image_features = self.image_projection(image_features)
# L2归一化
image_features = F.normalize(image_features, dim=-1)
return image_features
def encode_text(self, text_tokens):
"""
编码文本
Args:
text_tokens: [batch_size, seq_len]
Returns:
text_features: [batch_size, embed_dim]
"""
text_features = self.text_encoder(text_tokens)
text_features = self.text_projection(text_features)
# L2归一化
text_features = F.normalize(text_features, dim=-1)
return text_features
def forward(self, images, text_tokens):
"""
前向传播
Args:
images: 图像批次
text_tokens: 文本批次
Returns:
logits_per_image: 图像到文本的相似度
logits_per_text: 文本到图像的相似度
"""
# 编码
image_features = self.encode_image(images)
text_features = self.encode_text(text_tokens)
# 计算相似度矩阵
logit_scale = self.logit_scale.exp()
logits_per_image = logit_scale * image_features @ text_features.t()
logits_per_text = logits_per_image.t()
return logits_per_image, logits_per_text
def compute_loss(self, logits_per_image, logits_per_text):
"""
计算对比学习损失
Args:
logits_per_image: [batch_size, batch_size]
logits_per_text: [batch_size, batch_size]
Returns:
loss: 对比损失
"""
batch_size = logits_per_image.size(0)
labels = torch.arange(batch_size, device=logits_per_image.device)
# 对称的交叉熵损失
loss_i = F.cross_entropy(logits_per_image, labels)
loss_t = F.cross_entropy(logits_per_text, labels)
loss = (loss_i + loss_t) / 2
return loss
# 零样本分类
class ZeroShotClassifier:
"""基于CLIP的零样本分类器"""
def __init__(self, clip_model, class_names):
self.clip_model = clip_model
self.class_names = class_names
# 预计算类别文本特征
self.class_features = self._compute_class_features()
def _compute_class_features(self):
"""计算类别的文本特征"""
prompts = [f"a photo of a {name}" for name in self.class_names]
# 这里需要tokenizer，简化示例
# text_tokens = tokenizer(prompts)
# with torch.no_grad():
# class_features = self.clip_model.encode_text(text_tokens)
# return class_features
return None # 简化
def predict(self, image):
"""
预测图像类别
Args:
image: 输入图像
Returns:
prediction: 预测的类别
confidence: 置信度
"""
with torch.no_grad():
image_features = self.clip_model.encode_image(image)
# 计算与所有类别的相似度
similarities = image_features @ self.class_features.t()
probs = F.softmax(similarities, dim=-1)
confidence, pred_idx = probs.max(dim=-1)
prediction = self.class_names[pred_idx.item()]
return prediction, confidence.item()
print("=== CLIP应用示例 ===\n")
print("1. 零样本图像分类:")
print(" - 无需训练，直接分类新类别")
print(" - 使用自然语言描述类别")
print("\n2. 图像-文本检索:")
print(" - 用文本搜索图像")
print(" - 用图像搜索相关文本")
print("\n3. 多模态嵌入:")
print(" - 统一的图像-文本表示空间")
print(" - 支持跨模态任务")
---
b.视觉问答
视觉问答（VQA）要求模型根据图像回答问题。需要理解图像内容和问题语义。现代VQA模型使用视觉-语言预训练，如ViLT、BLIP等。这些模型在大规模图像-文本对上预训练，学习多模态表示。VQA在图像理解、辅助技术等领域有应用。
c.图像描述生成
图像描述生成（Image Captioning）自动生成图像的文本描述。使用编码器-解码器架构，视觉编码器提取图像特征，语言解码器生成描述。注意力机制使得模型关注图像的相关区域。图像描述在内容生成、辅助视障人士等方面有用。
d.文本到图像生成
文本到图像生成根据文本描述生成图像。DALL-E、Stable Diffusion等模型展示了惊人的生成能力。这些模型使用扩散模型或自回归模型，在大规模数据上训练。文本到图像生成在创意设计、内容创作等领域有广泛应用。
02.多模态预训练
a.统一架构设计
a.模态融合策略
多模态模型需要融合不同模态的信息。融合策略包括：早期融合（输入层融合）、晚期融合（决策层融合）、中间融合（特征层融合）。Transformer的自注意力机制天然支持多模态融合，不同模态的token可以相互交互。统一架构简化了模型设计，提升了多模态理解能力。
b.多模态Transformer实现
---
import torch
import torch.nn as nn
class MultiModalTransformer(nn.Module):
"""多模态Transformer"""
def __init__(self, d_model=768, num_heads=12, num_layers=6):
super(MultiModalTransformer, self).__init__()
# 模态特定的嵌入
self.text_embedding = nn.Embedding(50000, d_model)
self.image_projection = nn.Linear(2048, d_model) # 假设图像特征2048维
# 位置编码
self.pos_embedding = nn.Parameter(torch.randn(1, 512, d_model))
# 模态类型嵌入
self.modality_embedding = nn.Embedding(2, d_model) # 0: text, 1: image
# Transformer层
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model,
nhead=num_heads,
dim_feedforward=d_model * 4,
batch_first=True
)
self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
def forward(self, text_tokens=None, image_features=None,
text_mask=None, image_mask=None):
"""
前向传播
Args:
text_tokens: [batch_size, text_len]
image_features: [batch_size, num_patches, feature_dim]
text_mask: 文本掩码
image_mask: 图像掩码
Returns:
output: 多模态表示
"""
embeddings = []
masks = []
# 处理文本
if text_tokens is not None:
text_emb = self.text_embedding(text_tokens)
text_len = text_tokens.size(1)
# 添加模态类型嵌入
text_modality = torch.zeros(text_len, dtype=torch.long,
device=text_tokens.device)
text_emb = text_emb + self.modality_embedding(text_modality)
embeddings.append(text_emb)
if text_mask is not None:
masks.append(text_mask)
# 处理图像
if image_features is not None:
image_emb = self.image_projection(image_features)
image_len = image_features.size(1)
# 添加模态类型嵌入
image_modality = torch.ones(image_len, dtype=torch.long,
device=image_features.device)
image_emb = image_emb + self.modality_embedding(image_modality)
embeddings.append(image_emb)
if image_mask is not None:
masks.append(image_mask)
# 拼接所有模态
combined_emb = torch.cat(embeddings, dim=1)
# 添加位置编码
seq_len = combined_emb.size(1)
combined_emb = combined_emb + self.pos_embedding[:, :seq_len, :]
# 拼接掩码
if masks:
combined_mask = torch.cat(masks, dim=1)
else:
combined_mask = None
# Transformer编码
output = self.transformer(combined_emb, src_key_padding_mask=combined_mask)
return output
# 多模态预训练任务
class MultiModalPretraining:
"""多模态预训练任务"""
@staticmethod
def masked_language_modeling(model, text_tokens, labels):
"""掩码语言建模"""
outputs = model(text_tokens=text_tokens)
# 预测被掩码的token
# loss = compute_mlm_loss(outputs, labels)
return outputs
@staticmethod
def image_text_matching(model, text_tokens, image_features, labels):
"""图像-文本匹配"""
outputs = model(text_tokens=text_tokens,
image_features=image_features)
# 使用[CLS] token进行二分类
cls_output = outputs[:, 0, :]
# logits = classifier(cls_output)
# loss = F.cross_entropy(logits, labels)
return outputs
@staticmethod
def masked_region_modeling(model, text_tokens, image_features,
masked_regions, region_labels):
"""掩码区域建模"""
outputs = model(text_tokens=text_tokens,
image_features=image_features)
# 预测被掩码的图像区域
# loss = compute_mrm_loss(outputs, masked_regions, region_labels)
return outputs
print("多模态预训练任务:")
print("1. MLM (Masked Language Modeling): 预测被掩码的文本")
print("2. ITM (Image-Text Matching): 判断图像和文本是否匹配")
print("3. MRM (Masked Region Modeling): 预测被掩码的图像区域")
print("4. WPA (Word-Patch Alignment): 对齐词和图像patch")
print("\n这些任务帮助模型学习跨模态的对应关系")
---
b.对齐策略
多模态对齐确保不同模态的语义对应。对齐方法包括：对比学习（CLIP）、匹配预测（BERT风格）、生成式对齐（描述生成）等。对齐是多模态学习的核心挑战，直接影响下游任务性能。
c.数据构建
多模态预训练需要大规模的图像-文本对数据。数据来源包括：网页（alt text）、社交媒体、视频字幕等。数据质量影响模型性能，需要过滤噪声和不匹配的对。数据多样性也很重要，覆盖不同领域和风格。
d.评估基准
多模态模型的评估基准包括：VQA、图像描述、视觉推理、跨模态检索等。这些基准测试模型的不同能力。标准化的评估使得模型比较更客观。但现有基准可能不能完全反映实际应用性能。
03.GPT-4V与多模态LLM
a.GPT-4V能力
GPT-4V（GPT-4 with Vision）是OpenAI的多模态大模型，能够理解图像和文本。GPT-4V可以描述图像、回答视觉问题、分析图表、阅读文档等。它展示了强大的视觉理解和推理能力。GPT-4V的出现标志着多模态LLM的成熟。
b.Flamingo架构
Flamingo是DeepMind的多模态模型，使用少样本学习。Flamingo在冻结的语言模型中插入视觉特征，通过交叉注意力融合。这种设计使得Flamingo能够快速适应新的视觉任务。Flamingo在多个视觉-语言基准上取得了最佳性能。
c.LLaVA与开源方案
LLaVA（Large Language and Vision Assistant）是开源的多模态对话模型。LLaVA使用CLIP视觉编码器和Vicuna语言模型，通过指令微调训练。LLaVA的开源推动了多模态LLM的研究和应用。社区贡献了许多改进和变体。
d.应用场景
多模态LLM在多个领域有应用：医疗影像分析、文档理解、教育辅助、创意设计等。它们能够处理复杂的多模态任务，如从图表中提取数据、理解meme、分析艺术作品等。多模态LLM是通向通用人工智能的重要一步。
04.音频与视频理解
a.语音识别与合成
现代语音识别使用端到端模型，如Whisper。Whisper在大规模多语言数据上训练，达到了接近人类的识别准确率。语音合成（TTS）也取得了巨大进步，生成的语音自然流畅。语音技术在语音助手、字幕生成等领域广泛应用。
b.视频理解
视频理解需要处理时序信息和多模态信息。任务包括：动作识别、视频描述、视频问答等。视频Transformer使用时空注意力建模视频。视频理解在监控、内容审核、视频编辑等领域有用。
c.音频-文本模型
音频-文本模型将音频和文本映射到共同空间。可以用于音频检索、音频描述生成等。AudioCLIP等模型扩展了CLIP到音频领域。音频-文本模型在音乐推荐、声音事件检测等场景有应用。
d.多模态融合
真实世界的信息通常是多模态的。融合视觉、语音、文本等多种模态可以提供更全面的理解。多模态融合在视频理解、人机交互、机器人等领域至关重要。未来的AI系统将是多模态的，能够像人类一样感知和理解世界。
7.2 长文本建模
01.长文本挑战
a.注意力复杂度
标准Transformer的注意力复杂度是O(n²)，序列长度加倍，计算量增加4倍。这限制了可处理的最大长度，通常在2K-8K tokens。长文本任务如文档理解、书籍分析需要更长的上下文。降低注意力复杂度是长文本建模的核心挑战。
b.内存限制
长序列的KV缓存占用大量内存。例如，处理32K tokens的序列，KV缓存可能需要数GB内存。内存限制了batch size和序列长度。需要优化内存使用，如分块处理、稀疏注意力等。
c.位置编码外推
训练时的位置编码长度有限，推理时处理更长序列可能失效。位置编码的外推能力影响长文本性能。RoPE、ALiBi等方法提升了外推能力，但仍有限制。
d.长距离依赖
长文本中的信息可能相距很远，模型需要捕捉长距离依赖。标准注意力在长距离上可能退化。需要设计机制保持长距离信息流动。
02.高效注意力机制
a.稀疏注意力
a.稀疏模式设计
稀疏注意力只计算部分位置对的注意力，降低复杂度到O(n√n)或O(n log n)。常见模式包括：局部窗口、步长、全局token等。Longformer使用滑动窗口+全局注意力，BigBird使用随机+窗口+全局。稀疏注意力在保持性能的同时大幅降低计算量。
b.稀疏注意力实现
---
import torch
import torch.nn as nn
import math
class SparseAttention(nn.Module):
"""稀疏注意力实现"""
def __init__(self, d_model, num_heads, window_size=256,
num_global_tokens=64):
super(SparseAttention, self).__init__()
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
self.window_size = window_size
self.num_global_tokens = num_global_tokens
self.q_proj = nn.Linear(d_model, d_model)
self.k_proj = nn.Linear(d_model, d_model)
self.v_proj = nn.Linear(d_model, d_model)
self.o_proj = nn.Linear(d_model, d_model)
def create_sparse_mask(self, seq_len, device):
"""
创建稀疏注意力掩码
Args:
seq_len: 序列长度
device: 设备
Returns:
mask: 稀疏掩码 [seq_len, seq_len]
"""
mask = torch.zeros(seq_len, seq_len, device=device)
# 1. 局部窗口注意力
for i in range(seq_len):
start = max(0, i - self.window_size // 2)
end = min(seq_len, i + self.window_size // 2 + 1)
mask[i, start:end] = 1
# 2. 全局token注意力（前num_global_tokens个token）
mask[:, :self.num_global_tokens] = 1
mask[:self.num_global_tokens, :] = 1
return mask
def forward(self, x):
"""
前向传播
Args:
x: [batch_size, seq_len, d_model]
Returns:
output: [batch_size, seq_len, d_model]
"""
batch_size, seq_len, _ = x.size()
# 投影Q, K, V
Q = self.q_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
K = self.k_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
V = self.v_proj(x).view(batch_size, seq_len, self.num_heads, self.d_k)
Q = Q.transpose(1, 2)
K = K.transpose(1, 2)
V = V.transpose(1, 2)
# 创建稀疏掩码
sparse_mask = self.create_sparse_mask(seq_len, x.device)
sparse_mask = sparse_mask.unsqueeze(0).unsqueeze(0)
# 计算注意力
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
scores = scores.masked_fill(sparse_mask == 0, -1e9)
attn_weights = torch.softmax(scores, dim=-1)
context = torch.matmul(attn_weights, V)
# 合并头
context = context.transpose(1, 2).contiguous()
context = context.view(batch_size, seq_len, self.d_model)
output = self.o_proj(context)
return output
# 复杂度对比
seq_len = 16384
window_size = 512
num_global = 64
# 标准注意力
standard_ops = seq_len * seq_len
# 稀疏注意力
local_ops = seq_len * window_size
global_ops = seq_len * num_global * 2
sparse_ops = local_ops + global_ops
print(f"序列长度: {seq_len}")
print(f"标准注意力操作数: {standard_ops:,}")
print(f"稀疏注意力操作数: {sparse_ops:,}")
print(f"加速比: {standard_ops / sparse_ops:.2f}x")
print(f"内存节省: {(1 - sparse_ops/standard_ops)*100:.1f}%")
---
b.线性注意力
线性注意力通过核技巧将复杂度降低到O(n)。Performer使用随机特征近似softmax，Linformer使用低秩投影。线性注意力理论上很吸引人，但实践中性能通常不如标准注意力。适用于对性能要求不高但需要处理超长序列的场景。
c.Flash Attention
Flash Attention通过优化内存访问模式加速注意力计算。它将注意力计算分块，减少HBM访问，充分利用SRAM。Flash Attention在数学上等价于标准注意力，但速度快2-4倍。Flash Attention 2进一步优化，成为长文本建模的标准选择。
d.分层注意力
分层注意力将序列分成多个层次，底层处理局部信息，高层处理全局信息。类似于CNN的感受野逐层扩大。分层注意力在保持全局建模能力的同时降低复杂度。适合有层次结构的文本，如文档、书籍等。
03.上下文扩展技术
a.位置插值
a.插值方法
位置插值通过调整位置编码的频率，使得模型能够处理更长的序列。例如，将训练时2K长度的位置编码插值到8K。插值保持了位置编码的相对关系，提升了外推能力。但插值可能改变位置编码的语义，需要微调适应。
b.位置插值实现
---
import torch
import torch.nn as nn
import math
class PositionInterpolation:
"""位置编码插值"""
@staticmethod
def interpolate_rope(original_max_len, new_max_len, d_model):
"""
RoPE位置编码插值
Args:
original_max_len: 原始最大长度
new_max_len: 新的最大长度
d_model: 模型维度
Returns:
interpolated_freqs: 插值后的频率
"""
# 原始频率
base = 10000
inv_freq = 1.0 / (base ** (torch.arange(0, d_model, 2).float() / d_model))
# 计算缩放因子
scale = new_max_len / original_max_len
# 插值：降低频率
interpolated_freqs = inv_freq / scale
return interpolated_freqs
@staticmethod
def apply_rotary_embedding(x, freqs):
"""
应用旋转位置编码
Args:
x: [batch, seq_len, d_model]
freqs: 频率
Returns:
x_rotated: 应用RoPE后的张量
"""
seq_len = x.size(1)
# 生成位置
positions = torch.arange(seq_len, device=x.device).float()
# 计算角度
angles = positions.unsqueeze(-1) * freqs.unsqueeze(0)
# 应用旋转
cos = torch.cos(angles)
sin = torch.sin(angles)
# 分离实部和虚部
x_real = x[..., ::2]
x_imag = x[..., 1::2]
# 旋转
x_rotated_real = x_real * cos - x_imag * sin
x_rotated_imag = x_real * sin + x_imag * cos
# 合并
x_rotated = torch.stack([x_rotated_real, x_rotated_imag], dim=-1)
x_rotated = x_rotated.flatten(-2)
return x_rotated
# 示例：从2K扩展到8K
original_max_len = 2048
new_max_len = 8192
d_model = 128
pi = PositionInterpolation()
interpolated_freqs = pi.interpolate_rope(original_max_len, new_max_len, d_model)
print(f"原始最大长度: {original_max_len}")
print(f"扩展后长度: {new_max_len}")
print(f"扩展倍数: {new_max_len / original_max_len:.1f}x")
print(f"\n位置插值使得模型能够处理更长序列，")
print(f"通常需要少量微调以适应新的长度")
---
b.ALiBi位置偏置
ALiBi（Attention with Linear Biases）不使用位置编码，而是在注意力分数上加入线性偏置。偏置与位置距离成正比，距离越远偏置越大。ALiBi具有良好的外推能力，可以处理训练时未见过的长度。ALiBi在多个长文本任务上表现出色。
c.滑动窗口
滑动窗口将长文本分成多个重叠的窗口，分别处理。窗口之间通过重叠部分传递信息。滑动窗口简单有效，但可能丢失跨窗口的长距离依赖。适合不需要全局理解的任务，如文本分类、信息抽取等。
d.检索增强
对于超长文本，可以先检索相关片段，再进行处理。检索增强避免了处理整个文本的开销。适合问答、摘要等任务，只需要部分信息。但检索质量影响最终性能，需要高质量的检索系统。
04.长文本应用
a.文档理解
长文本模型在文档理解任务上有优势。可以处理完整的报告、论文、合同等。任务包括：文档问答、信息抽取、文档摘要等。长文本模型提升了文档处理的自动化程度，在法律、金融、医疗等领域有应用。
b.代码理解
代码文件通常很长，需要长上下文理解。长文本模型可以理解整个代码库，进行代码补全、bug检测、代码审查等。GitHub Copilot等工具使用长上下文模型，提升了开发效率。
c.对话系统
长上下文使得对话系统能够记住更多历史信息。多轮对话中，模型可以引用很早之前的内容。这提升了对话的连贯性和个性化。长上下文对话系统在客服、教育等领域有用。
d.书籍分析
长文本模型可以分析整本书，进行摘要、主题提取、角色分析等。这在文学研究、内容推荐等领域有应用。但处理整本书仍然具有挑战性，需要数十万tokens的上下文。
7.3 高效训练技术
01.混合专家模型
a.MoE架构
a.基本原理
混合专家（Mixture of Experts, MoE）使用多个专家网络，每个输入只激活部分专家。路由器决定哪些专家处理哪些输入。MoE大幅增加模型容量，但保持计算量不变。Mixtral、Switch Transformer等模型使用MoE，在性能和效率之间取得平衡。
b.MoE实现
---
import torch
import torch.nn as nn
import torch.nn.functional as F
class MoELayer(nn.Module):
"""混合专家层"""
def __init__(self, d_model, num_experts=8, expert_capacity=None,
top_k=2):
super(MoELayer, self).__init__()
self.d_model = d_model
self.num_experts = num_experts
self.top_k = top_k
# 路由器
self.router = nn.Linear(d_model, num_experts)
# 专家网络
self.experts = nn.ModuleList([
nn.Sequential(
nn.Linear(d_model, d_model * 4),
nn.ReLU(),
nn.Linear(d_model * 4, d_model)
)
for _ in range(num_experts)
])
def forward(self, x):
"""
前向传播
Args:
x: [batch_size, seq_len, d_model]
Returns:
output: [batch_size, seq_len, d_model]
load_balance_loss: 负载均衡损失
"""
batch_size, seq_len, d_model = x.size()
# 展平
x_flat = x.view(-1, d_model) # [batch*seq_len, d_model]
# 路由决策
router_logits = self.router(x_flat) # [batch*seq_len, num_experts]
router_probs = F.softmax(router_logits, dim=-1)
# 选择top-k专家
top_k_probs, top_k_indices = torch.topk(router_probs, self.top_k, dim=-1)
top_k_probs = top_k_probs / top_k_probs.sum(dim=-1, keepdim=True)
# 初始化输出
output = torch.zeros_like(x_flat)
# 每个专家处理分配给它的token
for i in range(self.num_experts):
# 找到分配给专家i的token
expert_mask = (top_k_indices == i).any(dim=-1)
if expert_mask.any():
expert_input = x_flat[expert_mask]
expert_output = self.experts[i](expert_input)
# 获取权重
expert_weights = top_k_probs[expert_mask]
expert_weights = expert_weights[
(top_k_indices[expert_mask] == i).nonzero(as_tuple=True)
]
# 加权输出
output[expert_mask] += expert_output * expert_weights.unsqueeze(-1)
# 恢复形状
output = output.view(batch_size, seq_len, d_model)
# 计算负载均衡损失
expert_counts = torch.zeros(self.num_experts, device=x.device)
for i in range(self.num_experts):
expert_counts[i] = (top_k_indices == i).sum().float()
# 鼓励均匀分配
load_balance_loss = expert_counts.std() / expert_counts.mean()
return output, load_balance_loss
# 参数效率对比
d_model = 4096
num_experts = 8
top_k = 2
# 标准FFN
standard_params = d_model * (d_model * 4) * 2
# MoE FFN
moe_params = (
d_model * num_experts + # 路由器
num_experts * d_model * (d_model * 4) * 2 # 专家
)
# 激活参数（每次只用top_k个专家）
active_params = (
d_model * num_experts +
top_k * d_model * (d_model * 4) * 2
)
print(f"标准FFN参数: {standard_params:,}")
print(f"MoE总参数: {moe_params:,}")
print(f"MoE激活参数: {active_params:,}")
print(f"参数增加: {moe_params / standard_params:.1f}x")
print(f"计算增加: {active_params / standard_params:.1f}x")
print(f"\nMoE用{top_k}/{num_experts}的计算获得{num_experts}倍的容量")
---
b.负载均衡
MoE的挑战是负载均衡，避免所有输入都路由到少数专家。负载均衡损失鼓励路由器均匀分配。辅助损失、容量限制等技术帮助平衡负载。负载不均会导致部分专家未充分训练，降低模型性能。
c.专家并行
MoE的专家可以分布在不同设备上，实现专家并行。每个设备负责部分专家，通过通信交换数据。专家并行使得训练超大MoE模型成为可能。但通信开销可能成为瓶颈，需要优化。
d.稀疏激活
MoE是稀疏激活的例子，每次只激活部分参数。稀疏激活提供了更好的参数效率。其他稀疏激活方法包括：动态网络、条件计算等。稀疏激活是扩展模型规模的重要方向。
02.梯度检查点
a.内存优化
梯度检查点（Gradient Checkpointing）通过重计算减少内存占用。前向传播时不保存所有中间激活，反向传播时重新计算需要的激活。这将内存占用从O(n)降低到O(√n)，但增加了约33%的计算时间。梯度检查点使得在有限内存下训练更大模型成为可能。
b.选择性检查点
不是所有层都需要检查点。可以选择性地对计算密集但内存占用大的层使用检查点。例如，对注意力层使用检查点，对FFN层不使用。选择性检查点在内存和计算之间取得更好的平衡。
c.自动检查点
自动检查点系统根据内存预算自动决定哪些层使用检查点。PyTorch、TensorFlow等框架提供了自动检查点功能。自动检查点简化了模型开发，用户无需手动管理内存。
d.实践建议
梯度检查点适合GPU内存有限的场景。在训练大模型时，梯度检查点几乎是必需的。但对于小模型或内存充足时，不使用检查点更快。需要根据具体情况权衡内存和速度。
03.ZeRO优化
a.ZeRO原理
ZeRO（Zero Redundancy Optimizer）消除数据并行中的冗余。标准数据并行在每个设备上保存完整的模型、梯度和优化器状态。ZeRO将这些状态分片到不同设备，大幅减少内存占用。ZeRO使得在相同硬件上训练更大的模型。
b.ZeRO阶段
ZeRO有三个阶段。ZeRO-1分片优化器状态，节省4倍内存。ZeRO-2分片梯度，节省8倍内存。ZeRO-3分片模型参数，节省更多内存但增加通信开销。可以根据需求选择不同阶段。
c.ZeRO-Offload
ZeRO-Offload将部分状态offload到CPU内存或NVMe。这进一步扩展了可训练的模型规模。Offload增加了数据传输开销，但在GPU内存极度有限时很有用。适合单机多卡或小集群训练大模型。
d.DeepSpeed集成
DeepSpeed是微软开源的训练框架，集成了ZeRO等优化技术。DeepSpeed简化了大模型训练，提供了易用的API。许多开源模型使用DeepSpeed训练，如BLOOM、GPT-NeoX等。DeepSpeed是训练大模型的重要工具。
04.其他训练优化
a.激活重计算
激活重计算在反向传播时重新计算激活，而不是保存。这是梯度检查点的泛化。可以选择性地重计算部分激活，平衡内存和计算。激活重计算在内存受限时特别有用。
b.CPU Offloading
将不常用的数据offload到CPU内存，需要时再传回GPU。适合优化器状态、梯度等。Offloading减少GPU内存压力，但增加数据传输时间。需要高速的CPU-GPU互联，如NVLink、PCIe 4.0等。
c.流水线并行优化
流水线并行将模型分成多个阶段，在不同设备上流水线执行。优化包括：微批次调度、梯度累积、bubble最小化等。GPipe、PipeDream等系统实现了高效的流水线并行。流水线并行适合层数很多的模型。
d.通信优化
分布式训练的通信开销可能很大。优化包括：梯度压缩、通信与计算重叠、拓扑感知调度等。高效的通信库如NCCL对性能至关重要。通信优化在大规模训练中不可忽视。
7.4 模型可解释性
01.注意力可视化
a.注意力权重分析
注意力权重显示了模型关注输入的哪些部分。可视化注意力权重有助于理解模型行为。不同的头可能关注不同的语言现象，如语法、语义等。注意力可视化是解释Transformer的常用方法。
b.BertViz工具
BertViz是可视化BERT注意力的工具，支持多种视图。模型视图显示所有层和头的注意力，神经元视图显示特定神经元的激活。BertViz帮助研究人员理解模型内部机制。类似工具还有exBERT、Attention Flow等。
c.注意力模式
研究发现Transformer的注意力头学习了不同的模式。有些头关注相邻词，有些关注句法依赖，有些关注语义相关词。这些模式在不同任务和模型中有一定的共性。理解注意力模式有助于改进模型设计。
d.局限性
注意力权重不能完全解释模型决策。高注意力权重不一定意味着高重要性。注意力只是信息流动的一部分，FFN层也起重要作用。需要结合其他方法全面理解模型。
02.特征归因方法
a.梯度方法
a.基本原理
梯度方法通过计算输出对输入的梯度来衡量重要性。梯度大的输入对输出影响大。常见方法包括：Saliency Maps、Integrated Gradients、SmoothGrad等。梯度方法计算简单，但可能不稳定。
b.归因实现
---
import torch
import torch.nn as nn
class FeatureAttribution:
"""特征归因方法"""
def __init__(self, model):
self.model = model
self.model.eval()
def saliency_map(self, input_ids, target_class):
"""
计算显著性图
Args:
input_ids: 输入token IDs
target_class: 目标类别
Returns:
saliency: 每个token的重要性分数
"""
input_ids.requires_grad = True
# 前向传播
outputs = self.model(input_ids)
logits = outputs.logits
# 计算目标类别的分数
target_score = logits[0, target_class]
# 反向传播
target_score.backward()
# 梯度的绝对值作为重要性
saliency = input_ids.grad.abs().squeeze()
return saliency
def integrated_gradients(self, input_ids, target_class,
baseline=None, steps=50):
"""
积分梯度方法
Args:
input_ids: 输入token IDs
target_class: 目标类别
baseline: 基线输入（通常是全零或padding）
steps: 积分步数
Returns:
attributions: 归因分数
"""
if baseline is None:
baseline = torch.zeros_like(input_ids)
# 生成插值路径
alphas = torch.linspace(0, 1, steps)
gradients = []
for alpha in alphas:
# 插值输入
interpolated = baseline + alpha * (input_ids - baseline)
interpolated.requires_grad = True
# 前向传播
outputs = self.model(interpolated)
target_score = outputs.logits[0, target_class]
# 计算梯度
target_score.backward()
gradients.append(interpolated.grad)
# 积分（梯度的平均）
avg_gradients = torch.stack(gradients).mean(dim=0)
# 归因 = (输入 - 基线) * 平均梯度
attributions = (input_ids - baseline) * avg_gradients
return attributions.squeeze()
def attention_rollout(self, attention_weights):
"""
注意力汇总
Args:
attention_weights: 所有层的注意力权重列表
Returns:
rollout: 汇总的注意力
"""
# 从第一层开始累积注意力
rollout = attention_weights[0]
for attn in attention_weights[1:]:
# 矩阵乘法累积注意力流
rollout = torch.matmul(attn, rollout)
return rollout
print("特征归因方法:")
print("1. Saliency Maps: 使用梯度衡量重要性")
print("2. Integrated Gradients: 沿路径积分梯度")
print("3. Attention Rollout: 累积多层注意力")
print("4. Layer-wise Relevance Propagation: 反向传播相关性")
print("\n这些方法帮助理解模型的决策依据")
---
b.LIME与SHAP
LIME（Local Interpretable Model-agnostic Explanations）通过局部线性模型近似复杂模型。SHAP（SHapley Additive exPlanations）基于博弈论的Shapley值。这些方法与模型无关，适用于任何黑盒模型。但计算开销较大，适合解释单个预测。
c.反事实解释
反事实解释寻找最小的输入改变，使得输出改变。例如，"如果将'not good'改为'good'，预测会变为正面"。反事实解释提供了可操作的洞察，用户可以理解如何改变输入来改变输出。
d.概念激活向量
概念激活向量（CAV）测试模型是否学习了特定概念。通过比较有无该概念的样本，计算概念的方向向量。CAV可以测试模型的偏见、学习的特征等。这是高层次的解释方法。
03.探测任务
a.语言学探测
探测任务（Probing Tasks）测试模型表示中编码了哪些语言学信息。例如，训练分类器预测词性、句法依赖等。如果分类器准确，说明表示包含该信息。探测任务揭示了模型学习的语言知识。
b.层次分析
不同层的表示编码不同层次的信息。底层通常编码词法信息，中层编码句法信息，高层编码语义信息。层次分析帮助理解模型的表示学习过程。可以指导模型设计和微调策略。
c.上下文化程度
测试表示的上下文化程度，即同一个词在不同上下文中的表示差异。BERT等模型的表示高度上下文化，而Word2Vec等静态嵌入不是。上下文化是现代NLP模型的重要特性。
d.跨语言探测
多语言模型在不同语言上的表示是否对齐？探测任务可以测试跨语言的对齐程度。这对理解多语言模型的工作机制很重要。
04.可解释性的应用
a.模型调试
可解释性帮助发现模型的错误模式。例如，模型可能过度依赖某些虚假相关特征。通过分析归因，可以识别这些问题并改进模型。可解释性是模型开发的重要工具。
b.偏见检测
可解释性方法可以检测模型的偏见。例如，分析模型对不同性别、种族的词的注意力。发现偏见后，可以通过去偏见技术改进。可解释性是公平AI的基础。
c.用户信任
可解释的模型更容易获得用户信任。在医疗、金融等高风险领域，可解释性是部署的前提。用户需要理解模型的决策依据，才能信任和使用。
d.监管合规
某些地区的法规要求AI系统可解释。例如，GDPR的"解释权"要求系统能够解释自动化决策。可解释性是满足监管要求的必要条件。
7.5 未来发展方向
01.通用人工智能
a.AGI的定义
通用人工智能（AGI）指能够在各种任务上达到或超越人类水平的AI系统。AGI不仅能完成特定任务，还能学习新任务、迁移知识、推理规划。当前的大语言模型展示了通向AGI的潜力，但距离真正的AGI还有距离。AGI是AI研究的终极目标。
b.当前进展
大语言模型在多个方面接近AGI。它们能够理解和生成自然语言、进行推理、学习新任务（上下文学习）、使用工具等。GPT-4等模型在某些任务上已经达到人类水平。但模型仍有局限，如缺乏真正的理解、容易产生幻觉、无法持续学习等。
c.技术挑战
实现AGI面临多个挑战。模型需要更强的推理能力、常识知识、因果理解等。需要解决幻觉、偏见、安全性等问题。还需要更高效的学习方法，减少对大规模数据和计算的依赖。这些挑战需要理论和工程的突破。
d.伦理考量
AGI带来深刻的伦理问题。如何确保AGI与人类价值观对齐？如何防止AGI被滥用？AGI对就业、社会结构的影响如何？这些问题需要技术、政策、哲学等多学科的共同努力。负责任地开发AGI至关重要。
02.多模态融合
a.统一表示学习
未来的AI系统将无缝融合视觉、语言、音频等多种模态。统一表示学习将不同模态映射到共同空间，实现跨模态理解和生成。这需要新的架构设计和训练方法。统一表示是多模态AI的基础。
b.具身智能
具身智能（Embodied AI）将AI与物理世界连接。机器人需要理解视觉、触觉、本体感觉等多模态信息，并在物理世界中行动。具身智能是AGI的重要组成部分，因为智能源于与环境的交互。
c.世界模型
世界模型是对环境的内部表示，能够预测行动的结果。世界模型使得AI能够规划、推理、想象。构建准确的世界模型是具身智能和AGI的关键。当前的研究探索如何从多模态数据中学习世界模型。
d.跨模态生成
未来的AI将能够在不同模态间自由转换。例如，从文本生成图像、视频，从图像生成音乐，从视频生成文本描述。跨模态生成在创意产业、内容创作等领域有巨大潜力。
03.持续学习与适应
a.终身学习
当前的模型在训练后是静态的，无法持续学习新知识。终身学习（Lifelong Learning）使得模型能够不断学习，同时保留旧知识。这需要解决灾难性遗忘问题。终身学习是智能系统的重要特性。
b.在线学习
在线学习允许模型从用户交互中实时学习。这使得模型能够个性化、适应用户偏好。但在线学习面临隐私、安全等挑战。需要设计机制确保学习的安全性和可控性。
c.少样本适应
未来的模型将能够从极少样本中快速学习新任务。元学习、提示学习等方法展示了这种潜力。少样本适应使得AI能够快速部署到新领域，降低数据需求。
d.知识更新
模型的知识会过时，需要机制更新知识。知识编辑技术允许修改模型的特定知识，而不影响其他部分。检索增强生成提供了另一种方案，通过外部知识库保持知识最新。
04.效率与可持续性
a.绿色AI
训练大模型消耗大量能源，产生碳排放。绿色AI关注AI的环境影响，追求更高效的算法和硬件。包括：模型压缩、高效架构、可再生能源等。绿色AI是可持续发展的要求。
b.边缘AI
将AI部署到边缘设备（手机、IoT）面临资源限制。边缘AI需要极致的效率优化。技术包括：量化、剪枝、知识蒸馏、神经架构搜索等。边缘AI使得AI能力无处不在，同时保护隐私。
c.神经架构搜索
神经架构搜索（NAS）自动设计高效的模型架构。NAS可以针对特定硬件和任务优化架构。这减少了人工设计的成本，可能发现人类难以想到的架构。NAS是提升效率的重要方向。
d.硬件协同设计
AI算法和硬件协同设计可以大幅提升效率。专用AI芯片（如TPU、NPU）针对AI工作负载优化。新型计算范式（如神经形态计算、光计算）探索更高效的计算方式。硬件创新是AI发展的重要推动力。
05.社会影响与治理
a.就业影响
AI自动化可能取代部分工作，同时创造新工作。如何管理这种转变是重要的社会问题。需要教育、培训、社会保障等政策配合。AI应该增强人类能力，而不是简单替代。
b.信息生态
AI生成内容可能影响信息生态。深度伪造、虚假信息传播是严重威胁。需要技术（检测、水印）和政策（监管、教育）共同应对。维护健康的信息生态是社会责任。
c.数字鸿沟
AI技术可能加剧数字鸿沟，使得有资源的群体受益更多。确保AI的普惠性是重要目标。开源模型、云服务、教育普及等有助于缩小鸿沟。AI应该服务全人类。
d.全球治理
AI是全球性技术，需要国际合作治理。包括：标准制定、伦理规范、安全协议等。不同国家和文化对AI有不同看法，需要对话和协调。全球治理确保AI的负责任发展。
06.研究前沿
a.神经符号AI
神经符号AI结合神经网络和符号推理。神经网络擅长感知和模式识别，符号系统擅长逻辑推理和知识表示。结合两者可以获得更强的智能。神经符号AI是重要的研究方向。
b.因果推理
当前的AI主要学习相关性，而非因果关系。因果推理使得AI能够理解"为什么"，进行反事实推理、干预分析等。因果AI在科学发现、决策支持等领域有重要应用。
c.自监督学习
自监督学习从无标注数据中学习，是预训练的基础。未来的自监督方法将更高效、更通用。对比学习、掩码建模等方法不断发展。自监督学习减少对标注数据的依赖。
d.元学习
元学习（Learning to Learn）使得模型能够快速学习新任务。通过学习学习算法本身，模型获得更强的适应能力。元学习在少样本学习、快速适应等场景有用。是通向AGI的重要路径。
07.展望
a.技术融合
未来的AI将融合多种技术：深度学习、强化学习、符号推理、进化算法等。单一技术难以实现AGI，需要多种方法的协同。技术融合是AI发展的趋势。
b.人机协作
AI不是要替代人类，而是增强人类能力。人机协作系统结合人类的创造力和AI的计算能力。在创意、决策、研究等领域，人机协作将产生巨大价值。
c.开放生态
开源、开放数据、开放标准推动AI民主化。开放生态使得更多人能够参与AI研发和应用。社区协作加速创新。开放是AI健康发展的基础。
d.负责任创新
AI的发展必须是负责任的。技术创新应该考虑伦理、安全、公平等因素。需要建立评估、审计、问责机制。负责任创新确保AI造福人类。