NLP教程(3) | 神经网络与反向传播

一、神经网络基础架构解析

1.1 从感知机到深度神经网络

神经网络的核心由输入层、隐藏层和输出层构成。单个感知机通过加权求和与激活函数实现二分类，但线性模型的表达能力有限。多层感知机（MLP）通过堆叠非线性激活函数（如ReLU、Sigmoid）构建深度结构，使模型具备拟合复杂非线性关系的能力。例如在文本分类任务中，输入层接收词向量矩阵，隐藏层通过非线性变换提取语义特征，输出层给出类别概率。

1.2 关键组件详解

• 权重矩阵：连接层间的参数矩阵，维度由输入/输出神经元数量决定
• 偏置向量：为每个神经元添加的调节参数
• 激活函数：ReLU（f(x)=max(0,x)）缓解梯度消失，Sigmoid（f(x)=1/(1+e^-x)）输出概率值
• 损失函数：交叉熵损失（分类任务）衡量预测分布与真实分布的差异

以PyTorch实现为例：

import torch
import torch.nn as nn
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__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

二、反向传播算法原理

2.1 链式法则的数学基础

反向传播本质是链式法则的工程实现。对于复合函数L=f(g(h(x)))，其梯度∂L/∂x=∂L/∂f·∂f/∂g·∂g/∂h·∂h/∂x。在神经网络中，输出层损失对第l层权重的梯度可分解为：
∂L/∂W^l = (∂L/∂a^l) · (∂a^l/∂z^l) · (∂z^l/∂W^l)
其中a^l为激活输出，z^l为加权输入。

2.2 计算图与动态规划

现代框架（如PyTorch、TensorFlow）通过构建计算图自动追踪梯度。以矩阵乘法为例：

# 前向传播
W = torch.randn(3, 2, requires_grad=True)
x = torch.randn(2, 1)
z = torch.mm(W, x)  # z = Wx
# 反向传播
z.backward(torch.ones_like(z))
print(W.grad)  # 输出∂L/∂W

计算图记录了所有中间变量的依赖关系，反向传播时从输出节点开始，按拓扑顺序反向计算梯度。

三、NLP中的优化实践

3.1 梯度消失与爆炸对策

• 梯度裁剪：当梯度范数超过阈值时按比例缩放

  torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

• 权重初始化：Xavier初始化（nn.init.xavieruniform）根据输入输出维度调整初始值范围
• 残差连接：在Transformer中通过a^l = f(a^{l-1}) + a^{l-1}缓解深层网络梯度消失

3.2 自适应优化器比较

优化器	更新规则	适用场景
SGD	θ = θ - η·∇θL	简单任务，需精细调参
Adam	m = β1m + (1-β1)∇θL v = β2v + (1-β2)∇θL² θ = θ - η·m/(√v+ε)	大多数NLP任务，默认选择
Adagrad	累积历史梯度平方和调整学习率	稀疏梯度场景

3.3 批归一化技术

批归一化（BatchNorm）通过标准化层输入缓解内部协变量偏移：

class BNLayer(nn.Module):
    def __init__(self, features):
        super().__init__()
        self.bn = nn.BatchNorm1d(features)
    def forward(self, x):
        return self.bn(x)

在训练时计算当前批次的均值和方差，测试时使用滑动平均估计。

四、实战案例：文本分类模型

4.1 数据预处理流程

1. 分词与构建词汇表
2. 序列填充至统一长度
3. 生成词索引序列
4. 划分训练/验证/测试集

4.2 模型架构实现

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.rnn = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
    def forward(self, text):
        # text shape: [batch_size, seq_len]
        embedded = self.embedding(text)  # [batch_size, seq_len, embed_dim]
        output, (hidden, cell) = self.rnn(embedded)  # output: [b,s,h], hidden: [1,b,h]
        hidden = hidden.squeeze(0)  # [batch_size, hidden_dim]
        return self.fc(hidden)

4.3 训练循环优化

def train(model, iterator, optimizer, criterion):
    model.train()
    epoch_loss = 0
    for batch in iterator:
        optimizer.zero_grad()
        predictions = model(batch.text).squeeze(1)
        loss = criterion(predictions, batch.label)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item()
    return epoch_loss / len(iterator)

五、进阶技巧与调试指南

5.1 梯度检查方法

通过数值微分验证反向传播正确性：

def gradient_check(model, x, y, epsilon=1e-6):
    model.zero_grad()
    y_pred = model(x)
    loss = criterion(y_pred, y)
    loss.backward()
    # 数值梯度
    numerical_grads = []
    for param in model.parameters():
        if param.requires_grad:
            original = param.data.clone()
            param.data += epsilon
            y_pos = model(x)
            loss_pos = criterion(y_pos, y)
            param.data -= 2*epsilon
            y_neg = model(x)
            loss_neg = criterion(y_neg, y)
            num_grad = (loss_pos - loss_neg).item() / (2*epsilon)
            numerical_grads.append(num_grad)
            param.data = original
    # 比较数值梯度与反向传播梯度
    # ...

5.2 学习率调度策略

• 余弦退火：nn.CosineAnnealingLR
• 预热调度：前若干个epoch逐步增加学习率
• 基于验证集的调度：ReduceLROnPlateau

5.3 分布式训练要点

1. 数据并行：nn.DataParallel自动分割输入数据
2. 梯度聚合：确保所有进程同步更新参数
3. 混合精度训练：使用torch.cuda.amp减少显存占用

六、常见问题解决方案

6.1 梯度爆炸处理

• 实施梯度裁剪（clipgrad_norm）
• 使用LSTM/GRU替代原始RNN
• 添加梯度归一化层

6.2 过拟合对抗策略

• Dropout层（nn.Dropout(p=0.5)）
• 标签平滑（Label Smoothing）
• 早停法（Early Stopping）

6.3 初始化敏感问题

• 对ReLU网络使用He初始化
• 对Sigmoid/Tanh使用Xavier初始化
• 避免全零初始化

七、未来发展方向

1. 稀疏训练：通过参数掩码实现高效计算
2. 二阶优化：K-FAC等近似二阶方法
3. 神经架构搜索：自动化设计最优网络结构
4. 持续学习：缓解灾难性遗忘问题

本文系统梳理了神经网络在NLP中的核心机制，从基础架构到优化技巧提供了完整的技术路线。开发者可通过调整隐藏层维度、激活函数类型和优化器参数，针对具体任务构建高效模型。建议从简单架构开始调试，逐步引入复杂技术，同时密切关注验证集指标变化。