PyTorch nn.RNN 参数全解析

目录

一、简介

torch.nn.RNN

用于构建循环层，其中的计算规则如下：

         h
        
        
         t
        
       
       
        =
       
       
        tanh
       
       
        ⁡
       
       
        (
       
       
        
         W
        
        
         
          i
         
         
          h
         
        
       
       
        
         x
        
        
         t
        
       
       
        +
       
       
        
         b
        
        
         
          i
         
         
          h
         
        
       
       
        +
       
       
        
         W
        
        
         
          h
         
         
          h
         
        
       
       
        
         h
        
        
         
          t
         
         
          −
         
         
          1
         
        
       
       
        +
       
       
        
         b
        
        
         
          h
         
         
          h
         
        
       
       
        )
       
      
     
     
     
      
       (1)
      
     
    
   
   
     \boldsymbol{h}_{t}=\tanh({\bf W}_{ih}\boldsymbol{x}_t+\boldsymbol{b}_{ih}+{\bf W}_{hh}\boldsymbol{h}_{t-1}+\boldsymbol{b}_{hh}) \tag{1} 
   
  
 ht​=tanh(Wih​xt​+bih​+Whh​ht−1​+bhh​)(1)

其中

     h
    
    
     t
    
   
  
  
   \boldsymbol{h}_{t}
  
 
ht​ 是 
 
  
   
    t
   
  
  
   t
  
 
t 时刻的隐层状态，
 
  
   
    
     x
    
    
     t
    
   
  
  
   \boldsymbol{x}_{t}
  
 
xt​ 是 
 
  
   
    t
   
  
  
   t
  
 
t 时刻的输入。下标 
 
  
   
    i
   
  
  
   i
  
 
i 是 
 
  
   
    i
   
   
    n
   
   
    p
   
   
    u
   
   
    t
   
  
  
   input
  
 
input 的简写，下标 
 
  
   
    h
   
  
  
   h
  
 
h 是 
 
  
   
    h
   
   
    i
   
   
    d
   
   
    d
   
   
    e
   
   
    n
   
  
  
   hidden
  
 
hidden 的简写。
 
  
   
    W
   
   
    ,
   
   
    b
   
  
  
   {\bf W},\boldsymbol{b}
  
 
W,b 分别是权重和偏置。

二、前置知识

先回顾一下普通的神经网络，我们在训练它的过程中通常会投喂一小批量的数据。不妨设

    batch_size
   
   
    =
   
   
    N
   
  
  
   \text{batch\_size}=N
  
 
batch_size=N，则投喂的数据的形式为：
 
  
   
    
     X
    
    
     =
    
    
     
      
       [
      
      
       
        
         
          
           
            x
           
           
            1
           
           
            T
           
          
         
        
       
       
        
         
          
           ⋮
          
          
           
          
         
        
       
       
        
         
          
           
            x
           
           
            N
           
           
            T
           
          
         
        
       
      
      
       ]
      
     
     
      
       N
      
      
       ×
      
      
       d
      
     
    
   
   
     {\bf X}= \begin{bmatrix} \boldsymbol{x}_1^{\text T} \\ \vdots \\ \boldsymbol{x}_N^{\text T} \end{bmatrix}_{N\times d} 
   
  
 X=⎣⎢⎡​x1T​⋮xNT​​⎦⎥⎤​N×d​

其中

     x
    
    
     i
    
   
   
    =
   
   
    (
   
   
    
     x
    
    
     
      i
     
     
      1
     
    
   
   
    ,
   
   
    
     x
    
    
     
      i
     
     
      2
     
    
   
   
    ,
   
   
    ⋯
    
   
    ,
   
   
    
     x
    
    
     
      i
     
     
      d
     
    
   
   
    
     )
    
    
     T
    
   
  
  
   \boldsymbol{x}_i=(x_{i1},x_{i2},\cdots,x_{id})^{\text T}
  
 
xi​=(xi1​,xi2​,⋯,xid​)T 为特征向量，维数为 
 
  
   
    d
   
  
  
   d
  
 
d。

在处理序列问题中，我们会将词元转化成对应的特征向量。例如在处理一个英文句子时，我们通常会通过某种手段将每个单词转化为合适的特征向量。设序列（句子）长度为

    L
   
  
  
   L
  
 
