单向/双向，单层/多层RNN输入输出维度问题

---

RNN

单层单向RNN

Rnn Cell

循环神经网络最原始的Simple RNN实现如下图所示:

下面写出单个时间步对应的Rnn Cell计算公式:

如果用矩阵运算视角来看待的话，单个时间步对应的Rnn Cell计算过程如下图所示:

代码示例如下:

import torchbatch_size = 2   # 批量大小
seq_len = 3      # 序列长度(单个RNN层包含的Time Step数量)
input_size = 4   # 输入数据的维度
hidden_size = 2  # 隐藏层的维度cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
dataset = torch.rand(seq_len, batch_size, input_size)
hidden = torch.zeros(batch_size, hidden_size)# 使用Rnn Cell加循环实现一个Rnn层处理一批输入序列的过程
for idx, input in enumerate(dataset):print('='*10,idx,'='*10)print('input size:', input.shape)hidden = cell(input, hidden)print('outputs size:', hidden.shape)print(hidden)

输出:

========== 0 ==========
input size: torch.Size([2, 4])
outputs size: torch.Size([2, 2])
tensor([[ 0.1077, -0.7972],[-0.1070, -0.9517]], grad_fn=<TanhBackward0>)
========== 1 ==========
input size: torch.Size([2, 4])
outputs size: torch.Size([2, 2])
tensor([[-0.4524, -0.8874],[ 0.0443, -0.9716]], grad_fn=<TanhBackward0>)
========== 2 ==========
input size: torch.Size([2, 4])
outputs size: torch.Size([2, 2])
tensor([[-0.2941, -0.9751],[-0.3554, -0.9399]], grad_fn=<TanhBackward0>)

图解运算过程:

1. 输入数据采用三维来表示 (序列长度，批量大小，输入向量维度) , 将序列长度作为第0维是因为这样可以很方便的将同属于一个Time Step处理的批次序列数据第i个词一次性送入Rnn Cell中处理。

2. 隐藏层输出的向量为Rnn Cell对当前Time Step输入的$x_t$和$h_{t-1}$做完信息融合和空间变换后得到的结果，其维度可以保持与输入$x_t$一致或者降低维度。

3. 由Rnn Cell内的权重矩阵$W_{ih}$负责完成对输入$x_t$的线性变换，使其由输入维度input_size变为hidden_size; 然后通过加法运算与同样处理的$h_{t-1}$做信息融合，再通过tanh激活做一次非线性变换，增强模型拟合数据的能力。

大家重点关注Rnn Cell如何在一个Time Step内同时处理一批数据的过程。

---

关于Rnn Cell内部具体的运算过程还可以简化为一次矩阵乘法运算完成，如下图所示:

---

Rnn

我们将上文用Rnn Cell加循环实现的例子通过Rnn层来实现一遍:

import torchbatch_size = 2   # 批量大小
seq_len = 3      # 序列长度(单个RNN层包含的Time Step数量)
input_size = 4   # 输入数据的维度
hidden_size = 2  # 隐藏层的维度rnn = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size,num_layers=1)
dataset = torch.rand(seq_len, batch_size, input_size)
hidden = torch.zeros(1,batch_size, hidden_size) # 此处1为RNN层数,下文会讲out, hidden = rnn(dataset, hidden)
print('output size:', out.shape)
print('Hidden size:', hidden.shape)

输出:

output size: torch.Size([3, 2, 2])
Hidden size: torch.Size([1, 2, 2])

Rnn可以一次性处理完输入的批量序列数据，并返回处理后的结果和最后一个Time Step隐藏层的输出结果，返回结果的维度解释如下:

• out：(序列长度，批量大小，隐藏层维度)
• hidden: (隐藏层层数，批量大小，隐藏层维度）

上图中按照Time Step维度展开的Rnn Cell为同一个实例对象，也就是上文中最开始给出的Rnn Cell加循环的图解过程，所以不同Time Step处理时涉及到的权重矩阵是共享的。

---

双层单向RNN

双层单向RNN处理的流程如下图所示:

我们下面通过代码来验证一下:

import torchbatch_size = 2   # 批量大小
seq_len = 3      # 序列长度(单个RNN层包含的Time Step数量)
input_size = 4   # 输入数据的维度
hidden_size = 2  # 隐藏层的维度rnn = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size,num_layers=2)
dataset = torch.rand(seq_len, batch_size, input_size)
hidden = torch.zeros(2,batch_size, hidden_size) # 此处1为RNN层数,下文会讲out, hidden = rnn(dataset, hidden)
print('output size:', out.shape)
print('Hidden size:', hidden.shape)

输出:

output size: torch.Size([3, 2, 2])
Hidden size: torch.Size([2, 2, 2])

改为双层RNN后，我们初始化输入的隐藏层向量要同时为层1的RNN和层2的RNN都提供，因此hidden的第一维num_layers要变为2; 同理，我们最终处理完毕后，会得到层1和层2的最后一个Time Step的输出，因此返回的hidden维度第一维也是2。

• out：(序列长度，批量大小，隐藏层维度)
• hidden: (隐藏层层数，批量大小，隐藏层维度）

---

单层双向RNN

单层双向RNN处理的流程如下图所示:

我们下面通过代码来验证一下:

import torchbatch_size = 2   # 批量大小
seq_len = 3      # 序列长度(单个RNN层包含的Time Step数量)
input_size = 4   # 输入数据的维度
hidden_size = 2  # 隐藏层的维度rnn = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size,num_layers=1,bidirectional=True)
dataset = torch.rand(seq_len, batch_size, input_size)
hidden = torch.zeros(2,batch_size, hidden_size) # 此处1为RNN层数,下文会讲out, hidden = rnn(dataset, hidden)
print('output size:', out.shape)
print('Hidden size:', hidden.shape)

输出:

output size: torch.Size([3, 2, 4])
Hidden size: torch.Size([2, 2, 2])

当我们考虑双向时，最终输出得到的out和hidden维度都会发生改变：

• out：(序列长度，批量大小，隐藏层维度*2)
• hidden: (隐藏层层数*2，批量大小，隐藏层维度）

当设置RNN为双向后，在每一个Time Step我们会得到正向和反向计算的两份输出，因此每个Time Step隐藏层的输出为正向和反向输出的concat，这里的concat运算过程如下所示:

# 维度: (序列长度,批量大小,隐藏层维度) --> [3,2,4]
# 假设正向RNN输出如下
forward_outputs = torch.tensor([[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]],  # t=0[[0.9, 1.0, 1.1, 1.2], [1.3, 1.4, 1.5, 1.6]],  # t=1[[1.7, 1.8, 1.9, 2.0], [2.1, 2.2, 2.3, 2.4]]  # t=2
])
# 假设反向RNN输出如下
backward_outputs = torch.tensor([[[2.5, 2.6, 2.7, 2.8], [2.9, 3.0, 3.1, 3.2]],  # t=0[[3.3, 3.4, 3.5, 3.6], [3.7, 3.8, 3.9, 4.0]],  # t=1[[4.1, 4.2, 4.3, 4.4], [4.5, 4.6, 4.7, 4.8]]  # t=2
])
# 拼接（concatenation）后的结果如下
concatenated_outputs = torch.tensor([[[0.1, 0.2, 0.3, 0.4, 2.5, 2.6, 2.7, 2.8], [0.5, 0.6, 0.7, 0.8, 2.9, 3.0, 3.1, 3.2]],  # t=0[[0.9, 1.0, 1.1, 1.2, 3.3, 3.4, 3.5, 3.6], [1.3, 1.4, 1.5, 1.6, 3.7, 3.8, 3.9, 4.0]],  # t=1[[1.7, 1.8, 1.9, 2.0, 4.1, 4.2, 4.3, 4.4], [2.1, 2.2, 2.3, 2.4, 4.5, 4.6, 4.7, 4.8]]  # t=2
])

同理，采用双向RNN后，正向和反向的最后一个Time Step计算完后都会得到一个hidden输出，因此最终计算完返回的hidden第一维是2；我们初始化时也要同时给出正向和反向RNN的hidden，因此初始化输入的hidden第一维也是2。

---

双层双向RNN

双层双向RNN处理流程如下:

• 第一层双向 RNN：
  • 正向 RNN 从序列的开始到结束处理数据。
  • 反向 RNN 从序列的结束到开始处理数据。
  • 两个方向的输出在每个时间步上进行拼接，形成第一层的输出。
• 第二层双向 RNN：
  • 第二层的输入是第一层的输出。
  • 第二层的正向 RNN 从第一层的输出序列的开始到结束处理数据。
  • 第二层的反向 RNN 从第一层的输出序列的结束到开始处理数据。
  • 两个方向的输出在每个时间步上进行拼接，形成第二层的输出。

我们下面通过代码来验证一下:

import torchbatch_size = 2   # 批量大小
seq_len = 3      # 序列长度(单个RNN层包含的Time Step数量)
input_size = 4   # 输入数据的维度
hidden_size = 2  # 隐藏层的维度rnn = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size,num_layers=2,bidirectional=True)
dataset = torch.rand(seq_len, batch_size, input_size)
hidden = torch.zeros(2*2,batch_size, hidden_size) # 此处1为RNN层数,下文会讲out, hidden = rnn(dataset, hidden)
print('output size:', out.shape)
print('Hidden size:', hidden.shape)

通过断点debug可以看到rnn对象实例内部各层权重矩阵的维度:

重点关注weight_ih_l1 和 weight_ih_l1_reverse ，这两个权重矩阵分别为第二层RNN的正向和反向层对应的输入数据的权重矩阵，可以看到其维度为[4,2] (X*W.T这里给出W转置后的维度) , 说明此处单个Time Step输入第二层Rnn Cell的输入数据维度为[2,4],由此可推断输入的为第一层双向RNN拼接输出后结果。

输出:

output size: torch.Size([3, 2, 4])
Hidden size: torch.Size([4, 2, 2])

这里output输出的维度和单层双向RNN的结果一致，这是因为第一层RNN的输出结果维度和初始input数据维度相同。

hidden第一维输出变成了4，这是因为每一个双向RNN层都会在最后一个Time Step提供正向和反向两个hidden输出，而因为我们这里采用了两层双向RNN，因此最终会得到四个hidden输出。