循环神经网络(RNN)：从理论到翻译

循环神经网络（RNN）是一种专为处理序列数据设计的神经网络，如时间序列、自然语言或语音。与传统的全连接神经网络不同，RNN具有"记忆"功能，通过循环传递信息，使其特别适合需要考虑上下文或顺序的任务。它出现在Transformer之前，广泛应用于文本生成、语音识别和时间序列预测（如股价预测）等领域。

RNN的数学基础

rnn-https://zlu.me

核心方程

在每个时间步 $t$ ，RNN执行以下操作：

隐藏状态更新：
$h_t = \text{tanh}(W_{hh}h_{t-1} + W_{xh}x_t + b_h)$
- $h_t$ : 时间 $t$ 的新隐藏状态（形状：[hidden_size]）
- $h_{t-1}$ : 前一个隐藏状态（形状：[hidden_size]）
- $x_t$ : 时间 $t$ 的输入（形状：[input_size]）
- $W_{hh}$ : 隐藏到隐藏的权重矩阵（形状：[hidden_size, hidden_size]）
- $W_{xh}$ : 输入到隐藏的权重矩阵（形状：[hidden_size, input_size]）
- $b_h$ : 隐藏层偏置项（形状：[hidden_size]）
- $\text{tanh}$ : 双曲正切激活函数
输出计算：
$o_t = W_{hy}h_t + b_y$
- $o_t$ : 时间 $t$ 的输出（形状：[output_size]）
- $W_{hy}$ : 隐藏到输出的权重矩阵（形状：[output_size, hidden_size]）
- $b_y$ : 输出偏置项（形状：[output_size]）

随时间反向传播（BPTT）

RNN使用BPTT进行训练，它通过时间展开网络并应用链式法则：

$\frac{\partial L}{\partial W} = \sum_{t=1}^T \frac{\partial L_t}{\partial o_t} \frac{\partial o_t}{\partial h_t} \sum_{k=1}^t \left( \prod_{i=k+1}^t \frac{\partial h_i}{\partial h_{i-1}} \right) \frac{\partial h_k}{\partial W}$

这可能导致梯度消失/爆炸问题，LSTM和GRU架构可以解决这个问题。

GRU：门控循环单元

在深入翻译示例之前，让我们先了解GRU的数学基础。GRU通过门控机制解决了标准RNN中的梯度消失问题。

GRU方程

在每个时间步 $t$ ，GRU计算以下内容：

更新门 ( $z_t$ )：
$z_t = \sigma(W_z \cdot [h_{t-1}, x_t] + b_z)$
- $z_t$ : 更新门（形状：[hidden_size]）
- $W_z$ : 更新门的权重矩阵（形状：[hidden_size, hidden_size + input_size]）
- $b_z$ : 更新门的偏置项（形状：[hidden_size]）
- $h_{t-1}$ : 前一个隐藏状态
- $x_t$ : 当前输入
- $\sigma$ : Sigmoid激活函数（将值压缩到0和1之间）
更新门决定保留多少之前的隐藏状态。
重置门 ( $r_t$ )：
$r_t = \sigma(W_r \cdot [h_{t-1}, x_t] + b_r)$
- $r_t$ : 重置门（形状：[hidden_size]）
- $W_r$ : 重置门的权重矩阵（形状：[hidden_size, hidden_size + input_size]）
- $b_r$ : 重置门的偏置项（形状：[hidden_size]）
重置门决定忘记多少之前的隐藏状态。
候选隐藏状态 ( $\tilde{h}_t$ )：
$\tilde{h}_t = \text{tanh}(W \cdot [r_t \odot h_{t-1}, x_t] + b)$
- $\tilde{h}_t$ : 候选隐藏状态（形状：[hidden_size]）
- $W$ : 候选状态的权重矩阵（形状：[hidden_size, hidden_size + input_size]）
- $b$ : 偏置项（形状：[hidden_size]）
- $\odot$ : 逐元素乘法（哈达玛积）
这表示可能使用的新隐藏状态内容。
最终隐藏状态 ( $h_t$ )：
$h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t$
- 最终隐藏状态是前一个隐藏状态和候选状态的组合
- $z_t$ 作为新旧信息之间的插值因子

