循环神经网络实现文本情感分类之Pytorch中LSTM和GRU模块使用

1. Pytorch中LSTM和GRU模块使用

1.1 LSTM介绍

LSTM和GRU都是由torch.nn提供

通过观察文档，可知LSTM的参数，

torch.nn.LSTM(input_size,hidden_size,num_layers,batch_first,dropout,bidirectional)

input_size：输入数据的形状，即embedding_dim
hidden_size：隐藏层神经元的数量，即每一层有多少个LSTM单元【自己设置的】
num_layer ：即RNN中的LSTM单元的层数
batch_first：默认值为False，输入的数据需要[seq_len,batch,feature],如果为True，则为[batch,seq_len,feature]
dropout:dropout的比例，默认值为0。dropout是一种训练过程中让部分参数随机失活的一种方式，能够提高训练速度，同时能够解决过拟合的问题。这里是在LSTM的最后一层，对每个输出进行dropout 【失活即参数不会更新】
bidirectional：是否使用双向LSTM,默认是False

【例：torch.nn.LSTM(input_size=emebedding_dim, hidden_size=lstm单元的个数,num_layers=层数,batch_first=数据中batch_size是否在第一个维度)】

实例化LSTM对象之后,不仅需要传入数据，还需要前一次的h_0(前一次的隐藏状态)和c_0（前一次memory）

即：lstm(input,(h_0,c_0))

LSTM的默认输出为output, (h_n, c_n) 【和的形状一样，和的形状也是一样的】

output：(seq_len, batch, num_directions * hidden_size)--->batch_first=False
h_n:(num_layers * num_directions, batch, hidden_size)
c_n: (num_layers * num_directions, batch, hidden_size) 【nun_directions为1或2，单向为1，双向为2】

【output:把每个实时间步上的结果在seq_len这一维度进行了拼接；：把不同层的隐藏状态在第0个维度上进行了拼接】

1.2 LSTM使用示例

假设数据输入为 input ,形状是[10,20]，假设embedding的形状是[100,30]

则LSTM使用示例如下：

import torchbatch_size = 10  # 句子的数量
seq_len = 20  # 每个句子的长度
embedding_dim = 30  # 用长度为30的向量表示一个词语
word_vocab = 100  # 词典的数量
hidden_size = 18  # 隐藏层中lstm的个数
num_layer = 2  # 多少个隐藏层#  准备输入数据，构造一个batch的数据
in_put = torch.randint(low=0, high=100, size=(batch_size, seq_len))#  准备embedding
embedding = torch.nn.Embedding(word_vocab, embedding_dim)  # 把embedding之后的数据传入lstm
lstm = torch.nn.LSTM(embedding_dim, hidden_size, num_layer)#  进行mebed操作
embed = embedding(in_put)  # [10, 20, 30]
# print(embed)#  转化数据为batch_first=False
embed = embed.permute(1, 0, 2)  # [20, 10, 30]
print(embed)#  初始化状态，如果不初始化，torch默认初始值为全0
h_0 = torch.rand(num_layer, batch_size, hidden_size)
c_0 = torch.rand(num_layer, batch_size, hidden_size)
out_put, (h_1, c_1) = lstm(embed, (h_0, c_0))print(out_put.size())
print(h_1.size())
print(c_1.size())#  获取最后一个时间步上的输出
last_output = out_put[-1, :, :]
print(last_output.size())#  获取最后一次的hidden_state
last_hidden_state = h_1[-1, :, :]
print(last_hidden_state.size())
print(last_hidden_state)#  通过前面的学习，我们知道，最后一次的h_1应该和output的最后一个time step的输出是一样的
# 通过下面的代码，我们来验证一下：
print(last_output == last_hidden_state)

运行结果：

1.3 GRU的使用示例

GRU模块torch.nn.GRU，和LSTM的参数相同，含义相同，具体可参考文档

但是输入只剩下gru(input,h_0)，输出为output, h_n

其形状为：

output:(seq_len, batch, num_directions * hidden_size)
h_n:(num_layers * num_directions, batch, hidden_size)

大家可以使用上述代码，观察GRU的输出形式

【gru=torch.nn.GRU(embedding_dim,hidden_size,num_layer) gru_output,gru_h_1=gru(embed,h_0)】

1.4 双向LSTM

