多层 RNN原理以及实现

数学原理

---

多层 RNN 的核心思想是堆叠多个 RNN 层，每一层的输出作为下一层的输入，从而逐层提取更高层次的抽象特征。

---

1. 单层 RNN 的数学表示

首先，单层 RNN 的计算过程如下。对于一个时间步 $t$，单层 RNN 的隐藏状态 $h_t$ 和输出 $y_t$ 可以表示为：

$$h_t=\text{activation}(W_{ih}{x}_t+b_{ih}+W_{hh}{h}_{t-1}+b_{hh})$$
$$y_t=W_{ho}{h}_t+b_{ho}$$

其中：

• $x_t$ 是时间步 $t$ 的输入。
• $h_t$ 是时间步 $t$ 的隐藏状态。
• $h_{t-1}$ 是时间步 $t-1$ 的隐藏状态。
• $W_{ih}$、$W_{hh}$、$W_{ho}$ 是权重矩阵。
• $b_{ih}$、$b_{hh}$、$b_{ho}$ 是偏置项。
• $\text{activation}$ 是激活函数（如 $\tanh$ 或 $\text{ReLU}$）。

---

2. 多层 RNN 的数学表示

假设我们有一个 $L$ 层的 RNN，每一层的隐藏状态为 $h_t^{(l)}$，其中 $l$ 表示第 $l$ 层，$t$ 表示时间步。多层 RNN 的计算过程如下：

(1) 第一层（$l=1$）

第一层的输入是原始输入序列 $x_t$，隐藏状态 $h_t^{(1)}$ 的计算公式为：

$$h_t^{(1)}=\text{activation}(W_{ih}^{(1)}{x}_t+b_{ih}^{(1)}+W_{hh}^{(1)}{h}_{t-1}^{(1)}+b_{hh}^{(1)})$$

其中：

• $W_{ih}^{(1)}$、$W_{hh}^{(1)}$ 是第一层的权重矩阵。
• $b_{ih}^{(1)}$、$b_{hh}^{(1)}$ 是第一层的偏置项。

(2) 第 $l$ 层（$l>1$）

第 $l$ 层的输入是第 $l-1$ 层的输出 $h_t^{(l-1)}$，隐藏状态 $h_t^{(l)}$ 的计算公式为：

$$h_t^{(l)}=\text{activation}(W_{ih}^{(l)}{h}_t^{(l-1)}+b_{ih}^{(l)}+W_{hh}^{(l)}{h}_{t-1}^{(l)}+b_{hh}^{(l)})$$

其中：

• $W_{ih}^{(l)}$、$W_{hh}^{(l)}$ 是第 $l$ 层的权重矩阵。
• $b_{ih}^{(l)}$、$b_{hh}^{(l)}$ 是第 $l$ 层的偏置项。

(3) 输出层

最后一层（第 $L$ 层）的输出 $h_t^{(L)}$ 作为整个网络的输出 $y_t$：

$$y_t=W_{ho}{h}_t^{(L)}+b_{ho}$$

其中：

• $W_{ho}$、$b_{ho}$ 是输出层的权重矩阵和偏置项。

---

3. 多层 RNN 的数据流向

以下是一个 $L$ 层 RNN 的数据流向的数学描述：

(1) 输入序列

输入序列为 $x_1,x_2,\dots ,x_T$，其中 $T$ 是序列长度。

(2) 初始化隐藏状态

每一层的初始隐藏状态 $h_0^{(l)}$ 通常初始化为零或随机值：

$$h_0^{(l)}=0\text{或}{h}_0^{(l)}\sim \mathcal{N}(0,{\sigma }^2)$$

(3) 时间步 $t$ 的计算

对于每个时间步 $t$，从第一层到第 $L$ 层依次计算隐藏状态：

1. 第一层：
   $$h_t^{(1)}=\text{activation}(W_{ih}^{(1)}{x}_t+b_{ih}^{(1)}+W_{hh}^{(1)}{h}_{t-1}^{(1)}+b_{hh}^{(1)})$$

2. 第 $l$ 层（$l>1$）：
   $$h_t^{(l)}=\text{activation}(W_{ih}^{(l)}{h}_t^{(l-1)}+b_{ih}^{(l)}+W_{hh}^{(l)}{h}_{t-1}^{(l)}+b_{hh}^{(l)})$$

3. 输出：
   $$y_t=W_{ho}{h}_t^{(L)}+b_{ho}$$

(4) 序列输出

最终，整个序列的输出为 $y_1,y_2,\dots ,y_T$。

---

4. 多层 RNN 的特点

(1) 逐层抽象

• 每一层 RNN 可以看作是对输入序列的不同层次的抽象。
• 较低层捕捉局部和细节信息，较高层捕捉全局和语义信息。

(2) 参数共享

• 每一层的参数（权重矩阵和偏置项）在时间步之间共享。
• 不同层的参数是独立的。