L，于是在此情景下，一个句子可以表示为：
 
  
   
    
     
      seq
     
     
      i
     
    
    
     =
    
    
     
      
       [
      
      
       
        
         
          
           
            x
           
           
            
             i
            
            
             1
            
           
           
            T
           
          
         
        
       
       
        
         
          
           ⋮
          
          
           
          
         
        
       
       
        
         
          
           
            x
           
           
            
             i
            
            
             L
            
           
           
            T
           
          
         
        
       
      
      
       ]
      
     
     
      
       L
      
      
       ×
      
      
       d
      
     
    
   
   
     \text{seq}_i= \begin{bmatrix} \boldsymbol{x}_{i1}^{\text T} \\ \vdots \\ \boldsymbol{x}_{iL}^{\text T} \end{bmatrix}_{L\times d} 
   
  
 seqi​=⎣⎢⎡​xi1T​⋮xiLT​​⎦⎥⎤​L×d​

其中的每个

     x
    
    
     
      i
     
     
      j
     
    
   
   
    ,
     
   
    j
   
   
    =
   
   
    1
   
   
    ,
   
   
    ⋯
    
   
    ,
   
   
    L
   
  
  
   \boldsymbol{x}_{ij},\;j=1,\cdots, L
  
 
xij​,j=1,⋯,L 都对应了句子 
 
  
   
    
     seq
    
    
     i
    
   
  
  
   \text{seq}_i
  
 
seqi​ 中的一个单词。在上述约定下，我们**在 
 
  
   
    
     t
    
   
   
    t
   
  
 t 时刻**投喂给RNN的数据为：
 
  
   
    
     
     
      
       
        
         X
        
        
         t
        
       
       
        =
       
       
        
         
          [
         
         
          
           
            
             
              
               x
              
              
               
                1
               
               
                t
               
              
              
               T
              
             
            
           
          
          
           
            
             
              ⋮
             
             
              
             
            
           
          
          
           
            
             
              
               x
              
              
               
                N
               
               
                t
               
              
              
               T
              
             
            
           
          
         
         
          ]
         
        
        
         
          N
         
         
          ×
         
         
          d
         
        
       
      
     
     
     
      
       (2)
      
     
    
   
   
     {\bf X}_t= \begin{bmatrix} \boldsymbol{x}_{1t}^{\text T} \\ \vdots \\ \boldsymbol{x}_{Nt}^{\text T} \end{bmatrix}_{N\times d}\tag{2} 
   
  
 Xt​=⎣⎢⎡​x1tT​⋮xNtT​​⎦⎥⎤​N×d​(2)

从而

    (
   
   
    1
   
   
    )
   
  
  
   (1)
  
 
(1) 式改写为
 
  
   
    
     
     
      
       
        
         H
        
        
         t
        
       
       
        =
       
       
        tanh
       
       
        ⁡
       
       
        (
       
       
        
         X
        
        
         t
        
       
       
        
         W
        
        
         
          i
         
         
          h
         
        
       
       
        +
       
       
        
         b
        
        
         
          i
         
         
          h
         
        
       
       
        +
       
       
        
         H
        
        
         
          t
         
         
          −
         
         
          1
         
        
       
       
        
         W
        
        
         
          h
         
         
          h
         
        
       
       
        +
       
       
        
         b
        
        
         
          h
         
         
          h
         
        
       
       
        )
       
      
     
     
     
      
       (3)
      
     
    
   
   
     {\bf H}_t=\tanh({\bf X}_t{\bf W}_{ih}+\boldsymbol{b}_{ih}+{\bf H}_{t-1}{\bf W}_{hh}+\boldsymbol{b}_{hh})\tag{3} 
   
  
 Ht​=tanh(Xt​Wih​+bih​+Ht−1​Whh​+bhh​)(3)

其中

     H
    
    
     t
    
   
   
    ,
   
   
    
     H
    
    
     
      t
     
     
      −
     
     
      1
     
    
   
  
  
   {\bf H}_t,{\bf H}_{t-1}
  
 
Ht​,Ht−1​ 的形状为 
 
  
   
    N
   
   
    ×
   
   
    h
   
  
  
   N\times h
  
 
N×h，
 
  
   
    
     W
    
    
     
      i
     
     
      h
     
    
   
  
  
   {\bf W}_{ih}
  
 
Wih​ 的形状为 
 
  
   
    d
   
   
    ×
   
   
    h
   
  
  
   d\times h
  
 
d×h，
 
  
   
    
     W
    
    
     
      h
     
     
      h
     
    
   
  
  
   {\bf W}_{hh}
  
 
Whh​ 的形状为 
 
  
   
    h
   
   
    ×
   
   
    h
   
  
  
   h\times h
  
 
