深度学习框架pytorch RNN,LSTM,GRU

Recurrent layers

class torch.nn.RNN( args, * kwargs)(source)

将一个多层的 Elman RNN，激活函数为tanh或者ReLU，用于输入序列。

对输入序列中每个元素，RNN每层的计算公式为 $$h_t=tanh(w_{ih}{x}_t+b_{ih}+w_{hh}{h}_{t-1}+b_{hh})$$ $h_t$是时刻$t$的隐状态。 $x_t$是上一层时刻$t$的隐状态，或者是第一层在时刻$t$的输入。如果nonlinearity=‘relu’,那么将使用relu代替tanh作为激活函数。

参数说明:

• input_size – 输入x的特征数量。
• hidden_size – 隐层的特征数量。
• num_layers – RNN的层数。
• nonlinearity – 指定非线性函数使用tanh还是relu。默认是tanh。
• bias – 如果是False，那么RNN层就不会使用偏置权重 $b_{ih}$和$b_{hh}$,默认是True
• batch_first – 如果True的话，那么输入Tensor的shape应该是[batch_size, time_step, feature],输出也是这样。
• dropout – 如果值非零，那么除了最后一层外，其它层的输出都会套上一个dropout层。
• bidirectional – 如果True，将会变成一个双向RNN，默认为False。

RNN的输入： (input, $h_0$)

• input (seq_len, batch, input_size): 保存输入序列特征的tensor。input可以是被填充的变长的序列。细节请看torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first=False)source

• $h_0$ (num_layers * num_directions, batch, hidden_size): 保存着初始隐状态的tensor

RNN的输出： (output, $h_n$)

• output (seq_len, batch, hidden_size * num_directions): 保存着RNN最后一层的输出特征。如果输入是被填充过的序列，那么输出也是被填充的序列。
• $h_n$ (num_layers * num_directions, batch, hidden_size): 保存着最后一个时刻隐状态。

RNN模型参数:

• $weigh{t}_i{h}_l$[k] – 第k层的 input-hidden 权重， 可学习，形状是(input_size x hidden_size)。
• $weigh{t}_h{h}_l$[k] – 第k层的 hidden-hidden 权重， 可学习，形状是(hidden_size x hidden_size)
• $bia{s}_i{h}_l$[k] – 第k层的 input-hidden 偏置， 可学习，形状是(hidden_size)
• $bia{s}_h{h}_l$[k] – 第k层的 hidden-hidden 偏置， 可学习，形状是(hidden_size)

示例：

rnn = nn.RNN(10, 20, 2)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.randn(2, 3, 20))
output, hn = rnn(input, h0)

class torch.nn.LSTM( args, * kwargs)(source)

将一个多层的 (LSTM) 应用到输入序列。

对输入序列的每个元素，LSTM的每层都会执行以下计算： $$\begin{array}{rlrlrlr}{i}_t& =sigmoid(W_{ii}{x}_t+b_{ii}+W_{hi}{h}_{t-1}+b_{hi})f_t& =sigmoid(W_{if}{x}_t+b_{if}+W_{hf}{h}_{t-1}+b_{hf})o_t& =sigmoid(W_{io}{x}_t+b_{io}+W_{ho}{h}_{t-1}+b_{ho})g_t& =tanh(W_{ig}{x}_t+b_{ig}+W_{hg}{h}_{t-1}+b_{hg})c_t& =f_t{c}_{t-1}+i_t{g}_t{h}_t& =o_t\ast tanh(c_t)\end{array}$$ $h_t$是时刻$t$的隐状态,$c_t$是时刻$t$的细胞状态，$x_t$是上一层的在时刻$t$的隐状态或者是第一层在时刻$t$的输入。$i_t,f_t,g_t,o_t$ 分别代表 输入门，遗忘门，细胞和输出门。

参数说明:

• input_size – 输入的特征维度
• hidden_size – 隐状态的特征维度
• num_layers – 层数（和时序展开要区分开）
• bias – 如果为False，那么LSTM将不会使用$b_{ih},b_{hh}$，默认为True。
• batch_first – 如果为True，那么输入和输出Tensor的形状为(batch, seq, feature)
• dropout – 如果非零的话，将会在RNN的输出上加个dropout，最后一层除外。
• bidirectional – 如果为True，将会变成一个双向RNN，默认为False。

LSTM输入: input, ($h_0$,$c_0$)

