前言
本文介绍了，循环神经网络（RNN），长短期记忆网络（LSTM），门循环控制单元（GRU）。这里顺便说了一下GRU-CNN并行网络和ABLSTM(基于注意力机制的双向LSTM网络)
一、RNN循环神经网络
卷积神经网络（CNN）只是对一个图片，或者一个样本进行特征提取，完全没有考虑到时序信息，前几刻的信息和这一刻信息的关联性。RNN模型的提出就解决了这个问题。
1.RNN模型介绍
RNN模型最重要的贡献就是引入了隐藏层，隐状态存储的都是前一些时刻的相关特征信息，也是隐状态让模型有了记忆的能力。计算公式就类似于线性层。
t时刻的H是由t-1时刻的H（也就是记忆的之前的信息），加上Xt（当前时刻的特征）
2.RNN模型pytorch代码实现
一个简单的rnn模型用pytorch实现起来很简单，主要是用nn.RNN加一个nn.Linear方法就可以实现。
这里需要注意的是RNN的几个常用的参数：
self.rnn = nn.RNN(input_size=self.num_input,hidden_size=self.num_hiddens,num_layers=self.num_layers,bidirectional=False,batch_first=True)
首先我们一般输入训练数据的特征X一般的维度特征是3个维度(batch_size,num_steps,input_features)
input_size : 也就是指的input_features，特征的维度。
hidden_size :隐藏层的神经元h的个数
num_layers: 隐藏层的层数（默认每个隐藏层里的神经元个数全都是hidden_size）
nonlinearity：激活函数
dropout：是否应用dropout, 默认不使用，如若使用将其设置成一个0-1的数字即可
batch_first:我们一般的数据传入都是(batch_size,num_steps,input_features)，也即是batch在第0维度，最前面，如果想这样直接扔进去进行RNN运算，batch_first需要设置为True，但是batch_first默认为False,需要我们利用permute函数，x=x.permute(1,0,2)把num_steps放在前面。
bidirectional：从前面的图片也可以看出，我们的RNN是单向，只能提取之前的信息，如果想提取双向的信息，这里需要把bidirectional设置为True。
说完了输入参数，在说一下输出。nn.RNN()的输出是一个元组(output, h_n)，其中output是所有批次，每一个时间步的最后一层隐状态，h_n是所有批次最后一个时间步所有隐藏态。h_n是最后一个时间步的输出。当batch_first设置为True时，output的形状为(batch_size, seq_length, hidden_size)，但是h_n的形状不会因为batch_first而改变为( num_layers * num_directions,batch_size, hidden_size)。
这两个信息，我们一般选择其一就可以提取需要的信息，经过线性层分类。
注意：代码中的倒数第二行out = self.fc(out.reshape(-1,out.shape[-1])) ，这里把out reshape 成(batch_size *num_steps,num_hiddens) ，这里的是每个以时间戳的特征x对应一个output，通过nn.Linear方法，输出最后变成(batch_size *num_steps,output_size)。
但是有时可能多个时间戳，才对应一个输出。（比如我最近在学习利用WIFI信号识别人体的动作，一个时间戳的信号肯定不可以对应一个输出，需要上百个时间戳才对应一个动作。）比如250个时间戳对应一个输出结果，我们只需要提取第250个时间戳里的最后一个对应的out，他包含之前全部时间戳的特征信息。
out= self.fc(out[:,-1,:]) #这里进行切片，对这个批次里的每个每组seq只提取最后一个时间步
class rnn_model(nn.Module): #这里来具体的实现RNN类
def __init__(self,voacb_size,num_hiddens,num_layers,**kwargs):
super(rnn_model,self).__init__(**kwargs)
self.num_input = voacb_size
self.num_output = voacb_size
self.num_hiddens = num_hiddens
self.num_layers = num_layers
#这里注意batch_first 就是维度放在第一维的是batch_size ,这样的设置在forward里就不要变换维度了
#但是需要注意batch_first = True 这个对隐藏态和细胞状态h和c的形状没有影响，其batch_size 都在第二维上
self.rnn = nn.RNN(input_size=self.num_input,hidden_size=self.num_hiddens,num_layers=self.num_layers,bidirectional=False,batch_first=True) #LSTM需要的参数,这里规定了输入的大小和规模
self.fc = nn.Linear(self.num_hiddens,self.num_output) #全连接层输出类别判断
def forward(self,X):
#需要注意下面的 out 是 h[-1]即为隐藏层的 整个序列的最后一层隐藏态
out,_ = self.rnn(X) #这里模型会自动给h0初始化zero,这里返回了out,这里的out时每一个元素对应的隐藏态的最后一层，而占位符对应的是最后的隐藏态这里的形状是（batch_sizes,num_layers×hidden_size)
#out,_ = self.lstm(X)
#out的形状是 batch_size *num _steps *num_hiddens
out = self.fc(out.reshape(-1,out.shape[-1])) #括号里面的形状变成，(batch_size *num_steps,num_hiddens)
return out
2.RNN模型一些问题
1.RNN模型容易发生梯度爆炸或者梯度消失，所有的数据公用Whx，这才进行反向传播计算梯度，会进行指数计算，导致梯度过大或者过小，导致模型训练效果不好。
为了应对这个问题，可以进行梯度裁剪。
梯度裁剪很容易理解
这里面的𝜃是给定的参数半径，下面的保证梯度的g不超过这𝜃,也就是把控制||g||<=𝜃
这个梯度裁剪用pytorch实现起来也很简单。
只需要每次l.backward()计算梯度后，使用nn.utils.clip_grad_norm_()方法，需要传入两个参数，一个是net的参数，一个是𝜃。
import torch
import torch.nn as nn
import torch.optim as optim
# 定义RNN模型
# 训练模型
num_epochs = 100
for epoch in range(num_epochs):
# 前向传播
outputs = model(x_train)
loss = criterion(outputs, y_train)
# 反向传播和梯度裁剪
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), clip) # 梯度裁剪
optimizer.step()
# 打印训练信息
if (epoch+1) % 10 == 0:
print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
# 预测
x_test = torch.tensor([[10, 11, 12]], dtype=torch.float32).unsqueeze(0)
y_pred = model(x_test)
print('Predicted value:', y_pred.item())
2.RNN模型的计算效率较低。由于RNN模型中的每个时间步都需要进行计算，使得模型的前向传播速度较慢。
3.RNN模型难以捕捉长期依赖关系。当序列长度较长时，RNN模型的记忆能力会逐渐减弱，导致难以建模长期依赖关系。
二、GRU门循环控制单元
GRU（Gate Recurrent Unit）是循环神经网络（RNN）的一种，可以解决RNN中不能长期记忆和反向传播中的梯度等问题，虽然比LSTM诞生的晚，但是相对简单。而且模型如其名。
1.GRU模型介绍
GRU模型和前面的RNN模型很像，包括输入特征、隐藏态、输出。但是又有了改进，主要改进了隐藏态H的计算方法，通过门控制隐状态。这里引进了门，就是数电那种逻辑电路。
这里引入了重置门和更新门，都是根据上一个时刻的隐藏态和t时刻的特征X计算得出。
GRU还引入了候选隐状态。可以从公式看出当Rt趋近于1时，就类似于前面说的RNN循环神经网络，当Rt趋近于0时候选隐状态的运算就想一层线性运算，整个网络也会想多层感知机靠近。
但是候选隐状态并不是最终的隐状态，每当更新门 𝐙𝑡 接近 1时，模型就倾向只保留旧状态。 此时，来自 𝐗𝑡的信息基本上被忽略， 从而有效地跳过了依赖链条中的时间步 𝑡 。 相反，当 𝐙𝑡接近 0 时， 新的隐状态 𝐇𝑡就会接近候选隐状态 𝐇̃ 𝑡。 这些设计可以帮助我们处理循环神经网络中的梯度消失问题， 并更好地捕获时间步距离很长的序列的依赖关系。 例如，如果整个子序列的所有时间步的更新门都接近于 1， 则无论序列的长度如何，在序列起始时间步的旧隐状态都将很容易保留并传递到序列结束。
可以看出
重置门有助于捕获序列中的短期依赖关系；
更新门有助于捕获序列中的长期依赖关系。
2.GRU模型pytorch实现
首先说一下nn.GRU()输入需要的参数和前面的RNN一模一样。
nn.GRU()的输出是一个元组(output, h_n)。如果batch_first为True，其中output是最后一个时间步的隐状态，h_n是最后一个时间步的输出。output的形状为(batch_size, seq_length, hidden_size)，h_n的形状为(num_layers * num_directions, batch_size, hidden_size)。这里的num_directions是表示GRU模型是单向的还是双向的。
关于nn.GRU的输出，可以说和前面的RNN一模一样。nn.GRU()的输出是一个元组(output, h_n)，其中output是最后一个时间步的隐状态，h_n是最后一个时间步的输出。output的形状为(batch_size, seq_length, hidden_size)，h_n的形状为(num_layers * num_directions, batch_size,hidden_size)。
import torch
from torch import nn
gru_layer = nn.GRU(input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
batch_first=True)
3.CNN-GRU串行网络
我们本篇介绍的RNN GRU LSTM都是处理序列关系、时间关系的时序模型。而CNN模型广泛应用于图像分类的特征提取领域。在某些预测问题中，单独使用CNN或时间学列模型可能无法充分挖掘数据的特征，因此我们需要将它们进行有效地融合。
CNN与循环网络可以连接成串行网络，也可以连接成并行网络。这里只介绍了和GRU的融合的网络，但是和其他序列的融合基本上是完全一样的，可以举一反三。
我们先说一下串行网络，其实很容易理解
数据集：这里用的CSI信号。可以简单理解input_size 250*90的数据，250代表时间戳，90代表一个时刻对应的特征，我们的目标是通过250个时间戳判断出人体的一种活动。
我们这里用一位卷积实现了一个self.encoder编码器，可以简单理解成encoder(CNN部分)进行了下采样，压缩了数据量，同时进行了特征提取。但是这里的时间通道维度并没有改变，我们可以直接把encoder输出的部分放入GRU模块提取时间特征。提取时间特征之后，把每个batch第250个时间戳对应的隐藏态的最后一层放入分类器，进行分类。
class CSI_serial_CNN_GRU(nn.Module):
def __init__(self):
super(UT_HAR_CNN_GRU,self).__init__()
self.encoder = nn.Sequential(
#input size: (250,90)
nn.Conv1d(250,250,12,3), #把时间戳当成通道，通道数始终不变，而每一个时刻的特征就是一维向量了，因此我们这里用了一位的卷积
nn.ReLU(True),
nn.Conv1d(250,250,5,2),
nn.ReLU(True),
nn.Conv1d(250,250,5,1)
# 250 x 8
)
self.gru = nn.GRU(8,128,num_layers=1)
self.classifier = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(128,7),
nn.Softmax(dim=1)
)
def forward(self,x):
# batch x 1 x 250 x 90
x = x.view(-1,250,90)
x = self.encoder(x)
# batch x 250 x 8
x = x.permute(1,0,2)
# 250 x batch x 8
_, ht = self.gru(x)
outputs = self.classifier(ht[-1])
return outputs
4.CNN-GRU并行网络
并向网络和串行网络有些区别，就像并联电路一样，CNN模块和GRU模块分别提取特征信息和，时序信息，两者提取出来不一样的特征，然后利用torch.cat(),将特征汇总，通过分类器实现分类。
我在阅读一篇论文时候，看到了一篇利用并行LSTM-CNN进行特征提取的论文。其框架大概如下。比如输入的CSI矩阵是250*90。250是250个时间戳，90是一个时间戳对应的特征。250个时间戳也就是一个CSI矩阵对应一个人体动作。
LSTM可以学习复杂的时间动态信息，而FCN可以通过提取动作在空间维度上的深层抽象特征来有效地预测动作。
接下来，我们简化一下这个模型，并把LSTM换成GRU来实现。这里我直接偷懒，用了上面的代码先卷积成（batch_size,num_steps,8）的形状，再利用nn.Flattern()展平成（batch_size,2000）的形状。其实这里也可以直接利用二维卷积，二维卷积后再展平。
最后通过代码x = torch.cat((x1,x2),dim=1) 把特征维度连接起来，变成了（batch_size,100+80）的形状。最后经过一个线性层变成（batch_size,7）与csi对应的7种动作分别对应。
我们在实现模型的时候一定要注意 形状 ，因为后面又torch.cat操作。
这里还需要注意batch_first设置为true， _,h = self.gru(X)这里h的形状需要转换维度。
import torch
from torch import nn
class Parallel_CNN_GRU(nn.Module):
def __init__(self):
super(Parallel_CNN_GRU,self).__init__()
#这里cnn输出的特征是 (batch_size,num_steps, 8) 、
# batch_size,num_steps还是250,然后这个特征数量从原来的90变成了提取后的8
self.cnn = nn.Sequential(
#input size: (250,90)
nn.Conv1d(250,250,12,3), #把时间戳当成通道，通道数始终不变，而每一个时刻的特征就是一维向量了，因此我们这里用了一位的卷积
nn.ReLU(True),
nn.Conv1d(250,250,5,2),
nn.ReLU(True),
nn.Conv1d(250,250,5,1),
# 250 x 8
nn.Dropout(0.5), #drop一下防止过拟合
nn.Flatten(), #直接展平了，形状变成(batch_size，)
nn.Linear(250*8,100)
)
self.gru = nn.GRU(input_size=90,hidden_size=80, num_layers= 2, batch_first = True, bidirectional = False)
self.fc = nn.Linear(180,7)
def forward(self,X):
# x1的形状是(batch_size, num_steps(250) ,fetures(8))
x1 = self.cnn(X)
#h是每一批第250个时间戳对应的隐藏层状态
#h的形状是(batch_size, num_layers(2) , hidden_size(80))
_,h = self.gru(X) #即便batch_first = True 这个形状仍然是(num_layers,batch,hiddens_size)
h = h.permute(1,0,2)
# x2的形状是(batch_size, 1 , hidden_size(80))
x2= h[:,-1,:] #提取最后一层即可
x2 = x2.squeeze(1) #形状变成(batch_size, 1 , hidden_size(80))
#print(x1.shape,x2.shape,h.shape)
x = torch.cat((x1,x2),dim=1) #把特征维度连接起来 (bacth,180)
output = self.fc(x)
return output
用这个模型跑了一下几千个CSI数据来识别人体活动。准确率还不错，好像有点过拟合，调一下模型，应该还有上涨的可能。
三、LSTM长短期记忆网络
LSTM（Long short term memory）模型比RNN、GRU模型复杂了很多,但是思路和GRU很类似。
1.LSTM模型介绍
其实RNN GRU LSTM的核心都是引入了隐藏态H，而这三者的区别就是H的生成方式不同，RNN是直接用上一刻的H和此刻的特征X，利用全连接的方法直接就简单的实现了。而GRU比RNN更复杂一些，引入了重置门R，通过这个重置门R生成候选隐状态，这个重置门R可以控制是否记忆足够多的过去内容，还是遗忘或者忘记。同时还引入了更新门Z，用来对候选隐状态和前一刻的隐状态操作，决定更新的比例大还是，保存之前的信息更重要。到底哪样重要我们也不知道，训练结果会给出答案。
LSTM引入了输入门、记忆门，遗忘门，候选记忆单元和记忆元之类。前三者的门和GRU的门的生成一样。
在门控循环单元中，有一种机制来控制输入和遗忘（或跳过）。 类似地，在长短期记忆网络中，也有两个门用于这样的目的： 输入门 𝐈𝑡控制采用多少来自 𝐂̃ 𝑡的新数据， 而遗忘门 𝐅𝑡控制保留多少过去的 记忆元 𝐂𝑡−1∈ℝ𝑛×ℎ的内容。 使用按元素乘法如果遗忘门始终为 1且输入门始终为 0， 则过去的记忆元 𝐂𝑡−1将随时间被保存并传递到当前时间步。 引入这种设计是为了缓解梯度消失问题， 并更好地捕获序列中的长距离依赖关系。还要注意H的生成时引入了激活函数，可以有效的保证，Ht的范围再(-1,+1).。
2.LSTM模型pytorch 代码示范
这里的数据集的例子和上面的CSI一样（batch_size,时间戳（250），特征（90）），250*90的CSI矩阵代表着一个动作。
而且需要注意的是这个模型的输出与前两个模型有微小的区别。输出是otput、(隐状态h_t，单元状态c_t)，多了一个前面提到的c。
import torch
from torch import nn
class LSTM_Net(nn.Module):
def __init__(self,input_size,output_size,num_hiddens=64,num_layers = 1):
super(LSTM_Net, self).__init__()
self.num_hiddens = num_hiddens
self.num_layers = num_layers
#分析这里的数据250*90
self.lstm = nn.LSTM(input_size=input_size,hidden_size=self.num_hiddens,num_layers=self.num_layers,batch_first=True)
self.fc = nn.Linear(num_hiddens,output_size)
def forward(self,X):
#X的形状是 batch_size,num_steps,90
out,_ = self.lstm(X) #这里的out是隐藏层的最后一层（batch_size *num _steps *num_hiddens）
#out = out.reshape(-1,out.shape[-1]) nlp的预测就是这种一个对应一个输出 转化成 (batch_size*num_steps , num_hiddens)
#这里需要是是提取250个时间步里面的最后一个时间步的隐藏态，因为250个时间不才输出一次
output = self.fc(out[:,-1,:]) #这里进行切片，对这个批次里的每个每组seq只提取最后一个时间步
return output #这里输出的形状就是（batch_size,1,output_num)
3.ABLSTM(基于注意力机制的双向LSTM网络)
从简单的开始说，先说一下BiLSTM,和BiGRU，BiRNN很类似的，举一反三。
先说双向LSTM和单向LSTM的区别。单向循环网络都是只能获取之前的信息。但是有时候我们不只想获取前面的信息，比如NLP领域，一段话我们想要获取上下文的信息。有上文和下文，着必然对应着两份隐藏层，分别从前往后训练得出，和从后往前训练得出，如下图所示。其实就是多了一套参数，多了一套隐藏层，理解起来比较容易。
在使用pytorch时只需要将bidirectional设置为True即可实现。只不过需要注意下面代码的out的形状是（batch_size, num _steps, 2*num_hiddens），而单向LSTM（batch_size, num _steps, num_hiddens）。
代码如下（示例）：
import torch
from torch import nn
class LSTM_Net(nn.Module):
def __init__(self,input_size,output_size,num_hiddens=64,num_layers = 1):
super(LSTM_Net, self).__init__()
self.num_hiddens = num_hiddens
self.num_layers = num_layers
#分析这里的数据250*90
self.lstm = nn.LSTM(input_size=input_size,hidden_size=self.num_hiddens,
num_layers=self.num_layers,batch_first=True, bidirectional=True) #这里bidirectional设置为True
self.fc = nn.Linear(num_hiddens,output_size)
def forward(self,X):
#X的形状是 batch_size,num_steps,90
out,_ = self.lstm(X) #这里的out是隐藏层的最后一层（batch_size, num _steps, 2*num_hiddens）
#这里需要是是提取250个时间步里面的最后一个时间步的隐藏态，因为250个时间不才输出一次
output = self.fc(out[:,-1,:]) #这里进行切片，对这个批次里的每个每组seq只提取最后一个时间步
return output #这里输出的形状就是（batch_size,1,output_num)
那么我们再进一步，如何再BLSTM的基础上引入注意力机制，ABLSTM是我在下面这篇论文里看到的也是处理CSI信号的来识别人体动作的。
一个x对应一个时间戳的CSI信号，一个h对应一个双向的隐藏态。接下啦我们要在下面图片的基础上引入注意力机制。
这里使用的是注意力机制，先计算注意力分数，
然后通过softmax函数计算注意力权重。
注意力权重乘对应时刻隐藏态，即为v值。
通过上面的公式可以看出，这里通过注意力机制，选取更为重要的ht。
整体的模型框架如下图所示：
代码如下：
import torch
from torch import nn
#ABLSTM模型
class ABLSTM(nn.Module):
def init(self,input_size,output_size,seq_lens,num_hiddens,num_layers,dqk,dv,num_heads = 1):
super(ABLSTM,self).init()
self.lstm = nn.LSTM(input_size=input_size,hidden_size=num_hiddens,bidirectional=True,num_layers=num_layers,batch_first=True) #这里的LSTM是双向的呢
#self.attention = nn.MultiheadAttention(embed_dim=dqk, kdim=dqk,vdim= dv, num_heads = num_heads,batch_first=True)
self.attention = nn.MultiheadAttention(embed_dim=input_size, num_heads = num_heads,batch_first=True)
self.flatten = nn.Flatten()
self.query = nn.Linear(2 * num_hiddens, input_size)
self.key = nn.Linear(2 * num_hiddens, input_size)
self.value = nn.Linear(2 * num_hiddens, input_size)
self.fc1 = nn.Linear(input_size,2*num_hiddens)
self.fc2 = nn.Linear(num_heads * seq_lens *num_hiddens * 2, 128)
self.fc3 = nn.Linear(128,output_size)
def forward(self,x):
out,_= self.lstm(x) #目的是提取出来所有的隐藏层 out 的形状（batch_size,seq_len,2 * num_hidden) 这里h的形状是(num_layers * 2,batch,hiddens_size)
#print(h.shape,out.shape)
q = self.query(out)
k = self.key(out)
v = self.value(out)
atten,_ = self.attention(q,k,v) #atten的形状是(batch_size, num_steps, 90)
x = self.fc1(atten) + out # 线性变换 + 残差连接
x = self.flatten(x) # 形状变成了(batch_size, num_heads * seq * 2*num_hiddens)
x = self.fc2(x)
x = torch.relu(x)
x = self.fc3(x)
return x
总结
本文主要讲解了RNN、GRU、LSTM等网络，并进行了适当的扩展。
622
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