h×h，
 
  
   
    
     b
    
    
     
      i
     
     
      h
     
    
   
   
    ,
   
   
    
     b
    
    
     
      h
     
     
      h
     
    
   
  
  
   \boldsymbol{b}_{ih},\boldsymbol{b}_{hh}
  
 
bih​,bhh​ 的形状为 
 
  
   
    1
   
   
    ×
   
   
    h
   
  
  
   1\times h
  
 
1×h，求和时利用广播机制。

在

nn.RNN

中，我们是一次性将所有时刻的数据全部投喂进去，数据形式为：

     X
    
    
     =
    
    
     [
    
    
     
      seq
     
     
      1
     
    
    
     ,
    
    
     
      seq
     
     
      2
     
    
    
     ,
    
    
     ⋯
     
    
     ,
    
    
     
      seq
     
     
      N
     
    
    
     
      ]
     
     
      
       N
      
      
       ×
      
      
       L
      
      
       ×
      
      
       d
      
     
    
    
    
     or
    
    
    
     X
    
    
     =
    
    
     [
    
    
     
      X
     
     
      1
     
    
    
     ,
    
    
     
      X
     
     
      2
     
    
    
     ,
    
    
     ⋯
     
    
     ,
    
    
     
      X
     
     
      L
     
    
    
     
      ]
     
     
      
       L
      
      
       ×
      
      
       N
      
      
       ×
      
      
       d
      
     
    
   
   
     {\bf X}=[\text{seq}_1,\text{seq}_2,\cdots,\text{seq}_N]_{N\times L\times d}\quad\text{or}\quad {\bf X}=[{\bf X}_1,{\bf X}_2,\cdots,{\bf X}_L]_{L\times N\times d} 
   
  
 X=[seq1​,seq2​,⋯,seqN​]N×L×d​orX=[X1​,X2​,⋯,XL​]L×N×d​

其中左边代表

batch_first=True

的情形，右边代表

batch_first=False

的情形。

注意： 在一个 batch 中，所有 sequence 的长度要保持相同，即

     L
    
   
   
    L
   
  
 L 需一致。

三、解析

3.1 所有参数

有了前置知识后，我们就能很方便的解释这些参数了。

• input_size：即 d d d；
• hidden_size：即 h h h；
• num_layers：即RNN的层数。默认是 1 1 1 层。该参数大于 1 1 1 时，会形成 Stacked RNN，又称多层RNN或深度RNN；
• nonlinearity：即非线性激活函数。可以选择 tanh 或 relu，默认是 tanh；
• bias：即偏置。默认启用，可以选择关闭；
• batch_first：即是否选择让 batch_size 作为输入的形状中的第一个参数。当 batch_first=True 时，输入应具有 N × L × d N\times L\times d N×L×d 这样的形状，否则应具有 L × N × d L\times N\times d L×N×d 这样的形状。默认是 False；
• dropout：即是否启用 dropout。如要启用，则应设置 dropout 的概率，此时除最后一层外，RNN的每一层后面都会加上一个dropout层。默认是 0 0 0，即不启用；
• bidirectional：即是否启用双向RNN，默认关闭。

3.2 输入参数

这里我们只考虑有 batch 的情况。

当

batch_first=True

时，输入

input

应具有形状

    N
   
   
    ×
   
   
    L
   
   
    ×
   
   
    d
   
  
  
   N\times L\times d
  
 
N×L×d，否则应具有形状 
 
  
   
    L
   
   
    ×
   
   
    N
   
   
    ×
   
   
    d
   
  
  
   L\times N\times d
  
 
L×N×d。

h_0

为初始时刻的隐状态。当RNN为单向RNN时，

h_0

的形状应为

    num_layers
   
   
    ×
   
   
    N
   
   
    ×
   
   
    h
   
  
  
   \text{num\_layers}\times N\times h
  
 
num_layers×N×h；当RNN为双向RNN时，

h_0

的形状应为

    (
   
   
    2
   
   
    ⋅
   
   
    num_layers
   
   
    )
   
   
    ×
   
   
    N
   
   
    ×
   
   
    h
   
  
  
   (2\cdot \text{num\_layers})\times N\times h
  
 
(2⋅num_layers)×N×h。如不提供该参数的值，则默认为全0张量。

3.3 输出参数

这里我们只考虑有 batch 的情况。

当RNN为单向RNN时：若

batch_first=True

，输出

output

