英译法案例 - 模型训练总结

1 课程概览

本课总结模型训练过程。训练 5 轮，每轮约 1 分钟（GPU），每 1000 条数据约 20 秒。保存了 5 个编码器和 5 个解码器模型。损失曲线持续下降说明模型在收敛。训练策略：单批次训练和多轮多批次训练分成两个函数，提高代码可读性。

2 核心概念与定义

单批次训练（train_iterate）：一个句子的训练过程。
多轮多批次训练：模型训练的骨架和流程。
Teacher Forcing 概率：0.5，不要太大。
三剑客：梯度清零、反向传播、梯度更新。

3 模型与算法详解

训练时长

项目	时长
总轮数	5 轮
每轮时长	约 1 分钟（GPU）
每 1000 条	约 20 秒

模型保存

一共保存了 10 个模型：5 个编码器 + 5 个解码器。

损失曲线

损失持续下降，说明模型在收敛
可调整打印密度（每 10 次或每 100 次打印）

训练流程总结

单批次训练（train_iterate）

编码：将英语句子编码为隐藏状态
解码：结合 Teacher Forcing 生成法语
训练策略：是否使用 Teacher Forcing
- 用：拿上一步真实值作为下一步输入
- 不用：拿本次预测值作为下一次输入
三剑客：梯度清零、反向传播、梯度更新

多轮多批次训练

定义优化器
定义损失函数
调用单批次训练函数

代码结构

单批次训练和多轮多批次训练分成两个函数，提高可读性。

def train_iterate():
    """单批次训练"""
    # 编码
    # 解码（Teacher Forcing）
    # 三剑客：梯度清零、反向传播、梯度更新

def train():
    """多轮多批次训练"""
    # 定义优化器
    # 定义损失函数
    # 调用 train_iterate

Teacher Forcing 概率

概率设为 0.5，不要太大。

太大：每次都用真实值，效果不好
0.5：一半用真实值，一半用预测值

4 数学原理与推导

梯度更新

$$W = W - \alpha \cdot \nabla W$$

其中 $\alpha$ 是学习率，$\nabla W$ 是梯度。

Teacher Forcing

$$\hat{y}t = f(y{t-1}, h_{t-1})$$

以概率 0.5 使用真实值 $y_{t-1}$，否则使用预测值 $\hat{y}_{t-1}$。

5 代码示例

import torch
import torch.nn as nn
import matplotlib.pyplot as plt


def train_iterate(input_tensor, target_tensor, encoder, decoder,
                  encoder_optimizer, decoder_optimizer, criterion,
                  teacher_forcing_ratio=0.5, max_length=10):
    """单批次训练函数"""
    encoder_optimizer.zero_grad()
    decoder_optimizer.zero_grad()
    
    input_length = input_tensor.size(0)
    target_length = target_tensor.size(0)
    
    loss = 0
    
    # 编码
    encoder_hidden = encoder.initHidden()
    for ei in range(input_length):
        encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)
    
    # 解码
    decoder_input = torch.tensor([[SOS]], device=device)
    decoder_hidden = encoder_hidden
    
    use_teacher_forcing = torch.rand(1).item() < teacher_forcing_ratio
    
    for di in range(target_length):
        decoder_output, decoder_hidden, _ = decoder(
            decoder_input, decoder_hidden, encoder_outputs
        )
        
        loss += criterion(decoder_output, target_tensor[di])
        
        if use_teacher_forcing:
            # Teacher Forcing：用真实值
            decoder_input = target_tensor[di]
        else:
            # 不用 Teacher Forcing：用预测值
            topv, topi = decoder_output.topk(1)
            decoder_input = topi.squeeze().detach()
    
    # 三剑客：梯度清零、反向传播、梯度更新
    loss.backward()
    encoder_optimizer.step()
    decoder_optimizer.step()
    
    return loss.item() / target_length


def train(encoder, decoder, n_iters, learning_rate=0.001):
    """多轮多批次训练函数"""
    # 定义优化器
    encoder_optimizer = torch.optim.Adam(encoder.parameters(), lr=learning_rate)
    decoder_optimizer = torch.optim.Adam(decoder.parameters(), lr=learning_rate)
    
    # 定义损失函数
    criterion = nn.NLLLoss()
    
    # 记录损失
    plot_losses = []
    
    for iter in range(1, n_iters + 1):
        # 获取数据
        for x, y in my_dataloader:
            # 调用单批次训练
            loss = train_iterate(x, y, encoder, decoder,
                                encoder_optimizer, decoder_optimizer, criterion)
            plot_losses.append(loss)
    
    # 绘制损失曲线
    plt.plot(plot_losses)
    plt.title('Training Loss')
    plt.show()