GRU在翻译中的优势

更新门
- 在英中翻译中，这有助于决定：
  - 保留多少上下文（例如，保持句子的主语）
  - 更新多少新信息（例如，遇到新词时）
重置门
- 帮助忘记不相关的信息
- 例如，在翻译新句子时，可以重置前一个句子的上下文
梯度流动
- 最终隐藏状态计算中的加法更新( $+$ )有助于保持梯度流动
- 这对于学习翻译任务中的长程依赖关系至关重要

简单的RNN示例

这个简化示例训练一个RNN来预测单词"hello"中的下一个字符。

模型定义：
- nn.RNN处理循环计算
- 全连接层(fc)将隐藏状态映射到输出（字符预测）
数据：
- 使用"hell"作为输入，期望输出为"ello"（序列移位）
- 字符转换为one-hot向量（例如，‘h’ → [1, 0, 0, 0]）
训练：
- 通过最小化预测字符和目标字符之间的交叉熵损失来学习
预测：
- 训练后，模型可以预测下一个字符

import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x, hidden):
        out, hidden = self.rnn(x, hidden)
        out = self.fc(out)
        return out, hidden
    
    def init_hidden(self, batch_size):
        return torch.zeros(1, batch_size, self.hidden_size)

# 超参数
input_size = 4   # 唯一字符数 (h, e, l, o)
hidden_size = 8  # 隐藏状态大小
output_size = 4  # 与input_size相同
learning_rate = 0.01

# 字符词汇表
chars = ['h', 'e', 'l', 'o']
char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}

# 输入数据："hell" 预测 "ello"
input_seq = "hell"
target_seq = "ello"

# 转换为one-hot编码
def to_one_hot(seq):
    tensor = torch.zeros(1, len(seq), input_size)  # [batch_size, seq_len, input_size]
    for t, char in enumerate(seq):
        tensor[0][t][char_to_idx[char]] = 1  # 批大小为1
    return tensor

# 准备输入和目标张量
input_tensor = to_one_hot(input_seq)  # 形状: [1, 4, 4]
print("输入张量形状:", input_tensor.shape)
target_tensor = torch.tensor([char_to_idx[ch] for ch in target_seq], dtype=torch.long)  # 形状: [4]

# 初始化模型、损失函数和优化器
model = SimpleRNN(input_size, hidden_size, output_size)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练循环
for epoch in range(100):
    hidden = model.init_hidden(1)  # 批大小为1
    print("隐藏状态形状:", hidden.shape)  # 应该是 [1, 1, 8]
    optimizer.zero_grad()
    output, hidden = model(input_tensor, hidden)  # 输出: [1, 4, 4], 隐藏: [1, 1, 8]
    
    loss = criterion(output.squeeze(0), target_tensor)  # output.squeeze(0): [4, 4], target: [4]
    loss.backward()
    optimizer.step()
    
    if epoch % 20 == 0:
        print(f'轮次 {epoch}, 损失: {loss.item():.4f}')

# 测试模型
with torch.no_grad():
    hidden = model.init_hidden(1)

英中翻译示例

我们将使用PyTorch的GRU（门控循环单元）构建一个简单的英中翻译模型，GRU是RNN的一种变体，能更好地处理长程依赖关系。

1. 数据准备

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 样本平行语料（英文 -> 中文）
english_sentences = [
    "hello", "how are you", "i love machine learning",
    "good morning", "artificial intelligence"
]

chinese_sentences = [
    "你好", "你好吗", "我爱机器学习",
    "早上好", "人工智能"
]

# 创建词汇表
eng_chars = sorted(list(set(' '.join(english_sentences))))
zh_chars = sorted(list(set(''.join(chinese_sentences))))

# 添加特殊标记
SOS_token = 0  # 句子开始
EOS_token = 1  # 句子结束
eng_chars = ['<SOS>', '<EOS>', '<PAD>'] + eng_chars
zh_chars = ['<SOS>', '<EOS>', '<PAD>'] + zh_chars