具有形状

    N
   
   
    ×
   
   
    L
   
   
    ×
   
   
    h
   
  
  
   N\times L\times h
  
 
N×L×h，否则具有形状 
 
  
   
    L
   
   
    ×
   
   
    N
   
   
    ×
   
   
    h
   
  
  
   L\times N\times h
  
 
L×N×h。当 

batch_first=False

时，

output[t, :, :]

代表时刻

    t
   
  
  
   t
  
 
t 时，RNN最后一层（之所以用最后一层这个术语是因为有可能出现Stacked RNN情形）的输出 
 
  
   
    
     h
    
    
     t
    
   
  
  
   \boldsymbol{h}_t
  
 
ht​。

h_n

代表最终的隐状态，形状为

    num_layers
   
   
    ×
   
   
    N
   
   
    ×
   
   
    h
   
  
  
   \text{num\_layers}\times N\times h
  
 
num_layers×N×h。

当RNN为双向RNN时：若

batch_first=True

，输出

output

具有形状

    N
   
   
    ×
   
   
    L
   
   
    ×
   
   
    2
   
   
    h
   
  
  
   N\times L\times 2h
  
 
N×L×2h，否则具有形状 
 
  
   
    L
   
   
    ×
   
   
    N
   
   
    ×
   
   
    2
   
   
    h
   
  
  
   L\times N\times 2h
  
 
L×N×2h。

h_n

的形状为

    (
   
   
    2
   
   
    ⋅
   
   
    num_layers
   
   
    )
   
   
    ×
   
   
    N
   
   
    ×
   
   
    h
   
  
  
   (2\cdot \text{num\_layers})\times N\times h
  
 
(2⋅num_layers)×N×h。

事实上，对于单向RNN，有

     output
    
    
     =
    
    
     [
    
    
     
      H
     
     
      1
     
    
    
     ,
    
    
     
      H
     
     
      2
     
    
    
     ,
    
    
     ⋯
     
    
     ,
    
    
     
      H
     
     
      L
     
    
    
     
      ]
     
     
      
       L
      
      
       ×
      
      
       N
      
      
       ×
      
      
       h
      
     
    
    
     ,
    
    
    
     h_n
    
    
     =
    
    
     [
    
    
     
      H
     
     
      L
     
    
    
     
      ]
     
     
      
       1
      
      
       ×
      
      
       N
      
      
       ×
      
      
       h
      
     
    
   
   
     \text{output}=[{\bf H}_1,{\bf H}_2,\cdots,{\bf H}_L]_{L\times N\times h},\quad \text{h\_n}=[{\bf H}_L]_{1\times N\times h} 
   
  
 output=[H1​,H2​,⋯,HL​]L×N×h​,h_n=[HL​]1×N×h​

四、通过例子来进一步理解 nn.RNN

以单隐层单向RNN为例（接下来的例子都默认

batch_first=False

）。

假设有一个英文句子：

He ate an apple.

，忽略

.

并设置词元为单词（word）时，该序列的长度为

    4
   
  
  
   4
  
 
4。简便起见，我们假设每个词元都对应了一个 
 
  
   
    6
   
  
  
   6
  
 
6 维的特征向量，则上述的序列可写成：

import torch
import torch.nn as nn
torch.manual_seed(42)
seq = torch.randn(4,6)# 只是为了举例print(seq)# tensor([[ 1.9269,  1.4873,  0.9007, -2.1055,  0.6784, -1.2345],#         [-0.0431, -1.6047,  0.3559, -0.6866, -0.4934,  0.2415],#         [-1.1109,  0.0915, -2.3169, -0.2168, -0.3097, -0.3957],#         [ 0.8034, -0.6216, -0.5920, -0.0631, -0.8286,  0.3309]])

将这个句子视为一个 batch，即（注意形状为

    L
   
   
    ×
   
   
    N
   
   
    ×
   
   
    d
   
  
  
   L\times N\times d
  
 
L×N×d）：

inputs = seq.unsqueeze(1)print(inputs)# tensor([[[ 1.9269,  1.4873,  0.9007, -2.1055,  0.6784, -1.2345]],#         [[-0.0431, -1.6047,  0.3559, -0.6866, -0.4934,  0.2415]],#         [[-1.1109,  0.0915, -2.3169, -0.2168, -0.3097, -0.3957]],#         [[ 0.8034, -0.6216, -0.5920, -0.0631, -0.8286,  0.3309]]])print(inputs.shape)# torch.Size([4, 1, 6])

