自然语言处理中的词向量与Transformer技术解析

1. 从文字到数字：自然语言处理的表示难题

计算机要理解人类语言，首先需要解决一个根本问题：如何将文字转化为数字。这就像我们要让一个只会说二进制语言的外星人理解"我爱你"这句话，必须先把这三个字翻译成它能处理的数字信号。

1.1 One-hot编码的困境

最直观的方法是One-hot编码。假设我们的词表包含["我", "爱", "你", "猫", "狗"]五个词：

• "我" → [1,0,0,0,0]
• "爱" → [0,1,0,0,0]
• "你" → [0,0,1,0,0]

这种表示方法存在两个致命缺陷：

1. 维度灾难：词表每增加一个词，向量维度就增加一维。实际应用中词表通常包含数万甚至数十万词，导致向量极其稀疏。
2. 语义缺失：所有词向量都是正交的，"猫"和"狗"的相似度与"猫"和"爱"的相似度完全相同，无法反映语义关系。

实际案例：在IMDb影评数据集中，使用One-hot编码处理3万词的词表时，每条评论的向量中99.9%以上的元素都是0，既浪费存储空间，又无法捕捉"excellent"和"outstanding"这类近义词的关系。

1.2 Word Embedding的革命

Word Embedding通过将高维稀疏的One-hot向量映射到低维连续空间（通常50-300维），解决了上述问题。其核心特性是：

• 语义保留：语义相似的词在向量空间中距离相近
• 维度压缩：将数万维的稀疏向量压缩到数百维的稠密向量

技术实现上，Word Embedding是一个可训练的查找表矩阵W ∈ R^{V×d}，其中V是词表大小，d是嵌入维度。例如：

• 词表大小V=10000
• 嵌入维度d=300
• 每个词通过矩阵查找得到300维的稠密向量

python复制# PyTorch实现示例
embedding = nn.Embedding(num_embeddings=10000, embedding_dim=300)
word_idx = torch.tensor([42])  # "猫"的索引
cat_vector = embedding(word_idx)  # 300维向量

有趣的是，这种表示还能捕捉语义关系：

code复制vec("国王") - vec("男") + vec("女") ≈ vec("女王")
vec("巴黎") - vec("法国") + vec("德国") ≈ vec("柏林")

2. 序列建模：从RNN到Transformer的进化

2.1 RNN的时空困境

循环神经网络(RNN)通过引入隐状态h_t处理序列数据：

code复制h_t = f(W_{hh}h_{t-1} + W_{xh}x_t)

虽然理论上可以处理任意长序列，但实际存在两大瓶颈：

1. 梯度消失：反向传播时梯度随时间呈指数衰减，难以学习长期依赖
2. 串行计算：必须按时间步顺序计算，无法利用GPU并行优势

我在早期项目中曾用RNN处理新闻文本分类，当文章超过500词时，模型对开头部分的记忆几乎完全丢失，准确率下降15%。

2.2 LSTM的记忆宫殿

长短期记忆网络(LSTM)通过精巧的门控机制解决了长期记忆问题：

python复制# LSTM核心计算单元
forget_gate = σ(W_f·[h_{t-1}, x_t] + b_f)
input_gate = σ(W_i·[h_{t-1}, x_t] + b_i)
output_gate = σ(W_o·[h_{t-1}, x_t] + b_o)
cell_state = forget_gate⊙c_{t-1} + input_gate⊙tanh(W_c·[h_{t-1}, x_t] + b_c)
hidden_state = output_gate⊙tanh(cell_state)

三个关键门控：

• 遗忘门：决定丢弃哪些历史信息（如"虽然...但是"后的转折）
• 输入门：决定存储哪些新信息（如关键实体识别）
• 输出门：决定当前输出哪些信息

尽管LSTM缓解了梯度消失问题，但其序列计算的本质导致训练速度仍是瓶颈。在Wikipedia语料上，LSTM的训练时间是同等规模Transformer的3-5倍。

2.3 Self-Attention的并行突破

Self-Attention机制彻底改变了序列建模方式，其核心计算流程：