如果需要使用双向LSTM，则在实例化LSTM的过程中，需要把LSTM中的bidriectional设置为True，同时h_0和c_0使用num_layer*2

观察效果，输出为

import torchbatch_size = 10  # 句子的数量
seq_len = 20  # 每个句子的长度
embedding_dim = 30  # 用长度为30的向量表示一个词语
word_vocab = 100  # 词典的数量
hidden_size = 18  # 隐藏层中lstm的个数
num_layer = 2  # 多少个隐藏层#  准备输入数据，构造一个batch的数据
in_put = torch.randint(low=0, high=100, size=(batch_size, seq_len))#  准备embedding
embedding = torch.nn.Embedding(word_vocab, embedding_dim)  # 把embedding之后的数据传入lstm
lstm = torch.nn.LSTM(embedding_dim, hidden_size, num_layer, bidirectional=True)#  进行mebed操作
embed = embedding(in_put)  # [10, 20, 30]
# print(embed)#  转化数据为batch_first=False
embed = embed.permute(1, 0, 2)  # [20, 10, 30]
print(embed)#  初始化状态，如果不初始化，torch默认初始值为全0
h_0 = torch.rand(num_layer * 2, batch_size, hidden_size)
c_0 = torch.rand(num_layer * 2, batch_size, hidden_size)
out_put, (h_1, c_1) = lstm(embed, (h_0, c_0))print(out_put.size())
print(h_1.size())
print(c_1.size())#  获取最后一个时间步上的输出
last_output = out_put[-1, :, :]
print(last_output.size())#  获取最后一次的hidden_state
last_hidden_state = h_1[-1, :, :]
print(last_hidden_state.size())
print(last_hidden_state)

运行结果：

在单向LSTM中，最后一个time step的输出的前hidden_size个和最后一层隐藏状态h_1的输出相同，那么双向LSTM呢？

双向LSTM中：

output：按照正反计算的结果顺序在第2个维度进行拼接，正向第一个拼接反向的最后一个输出

hidden state:按照得到的结果在第0个维度进行拼接，正向第一个之后接着是反向第一个

前向的LSTM中，最后一个time step的输出的前hidden_size个和最后一层向前传播h_1的输出相同

示例：

#  正向
# -1是前向LSTM的最后一个，前18是前hidden_size个
#  获取双向LSTM中正向的最后一个时间步的output
a = out_put[-1, :, :18]  # 前项LSTM中最后一个time step的output
print(a.size())
#  获取双向LSTM中正向的最后一个hidden_state
b = h_1[-2, :, :]  # 倒数第二个为前向
print(b.size())
print(a == b)

运行结果：

2.后向LSTM中，最后一个time step的输出的后hidden_size个和最后一层后向传播的h_1的输出相同

示例：

#  反向
# 0 是反向LSTM的最后一个，后18是后hidden_size个
c = out_put[0, :, 18:]  # 后向LSTM中的最后一个输出
print(c.size())
d = h_1[-1, :, :]  # 后向LSTM中的最后一个隐藏层状态
print(d.size())
print(c == d)

运行结果：

1.4 LSTM和GRU的使用注意点

第一次调用之前，需要初始化隐藏状态，如果不初始化，默认创建全为0的隐藏状态
往往会使用LSTM or GRU 的输出的最后一维的结果，来代表LSTM、GRU对文本处理的结果，其形状为[batch, num_directions*hidden_size]。【因为最后一维已经包含之前的结果啦】
1. 并不是所有模型都会使用最后一维的结果
2. 如果实例化LSTM的过程中，batch_first=False,则output[-1] or output[-1,:,:]可以获取最后一维
3. 如果实例化LSTM的过程中，batch_first=True,则output[:,-1,:]可以获取最后一维
如果结果是(seq_len, batch_size, num_directions * hidden_size),需要把它转化为(batch_size,seq_len, num_directions * hidden_size)的形状，不能够不是view等变形的方法，需要使用output.permute(1,0,2)，即交换0和1轴，实现上述效果【使用轴交换】
使用双向LSTM的时候，往往会分别使用每个方向最后一次的output，作为当前数据经过双向LSTM的结果
- 即：torch.cat([h_1[-2,:,:],h_1[-1,:,:]],dim=-1)
- 最后的表示的size是[batch_size,hidden_size*2]
上述内容在GRU中同理