有了

inputs

，我们还需要初始化隐状态

h_0

，不妨设

    h
   
   
    =
   
   
    3
   
  
  
   h=3
  
 
h=3：

h_0 = torch.randn(1,1,3)print(h_0)# tensor([[[ 1.3525,  0.6863, -0.3278]]])

接下来创建RNN层，事实上只需要输入

input_size

和

hidden_size

即可：

rnn = nn.RNN(6,3)

观察输出：

outputs, h_n = rnn(inputs, h_0)print(outputs)# tensor([[[-0.5428,  0.9207,  0.7060]],#         [[-0.2245,  0.2461, -0.4578]],#         [[ 0.5950, -0.3390, -0.4598]],#         [[ 0.9281, -0.7660,  0.5954]]], grad_fn=<StackBackward0>)print(h_n)# tensor([[[ 0.9281, -0.7660,  0.5954]]], grad_fn=<StackBackward0>)

五、从零开始手写一个单隐层单向RNN

首先写好框架：

classRNN(nn.Module):def__init__(self, input_size, hidden_size):super().__init__()passdefforward(self, inputs, h_0):pass

我们的计算遵循

    (
   
   
    3
   
   
    )
   
  
  
   (3)
  
 
(3) 式，即：
 
  
   
    
     
      H
     
     
      t
     
    
    
     =
    
    
     tanh
    
    
     ⁡
    
    
     (
    
    
     
      X
     
     
      t
     
    
    
     
      W
     
     
      
       i
      
      
       h
      
     
    
    
     +
    
    
     
      b
     
     
      
       i
      
      
       h
      
     
    
    
     +
    
    
     
      H
     
     
      
       t
      
      
       −
      
      
       1
      
     
    
    
     
      W
     
     
      
       h
      
      
       h
      
     
    
    
     +
    
    
     
      b
     
     
      
       h
      
      
       h
      
     
    
    
     )
    
   
   
     {\bf H}_t=\tanh({\bf X}_t{\bf W}_{ih}+\boldsymbol{b}_{ih}+{\bf H}_{t-1}{\bf W}_{hh}+\boldsymbol{b}_{hh}) 
   
  
 Ht​=tanh(Xt​Wih​+bih​+Ht−1​Whh​+bhh​)

classRNN(nn.Module):def__init__(self, input_size, hidden_size):super().__init__()
        self.W_ih = torch.randn(input_size, hidden_size)
        self.W_hh = torch.randn(hidden_size, hidden_size)
        self.b_ih = torch.randn(1, hidden_size)
        self.b_hh = torch.randn(1, hidden_size)defforward(self, inputs, h_0):
        L, N, d = inputs.shape  # 分别对应序列长度、批量大小和特征维度
        H = h_0[0]# 因为h_0的形状为(1,N,h)，我们需要使用(N,h)去计算
        outputs =[]# 用来存储h_1,h_2,...,h_Lfor t inrange(L):
            X_t = inputs[t]
            H = torch.tanh(X_t @ self.W_ih + self.b_ih + H @ self.W_hh + self.b_hh)
            outputs.append(H)
        h_n = outputs[-1].unsqueeze(0)# h_n实际上就是h_L，但此时的形状为(N,h)
        outputs = torch.cat(outputs,0).unsqueeze(1)return outputs, h_n

为了检验我们的RNN是正确的，我们需要使用相同的输入来验证我们的输出是否与之前的一致。

torch.manual_seed(42)
seq = torch.randn(4,6)
inputs = seq.unsqueeze(1)
h_0 = torch.randn(1,1,3)# 保持RNN内部参数：权重和偏置一致
rnn = nn.RNN(6,3)
params =[param.data.T for param in rnn.parameters()]
my_rnn = RNN(6,3)
my_rnn.W_ih = params[0]
my_rnn.W_hh = params[1]
my_rnn.b_ih[0]= params[2]
my_rnn.b_hh[0]= params[3]
outputs, h_n = my_rnn(inputs, h_0)print(outputs)# tensor([[[-0.5428,  0.9207,  0.7060]],#         [[-0.2245,  0.2461, -0.4578]],#         [[ 0.5950, -0.3390, -0.4598]],#         [[ 0.9281, -0.7660,  0.5954]]])print(h_n)# tensor([[[ 0.9281, -0.7660,  0.5954]]])

可以看出结果与之前的一致，这说明我们构造的RNN是正确的。

最后

博主才疏学浅，如有错误请在评论区指出，感谢！