PyTorch深度学习实践（十二）循环神经网络基础篇

对线性层的复用 Dense网络：稠密网络，有很多线性层对输入数据进行空间上的变换,又叫DNN 输入x1,x2…xn是数据样本的不同特征 Dense连接就是指全连接 比如预测天天气，就需要知道之前几天的数据，每一天的数据都包含若个特征，需要若干天的数据作为输入

假设现在取前3天，每一天有3个特征 第一种方法：把x1,x2,x3拼成有9个维度的长向量，然后去训练最后一天是否有雨 用全连接稠密网络进行预测，如果输入序列很长，而且每一个序列维度很高的话，对网络训练有很大挑战，因为稠密网络（全连接网络）实际上权重是最多的。对于卷积层：比如输入通道是128个，输出通道是64个，如果用55的卷积。权重数就是 2564188=204800，卷积层的输入输出只与通道数和卷积核的大小有关，全连接层和变换之后的数据大小有关 ，比如3阶张量经过一系列的卷积变换还剩下4096个元素，4096我们很少直接降成1维或者10维，而是先降成1024维，40961024=4194304，所以相比起来，卷积层的权重并不多，而全连接层的权重较多 。在网络的全部参数中，全连接层是占大头的 为什么卷积神经网络的权重比较少呢？ 因为使用了权重共享的概念，做卷积时，整个图像的卷积核是共享的，并不是图像上的每一个像素要和下一层的featureMap建立连接,权重数量就少 处理视频的时候，每一帧就少一张图像，我们需要把一组图像做成一个集合，如果用全连接网络的话，使用到的权重的数量就是一个天文数字，难以处理 RNN专门用来处理带有序列模式的数据，也使用权重共享减少需要训练的权重的数量 我们把x1,x2,x3,xn看成是一个序列，不仅考虑x1,x2之间的连接关系，还考虑x1,x2的时间上的先后顺序 x2依赖于x1,x3依赖于x2,下一天的天气状况部分依赖于前一天的天气状况，RNN主要处理这种具有序列连接的 天气，股市，金融，自然语言处理都是序列数据 RNN Cell本质是一个线性层（linear），把一个维度映射到另一个维度（比如把输入的3维向量xt变成输出5维向量ht） 这个线性层与普通的线性层的区别是这个线性层是共享的 展开就是下图（其中所有的RNN cell是同一个线性层，因为是展开的嘛），h0是先验值，没有就设置成0向量 具体的计算过程：

输入xt先做线性变换，h t-1也是，xt的维度是input_size,h t-1的维度是hidden_size,输出ht的维度是hidden_size，我们需要先把xt的维度变成hidden_size,所以Wih应该是一个 hidden_sizeinput_size的矩阵，Wihxt得到一个 hidden_size1的矩阵（就是维度为hidden_size的向量），bih是偏置。输入权重矩阵Whh是一个hidden_sizehidden_size的矩阵。 whhHt-1+bhh和WihXt+bih都是维度为hidden_size的向量，两个向量相加，就把信息融合起来了，融合之后用tanh做激活，循环神经网络的激活函数用的是tanh,因为tanh的取值在-1到+1之间，算出结果得到隐藏层输出ht

把RNN Cell以循环的方式把序列（x1,x2,…）一个一个送进去，然后依次算出隐藏层(h1,h2…)的过程,每一次算出来的h会作为下一个RNN Cell的输入，这就叫循环神经网络

PyTorch里面构造RNN的两种方式：

①自己构建Cell 需要设定输入的值input_size，和隐层的值hidden_size，就能确定权重W的维度和偏置b的维度

cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size) hidden = cell(input, hidden)#实例化Cell之后，我们需要给定当前的输入input以及当前的hidden，所以需要用循环来处理

比如

h1=Cell(x1,h0)

batchSize表示批量 seqLen=3表示每一个样本都有x1,x2,x3这些特征 inputSize=4表示每一个特征都是4维的 hoddenSize=2表示每一个隐藏层是2维

𝒊𝒏𝒑𝒖𝒕. 𝑠ℎ𝑎𝑝𝑒 = (𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆) 𝑜𝑢𝑡𝑝𝑢𝑡. 𝑠ℎ𝑎𝑝𝑒 =(𝑏𝑎𝑡𝑐ℎ𝑆𝑖𝑧𝑒, ℎ𝑖𝑑𝑑𝑒𝑛𝑆𝑖𝑧)#h0需要满足这个条件

The sequence can be warped in one Tensor with shape:

𝑑𝑎𝑡𝑎𝑠𝑒𝑡. 𝑠ℎ𝑎𝑝𝑒 = (𝒔𝒆𝒒𝑳𝒆𝒏, 𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛)

代码展示