(3) 梯度传播

• 在反向传播时，梯度会通过时间步和层数传播。
• 由于梯度消失或爆炸问题，训练深层 RNN 可能会比较困难。

---

可视化原理

下面是一个可视化的结构显示图：其中每一层神经元都要有两个方向的输出，一个是向本时间步的下一层传送，另一个是向下一个时间步的本层传送。而且，每一个神经元都有两个权重矩阵。注意：下方右图仅仅是逻辑上展开的数据流，其中不同世间步上的同一层，用的是同一个权重矩阵。

代码实现

---

1. 示例任务

假设有一个简单的任务：

• 处理一个长度为 4 的序列
• 批次大小为 2
• 每个时间步的输入特征维度为 3
• 希望使用一个 2 层的单向 RNN
• 隐藏状态维度为 5。

---

2. 输入数据

输入句子

• 句子 1: “I love PyTorch”
• 句子 2: “RNN is fun”

输入数据的形状

• 序列长度 (seq_len): 4（假设每个单词是一个时间步）
• 批次大小 (batch_size): 2
• 输入特征维度 (input_size): 3（假设每个单词用一个 3 维向量表示）

具体输入数据

import torch# 输入数据形状: (seq_len, batch_size, input_size)
input_data = torch.tensor([# 时间步 1[[0.1, 0.2, 0.3],  # 句子 1 的第一个单词[0.4, 0.5, 0.6]], # 句子 2 的第一个单词# 时间步 2[[0.7, 0.8, 0.9],  # 句子 1 的第二个单词[1.0, 1.1, 1.2]], # 句子 2 的第二个单词# 时间步 3[[1.3, 1.4, 1.5],  # 句子 1 的第三个单词[1.6, 1.7, 1.8]], # 句子 2 的第三个单词# 时间步 4[[1.9, 2.0, 2.1],  # 句子 1 的第四个单词[2.2, 2.3, 2.4]]  # 句子 2 的第四个单词
])
print("Input shape:", input_data.shape)  # 输出: torch.Size([4, 2, 3])

---

3. 初始隐藏状态

初始隐藏状态的形状

• RNN 层数 (num_layers): 2
• 方向数 (num_directions): 1（单向 RNN）
• 批次大小 (batch_size): 2
• 隐藏状态维度 (hidden_size): 5

具体初始隐藏状态

# 初始隐藏状态形状: (num_layers * num_directions, batch_size, hidden_size)
h0 = torch.zeros(2, 2, 5)  # 2层RNN，批次大小为2，隐藏状态维度为5
print("h0 shape:", h0.shape)  # 输出: torch.Size([2, 2, 5])

---

4. 定义 RNN 模型

import torch.nn as nn# 定义 RNN
rnn = nn.RNN(input_size=3,  # 输入特征维度hidden_size=5, # 隐藏状态维度num_layers=2,  # RNN 层数batch_first=False  # 输入形状为 (seq_len, batch_size, input_size)
)

---

5. 前向传播

计算输出

# 前向传播
output, hn = rnn(input_data, h0)print("Output shape:", output.shape)  # 输出: torch.Size([4, 2, 5])
print("hn shape:", hn.shape)          # 输出: torch.Size([2, 2, 5])

输出解析

1. output:

   • 形状为 (seq_len, batch_size, hidden_size)，即 (4, 2, 5)。
   • 包含了每个时间步的隐藏状态。
   • 例如，output[0] 是第一个时间步的隐藏状态，output[-1] 是最后一个时间步的隐藏状态。

2. hn:

   • 形状为 (num_layers, batch_size, hidden_size)，即 (2, 2, 5)。
   • 包含了最后一个时间步的隐藏状态。
   • 例如，hn[0] 是第一层的最终隐藏状态，hn[1] 是第二层的最终隐藏状态。

---

6. 具体输出值

output 的值

print("Output (所有时间步的隐藏状态):")
print(output)

输出示例：

tensor([[[ 0.1234,  0.5678,  0.9101,  0.1121,  0.3141],[ 0.4151,  0.6171,  0.8191,  0.0212,  0.2232]],[[ 0.4252,  0.6272,  0.8292,  0.0313,  0.2333],[ 0.4353,  0.6373,  0.8393,  0.0414,  0.2434]],[[ 0.4454,  0.6474,  0.8494,  0.0515,  0.2535],[ 0.4555,  0.6575,  0.8595,  0.0616,  0.2636]],[[ 0.4656,  0.6676,  0.8696,  0.0717,  0.2737],[ 0.4757,  0.6777,  0.8797,  0.0818,  0.2838]]],grad_fn=<StackBackward>)

hn 的值

print("hn (最后一个时间步的隐藏状态):")
print(hn)

输出示例：