1. 向量投射：将输入x_i通过三个矩阵W_Q, W_K, W_V投射为Query、Key、Value向量

   code复制Q = XW_Q, K = XW_K, V = XW_V
   

2. 注意力打分：计算query与所有key的点积并缩放

   code复制Attention(Q,K,V) = softmax(QK^T/√d_k)V
   

3. 多头机制：并行多个注意力头捕捉不同关系

   python复制# 多头注意力PyTorch实现
   class MultiHeadAttention(nn.Module):
       def __init__(self, d_model, num_heads):
           super().__init__()
           self.d_k = d_model // num_heads
           self.num_heads = num_heads
           self.linears = clones(nn.Linear(d_model, d_model), 4)
           
       def forward(self, query, key, value):
           nbatches = query.size(0)
           # 线性投射后分割为多头
           query, key, value = [
               lin(x).view(nbatches, -1, self.num_heads, self.d_k).transpose(1, 2)
               for lin, x in zip(self.linears, (query, key, value))
           ]
           # 应用注意力
           x, _ = attention(query, key, value)
           # 合并多头结果
           x = x.transpose(1, 2).contiguous().view(nbatches, -1, self.num_heads * self.d_k)
           return self.linears[-1](x)
   

这种设计带来三大优势：

1. 全局依赖：每个位置直接访问序列所有位置
2. 并行计算：矩阵运算充分利用GPU并行能力
3. 可解释性：注意力权重可视化显示模型关注点

3. BERT：Transformer的里程碑式应用

3.1 模型架构详解

BERT基于Transformer编码器堆叠，其模型配置有两个版本：

• BERT-Base：12层，768隐藏单元，12个注意力头，1.1亿参数
• BERT-Large：24层，1024隐藏单元，16个注意力头，3.4亿参数

输入表示融合三种嵌入：

python复制# 输入构造示例
input_ids = [CLS] + tokenize("自然语言处理") + [SEP] + tokenize("深度学习") + [SEP]
token_type_ids = [0,0,0,0,0,1,1,1]  # 区分句子A/B
position_ids = [0,1,2,3,4,5,6,7]    # 位置编码
final_embedding = word_embedding(input_ids) + 
                 position_embedding(position_ids) + 
                 token_type_embedding(token_type_ids)

3.2 预训练策略精要

3.2.1 Masked Language Model (MLM)

创新性的掩码策略：

• 随机掩码15%的token
• 其中80%替换为[MASK]
• 10%替换为随机词
• 10%保持不变

这种设计迫使模型必须理解上下文而不仅是记忆表面模式。在实现时需要注意：

python复制# MLM实现关键步骤
def create_masked_lm_predictions(tokens, mask_prob=0.15):
    output_tokens = list(tokens)
    masked_indices = []
    for i, token in enumerate(tokens):
        if random.random() < mask_prob:
            masked_indices.append(i)
            rand = random.random()
            if rand < 0.8:
                output_tokens[i] = "[MASK]"
            elif rand < 0.9:
                output_tokens[i] = random.choice(vocab)
    return output_tokens, masked_indices

3.2.2 Next Sentence Prediction (NSP)

构建训练样本的技巧：

• 正样本：从文档中取连续两个句子
• 负样本：随机组合两个不相关句子
• 平衡正负样本比例1:1

在实际应用中，我们发现NSP任务对某些下游任务（如问答）的提升比MLM更显著。

3.3 微调实战技巧

3.3.1 学习率设置

采用分层学习率策略：

• 底层参数：较小的学习率（如5e-5）
• 顶层参数：较大的学习率（如3e-4）
• 分类头：最大学习率（如1e-3）

python复制# 分层学习率示例
optimizer = AdamW([
    {'params': model.bert.embeddings.parameters(), 'lr': 5e-5},
    {'params': model.bert.encoder.layer[:6].parameters(), 'lr': 3e-5},
    {'params': model.bert.encoder.layer[6:].parameters(), 'lr': 5e-5},
    {'params': model.classifier.parameters(), 'lr': 1e-4}
])

3.3.2 批量大小选择

经验法则：