import torch batch_size=1 seq_len=3 input_size=4 hidden_size=2 Cell=torch.nn.RNNCell(input_size=input_size,hidden_size=hidden_size)#初始化，构建RNNCell dataset=torch.randn(seq_len,batch_size,input_size)#设置dataset的维度 hidden=torch.zeros(batch_size,hidden_size)#隐层的维度：batch_size*hidden_size，先把h0置为0向量 for idx,input in enumerate(dataset): print('='*20,idx,'='*20) print('Input size:',input.shape) hidden=Cell(input,hidden) print('Outputs size:',hidden.shape) print(hidden)

结果：

==================== 0 ==================== Input size: torch.Size([1, 4]) Outputs size: torch.Size([1, 2]) tensor([[0.8677, 0.8320]], grad_fn=<TanhBackward>) ==================== 1 ==================== Input size: torch.Size([1, 4]) Outputs size: torch.Size([1, 2]) tensor([[-0.9137, -0.5884]], grad_fn=<TanhBackward>) ==================== 2 ==================== Input size: torch.Size([1, 4]) Outputs size: torch.Size([1, 2]) tensor([[0.9840, 0.9235]], grad_fn=<TanhBackward>)

②直接使用RNN

cell = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers)#num_layers：RNN的层数

#num_layers：RNN的层数，如果RNN有多层，每一层都会有输出

out, hidden = cell(inputs, hidden)

inputs:所有的x,x1,x2,x3,xn 用RNN不用自己写循环，它自动循环，所以输入的时候要把所有的序列都送进去，然后给定h0,然后我们就会得到所有的隐层输出以及最后一层的输出 当RNN有多层，同样颜色的RNNCell是同一个，所以下图是有3个线性层（一个RNNCell是一个线性层）

代码

import torch batch_size=1 seq_len=3 input_size=4 hidden_size=2 num_layers=1 cell=torch.nn.RNN(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers) #构造RNN时指明输入维度，隐层维度以及RNN的层数 inputs=torch.randn(seq_len,batch_size,input_size) hidden=torch.zeros(num_layers,batch_size,hidden_size) out,hidden=cell(inputs,hidden) print('Output size:',out.shape) print('Output:',out) print('Hidden size:',hidden.shape) print('Hidden',hidden)

结果

Output size: torch.Size([3, 1, 2]) Output: tensor([[[-0.9123, 0.9218]], [[ 0.9394, -0.2471]], [[-0.9064, 0.5193]]], grad_fn=<StackBackward>) Hidden size: torch.Size([1, 1, 2]) Hidden tensor([[[-0.9064, 0.5193]]], grad_fn=<StackBackward>)

如果初始化RNN时，把batch_first设置成了TRUE,那么inputs的参数batch_size和seq_len需要调换一下位置

例子：训练RNN网络，输入“hello”，输出“ohlol”

①把字符转成向量 inputsize=4,因为输入有4个字符（e h l o） 这相当于一个多分类问题，输出就是一个4维的向量，每一维代表是某一个字符的概率，接交叉熵就能输出概率了 代码

import torch input_size=4 hidden_size=4 batch_size=1 idx2char=['e','h','l','o'] x_data=[1,2,2,2,3] y_data=[3,1,2,3,2] one_hot_lookup=[[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]] #查询字典 x_one_hot=[one_hot_lookup[x] for x in x_data]#独热向量 inputs=torch.Tensor(x_one_hot).view(-1,batch_size,input_size)#取出来one_hot_lookup中的一行向量 labels=torch.LongTensor(y_data).view(-1,1) #构建模型 class Model(torch.nn.Module): def __init__(self,input_size,hidden_size,batch_size): super(Model,self).__init__() self.batch_size=batch_size self.input_size=input_size self.hidden_size=hidden_size self.rnncell=torch.nn.RNNCell(input_size=self.input_size,hidden_size=self.hidden_size) def forward(self,input,hidden): hidden=self.rnncell(input,hidden)#ht=cell(xt,ht-1) return hidden def init_hidden(self): return torch.zeros(self.batch_size,self.hidden_size) net=Model(input_size,hidden_size,batch_size) criterion=torch.nn.CrossEntropyLoss() optimizer=torch.optim.Adam(net.parameters(),lr=0.1) #训练 for epoch in range(15): loss=0 optimizer.zero_grad()#每一轮训练先把优化器的梯度清零 hidden=net.init_hidden() print('Predicted string:',end='') for input,label in zip(inputs,labels): hidden=net(input,hidden) loss+=criterion(hidden,label) _,idx=hidden.max(dim=1)#hidden现在是4维向量，用max找到最大的概率 print(idx2char[idx.item()],end='') loss.backward() # loss.backward(retain_graph=True) optimizer.step() print(',Epoch [%d/15] loss=%.4f' % (epoch+1,loss.item())