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

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

RNN的数学基础

核心方程

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

1. 隐藏状态更新：
   $$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}$: 双曲正切激活函数

2. 输出计算：
   $$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计算以下内容：

1. 更新门 ($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之间）

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

2. 重置门 ($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]）

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

3. 候选隐藏状态 (${\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$: 逐元素乘法（哈达玛积）

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

4. 最终隐藏状态 ($h_t$)：
   $$h_t=(1-z_t)\odot h_{t-1}+z_t\odot {\tilde{h}}_t$$

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

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 nnclass SimpleRNN(nn.Module):def __init__(self, input_size, hidden_size, output_size):super(SimpleRNN, self).__init__()self.hidden_size = hidden_sizeself.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, hiddendef 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  # 批大小为1return 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)  # 批大小为1print("隐藏状态形状:", 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 = hiddendecoded_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:breakdecoded_words.append(zh_chars[topi.item()])decoder_input = topi.detach()return ''.join(decoded_words), decoder_hiddendef 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 = 0for 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 = hiddenloss = 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），这些模型在机器翻译任务中表现出色。