Pytorch：RNN、LSTM、GRU

日萌社

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）

---

#模型中最后一层隐藏层的最后一个时间步(节点)的输出output可作为预测值，然后通过softmax把output输出转换为概率值
#for循环遍历出来的input可以是字符，也可以是单词，那么模型可以是字符输入版本，也可以是单词输入版本
for input in range(lines):
	output, hidden = RNN实例对象(input, hidden)
	output, hidden = GRU实例对象(input, hidden)
	output, (hidden, cn) = LSTM实例对象(input, (hidden, cn)) 
	encoder_output, encoder_hidden = encoder(encoder_input, encoder_hidden)
	decoder_output, decoder_hidden, decoder_attention = decoder(decoder_input, decoder_hidden, encoder_outputs)

# nn.RNN(输入数据的词嵌入维度input_size, 隐藏层中神经元数量hidden_size, 隐藏层层数num_layers)
rnn = nn.RNN(5, 6, 2)
gru = nn.GRU(5, 6, 2)
lstm = nn.LSTM(5, 6, 2)
	input_size: 每一个时步(time_step)输入到RNN/GRU/LSTM单元的维度，实际输入的数据shape为(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度)
	hidden_size: 确定了隐含状态hidden_state的维度，可以简单的看成构造了一个可学习输入隐藏权重的形状(hidden_size, input_size)

weight_ih: 
    可学习输入隐藏权重的形状(hidden_size, input_size)
    每个单词 的嵌入维度的 向量 作为 一个时间步 输入到 一个 RNN 节点，
    然后 会和 神经元数量维度的 向量 构成一个 可学习输入隐藏权重 这样的 形状 (hidden_size, input_size)，
    就是 (神经元数量, 单词嵌入维度)。
    比如input输入数据为(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度)，
    那么input_size即为input输入数据的最后一个维度即词嵌入维度，
    那么每个时间步的输入维度input_size(一个单词的词嵌入维度embedding_dim) 都要作用于 隐藏层的所有隐藏神经元hidden_size， 
    那么便会构建一个(hidden_size, input_size)形状的可学习输入隐藏权重。
    
def __init__(self, mode, input_size, hidden_size, 
                    num_layers=1, bias=True, batch_first=False, dropout=0., 
                    bidirectional=False):
    #默认值bidirectional=False：那么“2 if False else 1”返回1，“2 if True else 1”返回2。
    #如果RNN是双向的，num_directions应该是2，否则应该是1。
    num_directions = 2 if bidirectional else 1                    
        
========================================================================
# nn.RNN(输入数据的词嵌入维度, 隐藏层中神经元数量, 隐藏层层数)
rnn = nn.RNN(5, 6, 2)
gru = nn.GRU(5, 6, 2)
lstm = nn.LSTM(5, 6, 2)

# input of shape (seq_len, batch, input_size)：(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度)
# input输入数据，torch.randn(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度)
input = torch.randn(4, 3, 5)

# h_0 of shape (num_layers * num_directions, batch, hidden_size)：
#	RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)	
#	RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)	
# hn隐藏层数据，torch.randn(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)
h0 = torch.randn(2, 3, 6)

# c_0 of shape (num_layers * num_directions, batch, hidden_size) 
#	RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)	
#	RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)	
c0 = torch.randn(2, 3, 6)

output, hn = rnn(input, h0)
output, (hn, cn) = rnn(input, (h0, c0))

# output of shape (seq_len, batch, num_directions * hidden_size):
#	RNN是单向：(当前批次的样本个数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量 * 1)	
#	RNN是双向：(当前批次的样本个数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量 * 2)		
output.shape #torch.Size([4, 3, 6])

# h_n of shape (num_layers * num_directions, batch, hidden_size)
#	RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)	
#	RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)	
hn.shape #torch.Size([2, 3, 6])

# c_n of shape (num_layers * num_directions, batch, hidden_size)
#	RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)	
#	RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)
hn.shape #torch.Size([2, 3, 6])
 