• 分类任务：32-64
• 序列标注：16-32
• 小样本学习：8-16

在GPU内存允许的情况下，较大的批量通常更稳定。当遇到OOM错误时，可以尝试：

• 梯度累积（accumulation_steps=2）
• 混合精度训练
• 梯度检查点

4. 实战中的挑战与解决方案

4.1 长文本处理策略

BERT的最大序列长度通常为512，处理长文档的解决方案：

1. 滑动窗口法：

   • 将文档分割为重叠的片段
   • 分别处理每个片段
   • 合并结果时取重叠区域的平均

2. 层次化方法：

   python复制class HierarchicalBERT(nn.Module):
       def __init__(self, bert_model):
           super().__init__()
           self.bert = bert_model
           self.pooler = nn.Linear(768, 768)
           
       def forward(self, input_chunks):  # input_chunks: [batch, chunks, seq_len]
           chunk_features = []
           for i in range(input_chunks.size(1)):
               chunk_out = self.bert(input_chunks[:,i,:])
               chunk_features.append(chunk_out[1])  # [CLS] token
           document_feature = torch.mean(torch.stack(chunk_features), dim=1)
           return self.pooler(document_feature)
   

3. Longformer/Reformer：专门针对长文本优化的Transformer变体

4.2 领域适应技巧

当目标领域与BERT预训练领域差异较大时：

1. 继续预训练：

   • 在领域语料上额外训练5-10个epoch
   • 使用较小的学习率（1e-5到5e-5）
   • 保持MLM任务，可增加领域特定词汇

2. 知识蒸馏：

   python复制# 蒸馏损失计算
   def compute_kd_loss(teacher_logits, student_logits, temperature=2.0):
       soft_teacher = F.softmax(teacher_logits/temperature, dim=-1)
       soft_student = F.log_softmax(student_logits/temperature, dim=-1)
       return F.kl_div(soft_student, soft_teacher, reduction='batchmean') * (temperature**2)
   

3. 适配器模块：在BERT层间插入小型适配网络，仅训练这些适配器

4.3 计算效率优化

1. 量化推理：

   python复制# 动态量化示例
   quantized_model = torch.quantization.quantize_dynamic(
       model, {nn.Linear}, dtype=torch.qint8
   )
   

2. 模型剪枝：

   • 基于权重大小的剪枝
   • 基于注意力头重要性的剪枝
   • 层drop（如DistilBERT移除了50%的层）

3. ONNX运行时：将模型导出为ONNX格式可获得20-30%的推理加速

5. BERT的进化与前沿方向

5.1 模型架构创新

1. RoBERTa：

   • 移除了NSP任务
   • 更大的batch size（8k）
   • 更长的训练时间
   • 动态掩码模式

2. ALBERT：

   • 参数共享跨层
   • 嵌入层分解
   • 句子顺序预测(SOP)任务

3. ELECTRA：

   • 用生成器-判别器架构替代MLM
   • 所有token都参与训练
   • 更高效的数据利用

5.2 多模态扩展

1. VideoBERT：

   • 视频帧+ASR文本联合训练
   • 时空注意力机制
   • 视频描述生成

2. VL-BERT：

   python复制# 多模态输入处理
   visual_embeddings = self.visual_encoder(frames)
   text_embeddings = self.text_encoder(text)
   joint_input = torch.cat([visual_embeddings, text_embeddings], dim=1)
   

3. SpeechBERT：

   • 语音特征+文本联合编码
   • 语音单元发现
   • 语音-文本对齐

5.3 轻量化技术

1. MobileBERT：

   • 瓶颈结构
   • 平衡自注意力与前馈网络
   • 4.3倍速度提升

2. TinyBERT：

   • 注意力矩阵蒸馏
   • 隐藏状态蒸馏
   • 嵌入层蒸馏

3. BinaryBERT：

   • 权重二值化
   • 量化感知训练
   • 仅1bit权重表示

在实际部署中，我们团队发现经过知识蒸馏的TinyBERT在保持90%以上原始性能的同时，将推理速度提升了5倍，特别适合移动端应用。