• input (seq_len, batch, input_size): 包含输入序列特征的Tensor。也可以是packed variable ，详见 [pack_padded_sequence](#torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first=False[source])
• $h_0$ (num_layers * num_directions, batch, hidden_size):保存着batch中每个元素的初始化隐状态的Tensor
• $c_0$ (num_layers * num_directions, batch, hidden_size): 保存着batch中每个元素的初始化细胞状态的Tensor

LSTM输出 output, ($h_n$, $c_n$)

• output (seq_len, batch, hidden_size * num_directions): 保存RNN最后一层的输出的Tensor。 如果输入是torch.nn.utils.rnn.PackedSequence，那么输出也是torch.nn.utils.rnn.PackedSequence
• $h_n$ (num_layers * num_directions, batch, hidden_size): Tensor，保存着RNN最后一个时间步的隐状态。
• $c_n$ (num_layers * num_directions, batch, hidden_size): Tensor，保存着RNN最后一个时间步的细胞状态。

LSTM模型参数:

• $weigh{t}_i{h}_l$[k] – 第k层可学习的input-hidden权重($W_{ii}|W_{if}|W_{ig}|W_{io}$)，形状为(input_size x 4*hidden_size)
• $weigh{t}_h{h}_l$[k] – 第k层可学习的hidden-hidden权重($W_{hi}|W_{hf}|W_{hg}|W_{ho}$)，形状为(hidden_size x 4*hidden_size)。
• $bia{s}_i{h}_l$[k] – 第k层可学习的input-hidden偏置($b_{ii}|b_{if}|b_{ig}|b_{io}$)，形状为( 4*hidden_size)
• $bia{s}_h{h}_l$[k] – 第k层可学习的hidden-hidden偏置($b_{hi}|b_{hf}|b_{hg}|b_{ho}$)，形状为( 4*hidden_size)。

示例：

lstm = nn.LSTM(10, 20, 2)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.randn(2, 3, 20))
c0 = Variable(torch.randn(2, 3, 20))
output, hn = lstm(input, (h0, c0))

class torch.nn.GRU( args, * kwargs)(source)

将一个多层的GRU用于输入序列。
对输入序列中的每个元素，每层进行了一下计算：
$$\begin{array}{rlrlr}{r}_t& =sigmoid(W_{ir}{x}_t+b_{ir}+W_{hr}{h}_{(t-1)}+b_{hr})i_t& =sigmoid(W_{ii}{x}_t+b_{ii}+W_{hi}{h}_{(t-1)}+b_{hi})n_t& =tanh(W_{in}{x}_t+b_{in}+rt(W_{hn}{h}_{(t-1)}+b_{hn}))h_t& =(1-i_t)nt+i_t\ast h(t-1)\end{array}$$ $h_t$是是时间$t$的上的隐状态，$x_t$是前一层$t$时刻的隐状态或者是第一层的$t$时刻的输入，$r_t,i_t,n_t$分别是重置门，输入门和新门。

参数说明：

• input_size – 期望的输入$x$的特征值的维度
• hidden_size – 隐状态的维度
• num_layers – RNN的层数。
• bias – 如果为False，那么RNN层将不会使用bias，默认为True。
• batch_first – 如果为True的话，那么输入和输出的tensor的形状是(batch, seq, feature)。
• dropout – 如果非零的话，将会在RNN的输出上加个dropout，最后一层除外。
• bidirectional – 如果为True，将会变成一个双向RNN，默认为False。

GRU输入： （input, $h_0$)

• input (seq_len, batch, input_size): 包含输入序列特征的Tensor。也可以是packed variable ，详见 [pack_padded_sequence](#torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first=False[source])。
• $h_0$ (num_layers * num_directions, batch, hidden_size):保存着batch中每个元素的初始化隐状态的Tensor

GRU输出： (output, $h_n$)

• output (seq_len, batch, hidden_size * num_directions): ten保存RNN最后一层的输出的Tensor。 如果输入是torch.nn.utils.rnn.PackedSequence，那么输出也是torch.nn.utils.rnn.PackedSequence。
• $h_n$ (num_layers * num_directions, batch, hidden_size): Tensor，保存着RNN最后一个时间步的隐状态。

变量：

• $weigh{t}_i{h}_l$[k] – 第k层可学习的input-hidden权重($W_{ir}|W_{ii}|W_{in}$)，形状为(input_size x 3*hidden_size)
• $weigh{t}_h{h}_l$[k] – 第k层可学习的hidden-hidden权重($W_{hr}|W_{hi}|W_{hn}$)，形状为(hidden_size x 3*hidden_size)。
• $bia{s}_i{h}_l$[k] – 第k层可学习的input-hidden偏置($b_{ir}|b_{ii}|b_{in}$)，形状为( 3*hidden_size)
• $bia{s}_h{h}_l$[k] – 第k层可学习的hidden-hidden偏置($b_{hr}|b_{hi}|b_{hn}$)，形状为( 3*hidden_size)。

例子：

 rnn = nn.GRU(10, 20, 2)
 input = Variable(torch.randn(5, 3, 10))
 h0 = Variable(torch.randn(2, 3, 20))
 output, hn = rnn(input, h0)