英译法案例 - 需求介绍

1 课程概览

本课介绍 Sequence to Sequence 机器翻译案例——英译法。source 是英文，target 是法文。整个代码约 800 行，使用 nn.Embedding 词嵌入层进行文本数值化。在解码器端增加注意力机制，实现句子到句子的翻译。本案例本质是一个分类问题（4000 多个法语单词的分类）。

2 核心概念与定义

英译法：source 是英文，target 是法文。
Seq2Seq 架构：编码器（理解）+ 解码器（生成）+ 中间语义张量 C。
nn.Embedding：词嵌入层，用于文本数值化。
注意力机制：在解码器端添加，让每个时间步用不同的 $C_t$。
分类问题：从 4000 多个法语单词中预测概率最高的词。

3 模型与算法详解

案例需求

输入：一句英文
输出：翻译成法文
架构：Seq2Seq（句子到句子）
特点：解码器端增加注意力机制

Seq2Seq 架构三部分

组件	作用
编码器（Encoder）	主理解，将输入序列编码为中间语义张量 C
解码器（Decoder）	主生成，基于 C 生成目标序列
中间语义张量 C	编码器的总输出

编码流程

一个时间步一个时间步地编码
每次输入 $x_t$ 和 $h_{t-1}$
得到本次的隐藏状态 $h_t$ 和输出
最后的 C 是对所有词向量内容的汇总

解码流程（加注意力机制）

生成 "to" 时，不仅要依赖前边 3 个词，还要依赖已生成的 "welcome"。

每个时间步用不同的 $C_t$
结合上一时刻隐藏状态 $S_{t-1}$
全连接 + softmax 分类
从 4000 多个法语单词中找概率最高的

本质：分类问题

英译法本质是一个分类问题。

法语单词去重合并后约 4000 多个
每次生成单词时，输出 4000 多个概率
概率最高的就是预测的词

数据格式

英文\t法文
I am a student\tJe suis un étudiant

每行两列，左边英文，右边法文
中间用 \t（制表符）隔开
可训练数据约 1 万多条

4 数学原理与推导

编码过程

$$h_t = \text{Encoder}(x_t, h_{t-1})$$ $$C = h_T$$

解码过程（加注意力）

$$C_t = \text{Attention}(Q_t, K, V)$$ $$Y_t = \text{Decoder}(C_t, S_{t-1})$$ $$P(Y_t) = \text{softmax}(\text{Linear}(Y_t))$$

分类

$$\hat{Y}t = \arg\max{i} P(Y_t = i)$$

5 代码示例

# 英译法案例框架（伪代码）
import torch
import torch.nn as nn

class Encoder(nn.Module):
    """编码器：基于 GRU"""
    def __init__(self, input_size, hidden_size):
        super().__init__()
        self.embedding = nn.Embedding(input_size, hidden_size)
        self.gru = nn.GRU(hidden_size, hidden_size)
    
    def forward(self, x, hidden):
        embedded = self.embedding(x)
        output, hidden = self.gru(embedded, hidden)
        return output, hidden


class AttentionDecoder(nn.Module):
    """解码器：加入注意力机制"""
    def __init__(self, hidden_size, output_size):
        super().__init__()
        self.embedding = nn.Embedding(output_size, hidden_size)
        self.gru = nn.GRU(hidden_size, hidden_size)
        self.linear = nn.Linear(hidden_size, output_size)
        self.softmax = nn.LogSoftmax(dim=1)
    
    def forward(self, x, hidden, encoder_outputs):
        # 注意力权重
        attn_weights = torch.softmax(
            torch.matmul(hidden, encoder_outputs.T),
            dim=1
        )
        # 加权求和得到 C_t
        C_t = torch.matmul(attn_weights, encoder_outputs)
        # 解码
        output, hidden = self.gru(C_t, hidden)
        # 全连接 + softmax 分类
        output = self.softmax(self.linear(output))
        return output, hidden, attn_weights


class Seq2Seq(nn.Module):
    """Seq2Seq 架构"""
    def __init__(self, encoder, decoder):
        super().__init__()
        self.encoder = encoder
        self.decoder = decoder
    
    def forward(self, src, trg):
        # 编码
        encoder_outputs, hidden = self.encoder(src, None)
        # 解码（加注意力）
        outputs = []
        for t in range(trg.size(0)):
            output, hidden, _ = self.decoder(
                trg[t], hidden, encoder_outputs
            )
            outputs.append(output)
        return torch.stack(outputs)