tensor([[[ 0.4656,  0.6676,  0.8696,  0.0717,  0.2737],[ 0.4757,  0.6777,  0.8797,  0.0818,  0.2838]],[[ 0.4858,  0.6878,  0.8898,  0.0919,  0.2939],[ 0.4959,  0.6979,  0.8999,  0.1020,  0.3040]]],grad_fn=<StackBackward>)

---

batch_first=True时

以下是一个具体的例子，展示当 batch_first=True 时，PyTorch 中 torch.nn.RNN 的输入、输出以及参数的作用。

---

任务

假设有一个简单的任务：

• 处理一个长度为 4 的序列
• 批次大小为 2
• 每个时间步的输入特征维度为 3
• 希望使用一个 2 层的单向 RNN
• 隐藏状态维度为 5
• 并且设置 batch_first=True。

---

2. 输入数据

输入句子

• 句子 1: “I love PyTorch”
• 句子 2: “RNN is fun”

输入数据的形状

• 批次大小 (batch_size): 2
• 序列长度 (seq_len): 4（假设每个单词是一个时间步）
• 输入特征维度 (input_size): 3（假设每个单词用一个 3 维向量表示）

具体输入数据

import torch# 输入数据形状: (batch_size, seq_len, input_size)
input_data = torch.tensor([# 句子 1[[0.1, 0.2, 0.3],  # 第一个单词[0.7, 0.8, 0.9],  # 第二个单词[1.3, 1.4, 1.5],  # 第三个单词[1.9, 2.0, 2.1]], # 第四个单词# 句子 2[[0.4, 0.5, 0.6],  # 第一个单词[1.0, 1.1, 1.2],  # 第二个单词[1.6, 1.7, 1.8],  # 第三个单词[2.2, 2.3, 2.4]]  # 第四个单词
])
print("Input shape:", input_data.shape)  # 输出: torch.Size([2, 4, 3])

---

3. 初始隐藏状态

初始隐藏状态的形状

• RNN 层数 (num_layers): 2
• 方向数 (num_directions): 1（单向 RNN）
• 批次大小 (batch_size): 2
• 隐藏状态维度 (hidden_size): 5

具体初始隐藏状态

# 初始隐藏状态形状: (num_layers * num_directions, batch_size, hidden_size)
h0 = torch.zeros(2, 2, 5)  # 2层RNN，批次大小为2，隐藏状态维度为5
print("h0 shape:", h0.shape)  # 输出: torch.Size([2, 2, 5])

---

4. 定义 RNN 模型

import torch.nn as nn# 定义 RNN
rnn = nn.RNN(input_size=3,  # 输入特征维度hidden_size=5, # 隐藏状态维度num_layers=2,  # RNN 层数batch_first=True  # 输入形状为 (batch_size, seq_len, input_size)
)

---

5. 前向传播

计算输出

# 前向传播
output, hn = rnn(input_data, h0)print("Output shape:", output.shape)  # 输出: torch.Size([2, 4, 5])
print("hn shape:", hn.shape)          # 输出: torch.Size([2, 2, 5])

输出解析

1. output:

   • 形状为 (batch_size, seq_len, hidden_size)，即 (2, 4, 5)。
   • 包含了每个时间步的隐藏状态。
   • 例如，output[0] 是第一个句子的所有时间步的隐藏状态，output[1] 是第二个句子的所有时间步的隐藏状态。

2. hn:

   • 形状为 (num_layers, batch_size, hidden_size)，即 (2, 2, 5)。
   • 包含了最后一个时间步的隐藏状态。
   • 例如，hn[0] 是第一层的最终隐藏状态，hn[1] 是第二层的最终隐藏状态。

---

6. 具体输出值

output 的值

print("Output (所有时间步的隐藏状态):")
print(output)

输出示例：

tensor([[[ 0.1234,  0.5678,  0.9101,  0.1121,  0.3141],[ 0.4252,  0.6272,  0.8292,  0.0313,  0.2333],[ 0.4454,  0.6474,  0.8494,  0.0515,  0.2535],[ 0.4656,  0.6676,  0.8696,  0.0717,  0.2737]],[[ 0.4151,  0.6171,  0.8191,  0.0212,  0.2232],[ 0.4353,  0.6373,  0.8393,  0.0414,  0.2434],[ 0.4555,  0.6575,  0.8595,  0.0616,  0.2636],[ 0.4757,  0.6777,  0.8797,  0.0818,  0.2838]]],grad_fn=<TransposeBackward0>)

hn 的值

print("hn (最后一个时间步的隐藏状态):")
print(hn)

输出示例：

tensor([[[ 0.4656,  0.6676,  0.8696,  0.0717,  0.2737],[ 0.4757,  0.6777,  0.8797,  0.0818,  0.2838]],[[ 0.4858,  0.6878,  0.8898,  0.0919,  0.2939],[ 0.4959,  0.6979,  0.8999,  0.1020,  0.3040]]],grad_fn=<StackBackward>)

---