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

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

RNN的数学基础

核心方程

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

1. 隐藏状态更新 ：
   h t = tanh ( W h h h t − 1 + W x h x t + b h ) h_t = \text{tanh}(W_{hh}h_{t-1} + W_{xh}x_t + b_h) ht=tanh(Whhht−1+Wxhxt+bh)

   • h t h_t ht: 时间 t t t的新隐藏状态（形状：[hidden_size]）
   • h t − 1 h_{t-1} ht−1: 前一个隐藏状态（形状：[hidden_size]）
   • x t x_t xt: 时间 t t t的输入（形状：[input_size]）
   • W h h W_{hh} Whh: 隐藏到隐藏的权重矩阵（形状：[hidden_size, hidden_size]）
   • W x h W_{xh} Wxh: 输入到隐藏的权重矩阵（形状：[hidden_size, input_size]）
   • b h b_h bh: 隐藏层偏置项（形状：[hidden_size]）
   • tanh \text{tanh} tanh: 双曲正切激活函数

2. 输出计算 ：
   o t = W h y h t + b y o_t = W_{hy}h_t + b_y ot=Whyht+by

   • o t o_t ot: 时间 t t t的输出（形状：[output_size]）
   • W h y W_{hy} Why: 隐藏到输出的权重矩阵（形状：[output_size, hidden_size]）
   • b y b_y by: 输出偏置项（形状：[output_size]）

随时间反向传播（BPTT）

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

∂ L ∂ W = ∑ t = 1 T ∂ L t ∂ o t ∂ o t ∂ h t ∑ k = 1 t ( ∏ i = k + 1 t ∂ h i ∂ h i − 1 ) ∂ h k ∂ W \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} ∂W∂L=t=1∑T∂ot∂Lt∂ht∂otk=1∑t(i=k+1∏t∂hi−1∂hi)∂W∂hk

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

GRU：门控循环单元

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

GRU方程

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

1. 更新门 ( z t z_t zt)：
   z t = σ ( W z ⋅ [ h t − 1 , x t ] + b z ) z_t = \sigma(W_z \cdot [h_{t-1}, x_t] + b_z) zt=σ(Wz⋅[ht−1,xt]+bz)

   • z t z_t zt: 更新门（形状：[hidden_size]）
   • W z W_z Wz: 更新门的权重矩阵（形状：[hidden_size, hidden_size + input_size]）
   • b z b_z bz: 更新门的偏置项（形状：[hidden_size]）
   • h t − 1 h_{t-1} ht−1: 前一个隐藏状态
   • x t x_t xt: 当前输入
   • σ \sigma σ: Sigmoid激活函数（将值压缩到0和1之间）

   更新门决定保留多少之前的隐藏状态。

2. 重置门 ( r t r_t rt)：
   r t = σ ( W r ⋅ [ h t − 1 , x t ] + b r ) r_t = \sigma(W_r \cdot [h_{t-1}, x_t] + b_r) rt=σ(Wr⋅[ht−1,xt]+br)

   • r t r_t rt: 重置门（形状：[hidden_size]）
   • W r W_r Wr: 重置门的权重矩阵（形状：[hidden_size, hidden_size + input_size]）
   • b r b_r br: 重置门的偏置项（形状：[hidden_size]）

   重置门决定忘记多少之前的隐藏状态。

3. 候选隐藏状态 ( h ~ t \tilde{h}_t h~t)：
   h ~ t = tanh ( W ⋅ [ r t ⊙ h t − 1 , x t ] + b ) \tilde{h}t = \text{tanh}(W \cdot [r_t \odot h{t-1}, x_t] + b) h~t=tanh(W⋅[rt⊙ht−1,xt]+b)

   • h ~ t \tilde{h}_t h~t: 候选隐藏状态（形状：[hidden_size]）
   • W W W: 候选状态的权重矩阵（形状：[hidden_size, hidden_size + input_size]）
   • b b b: 偏置项（形状：[hidden_size]）
   • ⊙ \odot ⊙: 逐元素乘法（哈达玛积）

   这表示可能使用的新隐藏状态内容。

4. 最终隐藏状态 ( h t h_t ht)：
   h t = ( 1 − z t ) ⊙ h t − 1 + z t ⊙ h ~ t h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t ht=(1−zt)⊙ht−1+zt⊙h~t

   • 最终隐藏状态是前一个隐藏状态和候选状态的组合
   • z t z_t zt作为新旧信息之间的插值因子

GRU在翻译中的优势

1. 更新门

   • 在英中翻译中，这有助于决定：
     • 保留多少上下文（例如，保持句子的主语）
     • 更新多少新信息（例如，遇到新词时）

2. 重置门

   • 帮助忘记不相关的信息
   • 例如，在翻译新句子时，可以重置前一个句子的上下文

3. 梯度流动

   • 最终隐藏状态计算中的加法更新( + + +)有助于保持梯度流动
   • 这对于学习翻译任务中的长程依赖关系至关重要

简单的RNN示例

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

1. 模型定义：

   • nn.RNN处理循环计算
   • 全连接层(fc)将隐藏状态映射到输出（字符预测）

2. 数据：

   • 使用"hell"作为输入，期望输出为"ello"（序列移位）
   • 字符转换为one-hot向量（例如，'h' → [1, 0, 0, 0]）

3. 训练：

   • 通过最小化预测字符和目标字符之间的交叉熵损失来学习

4. 预测：

   • 训练后，模型可以预测下一个字符

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')}'")

4. 理解输出

训练后，模型应该能够将简单的英文短语翻译成中文。例如：

• 输入: "hello"

  • 输出: "你好"

• 输入: "how are you"

  • 输出: "你好吗"

• 输入: "i love machine learning"

  • 输出: "我爱机器学习"

5. 关键组件解释

1. 嵌入层：

   • 将离散的词索引转换为连续向量
   • 捕捉词与词之间的语义关系

2. GRU（门控循环单元）：

   • 使用更新门和重置门控制信息流
   • 解决标准RNN中的梯度消失问题

3. 教师强制：

   • 在训练过程中使用目标输出作为下一个输入
   • 帮助模型更快地学习正确的翻译

4. 束搜索：

   • 可以用于提高翻译质量
   • 在解码过程中跟踪多个可能的翻译

6. 挑战与改进

1. 处理变长序列：

   • 使用填充和掩码
   • 实现注意力机制以获得更好的对齐

2. 词汇表大小：

   • 使用子词单元（如Byte Pair Encoding, WordPiece）
   • 实现指针生成网络处理稀有词

3. 性能：

   • 使用双向RNN增强上下文理解
   • 实现Transformer架构以实现并行处理

这个示例为使用RNN进行序列到序列学习提供了基础。对于生产系统，建议使用基于Transformer的模型（如BART或T5），这些模型在机器翻译任务中表现出色。