Examples::
    #nn.LSTM(输入数据的词嵌入维度 10, 隐藏层中神经元数量 20, 隐藏层层数 2)
    >>> rnn = nn.LSTM(10, 20, 2)
    #input输入数据，torch.randn(当前批次的样本个数 5, 当前样本的序列长度(单词个数) 3, 词嵌入维度 10)
    >>> input = torch.randn(5, 3, 10)
    #h0/hn隐藏层数据，torch.randn(隐藏层层数 2, 当前样本的序列长度(单词个数) 3, 隐藏层中神经元数量 20)
    >>> h0 = torch.randn(2, 3, 20)
    #c0/cn细胞状态数据，torch.randn(隐藏层层数 2, 当前样本的序列长度(单词个数) 3, 隐藏层中神经元数量 20)
    >>> c0 = torch.randn(2, 3, 20)
    >>> output, (hn, cn) = rnn(input, (h0, c0))

LSTM输出API为：output,(h_n,c_n)=self.rnn(x)
	1.output: 如果num_layer为3，则output只记录最后一层(即第三层)的输出
		对应图中向上的各个time_step的ht，也即output。
		(seq_len, batch, num_directions * hidden_size)：
			RNN是单向：(当前批次的样本个数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量 * 1)	
			RNN是双向：(当前批次的样本个数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量 * 2)		
 
	2.h_n: 各个层的最后一个时步的隐含状态h
		shape为[num_layers, batch_size, hidden_size]。
		(num_layers * num_directions, batch, hidden_size)
			RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)	
			RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)
 
	3.c_n: 各个层的最后一个时步的隐含状态C
		c_n可以看成另一个隐含状态，其shape和h_n的shape相同。
 		(num_layers * num_directions, batch, hidden_size)
			RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)	
			RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)

---

RNN

weight_ih: 
    可学习输入隐藏权重的形状(hidden_size, input_size)
    每个单词 的嵌入维度的 向量 作为 一个时间步 输入到 一个 RNN 节点，
    然后 会和 神经元数量维度的 向量 构成一个 可学习输入隐藏权重 这样的 形状 (hidden_size, input_size)，
    就是 (神经元数量, 单词嵌入维度)。

nn.RNN(输入数据的词嵌入维度, 隐藏层中神经元数量, 隐藏层层数)
Xt：输入数据，shape为(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度影)，比如[1,3,5]。
h0：隐藏层数据，shape为(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)，比如[1,3,6]。
[Xt,ht-1]：通过concat(Xt,ht-1)把[1,3,5]和[1,3,6]进行列维度(最后一个维度)的拼接变成[1,3,11]。
Wt[Xt,ht-1]：concat拼接后的[1,3,11]乘以Wt的[11,6]变成[1,3,6]。
output是hn隐藏层中的最后一层输出，比如：
	当隐藏层只有一层时，rnn的输出output和隐藏层数据hn 两者完全相同，shape均为[1,3,6]。
	当隐藏层有多层时，rnn的输出output为隐藏层数据hn中的最后一个二维矩阵，比如hn为[2,3,6]，output的数据实际为hn中最后一个二维矩阵[1,3,6]。

---

LSTM

1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
  只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如此处的遗忘门中的通过sigmiod输出的ft便是一个0和1之间的小数值，ft用作在“细胞状态更新公式”中的ft*Ct-1，
  因为ft本身就是一个0和1之间的小数值(相当于一个百分比值)，那么ft*Ct-1表示使用ft这个百分值保留多少Ct-1的值。

1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
  只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如此处输入门中的通过sigmiod输出的it便是一个0和1之间的小数值，it用作在“细胞状态更新公式”中的it*Ct~，
  因为it本身就是一个0和1之间的小数值(相当于一个百分比值)，那么it*Ct~表示使用it这个百分值保留多少Ct~的值。

1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
  只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如输入门中的通过sigmiod输出的it便是一个0和1之间的小数值，it用作在“细胞状态更新公式”中的it*Ct~，
  因为it本身就是一个0和1之间的小数值(相当于一个百分比值)，那么it*Ct~表示使用it这个百分值保留多少Ct~的值。
3.比如遗忘门中的通过sigmiod输出的ft便是一个0和1之间的小数值，ft用作在“细胞状态更新公式”中的ft*Ct-1，
  因为ft本身就是一个0和1之间的小数值(相当于一个百分比值)，那么ft*Ct-1表示使用ft这个百分值保留多少Ct-1的值。

1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
  只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如此处输出门中的通过sigmiod输出的ot便是一个0和1之间的小数值，ot用作在“输出门更新公式”中的ot*tanh(Ct)，
  因为ot本身就是一个0和1之间的小数值(相当于一个百分比值)，那么ot*tanh(Ct)表示使用ot这个百分值保留多少tanh(Ct)的值。

---

GRU