# 创建词到索引的映射
eng_to_idx = {ch: i for i, ch in enumerate(eng_chars)}
zh_to_idx = {ch: i for i, ch in enumerate(zh_chars)}

# 将句子转换为张量
def sentence_to_tensor(sentence, vocab, is_target=False):
    indices = [vocab[ch] for ch in (sentence if not is_target else sentence)]
    if is_target:
        indices.append(EOS_token)  # 为目标添加EOS标记
    return torch.tensor(indices, dtype=torch.long).view(-1, 1)

2. 模型架构

class Seq2Seq(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Seq2Seq, self).__init__()
        self.hidden_size = hidden_size
        
        # 编码器（英文到隐藏状态）
        self.embedding = nn.Embedding(input_size, hidden_size)
        self.gru = nn.GRU(hidden_size, hidden_size)
        
        # 解码器（隐藏状态到中文）
        self.out = nn.Linear(hidden_size, output_size)
        self.softmax = nn.LogSoftmax(dim=1)
    
    def forward(self, input_seq, hidden=None, max_length=10):
        # 编码器
        embedded = self.embedding(input_seq).view(1, 1, -1)
        output, hidden = self.gru(embedded, hidden)
        
        # 解码器
        decoder_input = torch.tensor([[SOS_token]], device=input_seq.device)
        decoder_hidden = hidden
        decoded_words = []
        
        for _ in range(max_length):
            output, decoder_hidden = self.gru(
                self.embedding(decoder_input).view(1, 1, -1),
                decoder_hidden
            )
            output = self.softmax(self.out(output[0]))
            topv, topi = output.topk(1)
            
            if topi.item() == EOS_token:
                break
                
            decoded_words.append(zh_chars[topi.item()])
            decoder_input = topi.detach()
            
        return ''.join(decoded_words), decoder_hidden
    
    def init_hidden(self):
        return torch.zeros(1, 1, self.hidden_size)

3. 训练模型

# 超参数
hidden_size = 256
learning_rate = 0.01
n_epochs = 1000

# 初始化模型
model = Seq2Seq(len(eng_chars), hidden_size, len(zh_chars))
criterion = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# 训练循环
for epoch in range(n_epochs):
    total_loss = 0
    
    for eng_sent, zh_sent in zip(english_sentences, chinese_sentences):
        # 准备数据
        input_tensor = sentence_to_tensor(eng_sent, eng_to_idx)
        target_tensor = sentence_to_tensor(zh_sent, zh_to_idx, is_target=True)
        
        # 前向传播
        model.zero_grad()
        hidden = model.init_hidden()
        
        # 编码器前向传播
        embedded = model.embedding(input_tensor).view(len(input_tensor), 1, -1)
        _, hidden = model.gru(embedded, hidden)
        
        # 准备解码器
        decoder_input = torch.tensor([[SOS_token]])
        decoder_hidden = hidden
        loss = 0
        
        # 教师强制：使用目标作为下一个输入
        for di in range(len(target_tensor)):
            output, decoder_hidden = model.gru(
                model.embedding(decoder_input).view(1, 1, -1),
                decoder_hidden
            )
            output = model.out(output[0])
            loss += criterion(output, target_tensor[di])
            decoder_input = target_tensor[di]
        
        # 反向传播和优化
        loss.backward()
        optimizer.step()
        total_loss += loss.item() / len(target_tensor)
    
    # 打印进度
    if (epoch + 1) % 100 == 0:
        print(f'轮次 {epoch + 1}, 平均损失: {total_loss / len(english_sentences):.4f}')

# 测试翻译
def translate(sentence):
    with torch.no_grad():
        input_tensor = sentence_to_tensor(sentence.lower(), eng_to_idx)
        output_words, _ = model(input_tensor)
        return output_words

# 示例翻译
print("\n翻译结果:")
print(f"'hello' -> '{translate('hello')}'")
print(f"'how are you' -> '{translate('how are you')}'")
print(f"'i love machine learning' -> '{translate('i love machine learning')}'")