十三、RNN循环神经网络实战

因为我本人主要课题方向是处理图像的，RNN是基本的序列处理模型，主要应用于自然语言处理，故这里就简单的学习一下，了解为主

一、问题引入

已知以前的天气数据信息，进行预测当天(4-9)是否下雨

日期	温度	气压	是否下雨
4-1	10	20	否
4-2	30	40	是
4-3	40	25	是
4-4	10	30	是
4-5	5	10	否
4-6	10	20	是
4-7	12	60	否
4-8	25	80	是
4-9	20	15	？

这里的数据集都是随别胡乱写的哈，就说在阐述一下待解决的问题，随别做的数据集
思路：可以四天一组，每组中有4天的天气信息，包括温度、气压、是否下雨
前三天作为输入，第四天最为输出

在卷积神经网络中，全连接层是权重最多的，也是整个网络中计算量最多的地方

卷积中
输入：128通道
输出：64通道
卷积核：5×5
总共的权重参数：128×64×5×5 = 204800

全连接中
一般都不会直接将一个高维通道直接变为1，而是多几个中间层进行过度
输入：4096
输出：1024
权重参数个数：4096×1024 = 4194304

权重参数个数压根都不在一个数量级上，所以说，正因为卷积的权重共享，导致卷积操作所需参数远小于全连接

RNN循环神经网络主要用在具有序列关系的数据中进行处理，例如：天气的预测，因为前后的天气会相互影响，并不会断崖式的变化、股市预测等，典型的就是自然语言处理
我喜欢beyond乐队这句话的词语之间具有序列关系，随便调换顺序产生的结果肯定很难理解

二、RNN循环神经网络

Ⅰ，RNN Cell

RNN Cell是RNN中的核心单元

xt：序列当中，时刻t时的数据，这个数据具有一定的维度，例如天气数据就是3D向量的，即，温度、气压、是否下雨
xt通过RNN Cell之后就会得到一个ht，这个数据也是具有一定的维度，假如是5D向量
从xt这个3D向量数据通过RNN Cell得到一个ht这个5D向量数据，很明显，这个RNN Cell本质就是一个线性层
区别：RNN Cell这个线性层是共享的

RNN Cell基本流程

现学现卖

import torch#根据需求设定参数
batch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2yy_cell = torch.nn.RNNCell(input_size=input_size,hidden_size=hidden_size)dataset = torch.randn(seq_len,batch_size,input_size)
hidden = torch.zeros(batch_size,hidden_size) #h0设置为全0for idx,inputs in enumerate(dataset):print('-----------------)print("Input size:",inputs.shape)hidden = yy_cell(inputs,hidden)print("outputs size:",hidden.shape)print(hidden)
"""
==================== 0 ====================
Input size: torch.Size([1, 4])
outputs size: torch.Size([1, 2])
tensor([[ 0.6377, -0.4208]], grad_fn=<TanhBackward0>)
==================== 1 ====================
Input size: torch.Size([1, 4])
outputs size: torch.Size([1, 2])
tensor([[-0.2049,  0.6174]], grad_fn=<TanhBackward0>)
==================== 2 ====================
Input size: torch.Size([1, 4])
outputs size: torch.Size([1, 2])
tensor([[-0.1482, -0.2232]], grad_fn=<TanhBackward0>)
"""

Ⅱ，RNN

现学现卖

import torch#根据需求设定参数
batch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2
num_layers = 2 #两层RNN Cellcell = torch.nn.RNN(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers)inputs = torch.randn(seq_len,batch_size,input_size)
hidden = torch.zeros(num_layers,batch_size,hidden_size) #h0设置为全0out,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.8465, -0.1636]],[[ 0.3185, -0.1733]],[[ 0.0269, -0.1330]]], grad_fn=<StackBackward0>)
hidden size: torch.Size([2, 1, 2])
hidden tensor([[[ 0.5514,  0.8349]],[[ 0.0269, -0.1330]]], grad_fn=<StackBackward0>)
"""

三、RNN实战

需求：实现将输入beyond转换为ynbode

①文本转向量one-hot

因为RNN Cell单元输入的数据必须是由单词构成的向量 ，根据字符来构建一个词典，并为其分配索引，索引变One-Hot向量，词典中有几项，最终构建的向量也有几列，只能出现一个1，其余都为0

character	index
b	0
d	1
e	2
n	3
o	4
y	5

②模型训练

Ⅰ RNN Cell

import torchinput_size = 6
hidden_size = 6
batch_size = 1dictionary = ['b','e','y','o','n','d'] #字典
x_data = [0,1,2,3,4,5] #beyond
y_data = [2,4,0,3,5,1] #ynbodeone_hot = [[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,1,0,0,0],[0,0,0,1,0,0],[0,0,0,0,1,0],[0,0,0,0,0,1]]x_one_hot = [one_hot[x] for x in x_data] #将x_data的每个元素从one_hot得到相对于的向量形式inputs = torch.Tensor(x_one_hot).view(-1,batch_size,input_size) #inputs形式为(seqlen,batch_size,input_size)
labels = torch.LongTensor(y_data).view(-1,1) #lables形式为(seqlen,1)class y_rnncell_model(torch.nn.Module):def __init__(self,input_size,hidden_size,batch_size):super(y_rnncell_model,self).__init__()self.batch_size = batch_sizeself.input_size = input_sizeself.hidden_size = hidden_sizeself.rnncell = torch.nn.RNNCell(input_size=self.input_size,hidden_size=self.hidden_size)def forward(self,inputs,labels):hidden = self.rnncell(inputs,labels)return hiddendef init_hidden(self): #定义h0初始化return torch.zeros(self.batch_size,self.hidden_size)y_net = y_rnncell_model(input_size,hidden_size,batch_size)#定义损失函数和优化器
lossf = torch.nn.CrossEntropyLoss()
optim = torch.optim.Adam(y_net.parameters(),lr=0.001)# RNN Cell
for epoch in range(800):loss = 0optim.zero_grad() #优化器梯度归零hidden = y_net.init_hidden() #h0print('Predicted string:',end='')for x,y in zip(inputs,labels):hidden = y_net(x,hidden)loss += lossf(hidden,y) #计算损失之和，需要构造计算图_,idx = hidden.max(dim=1)print(dictionary[idx.item()],end='')loss.backward()optim.step()print(',Epoch [%d/20] loss=%.4f'%(epoch+1,loss.item()))

Ⅱ RNN

#引入torch
import torchinput_size = 6 #beyond
hidden_size = 6 #
num_layers = 1
batch_size = 1
seq_len = 6idx2char = ['b','d','e','n','o','y'] #字典
x_data = [0,2,5,4,3,1] #beyond
y_data = [5,3,0,4,1,2] #ynbodeone_hot = [[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,1,0,0,0],[0,0,0,1,0,0],[0,0,0,0,1,0],[0,0,0,0,0,1]]x_one_hot = [one_hot[x] for x in x_data] #将x_data的每个元素从one_hot得到相对于的向量形式inputs = torch.Tensor(x_one_hot).view(seq_len,batch_size,input_size)labels = torch.LongTensor(y_data)class y_rnn_model(torch.nn.Module):def __init__(self,input_size,hidden_size,batch_size,num_layers):super(y_rnn_model,self).__init__()self.num_layers = num_layersself.batch_size = batch_sizeself.input_size = input_sizeself.hidden_size = hidden_sizeself.rnn = torch.nn.RNN(input_size=self.input_size,hidden_size=self.hidden_size,num_layers=self.num_layers)def forward(self,inputs):hidden = torch.zeros(self.num_layers,self.batch_size,self.hidden_size)#构造h0out,_ = self.rnn(inputs,hidden)     return out.view(-1,self.hidden_size) #（seqlen×batchsize,hiddensize）net = y_rnn_model(input_size,hidden_size,batch_size,num_layers)lessf = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr=0.05)for epoch in range(30):optimizer.zero_grad()outputs = net(inputs)loss = lessf(outputs,labels)   loss.backward()optimizer.step()_, idx = outputs.max(dim=1)idx = idx.data.numpy()print('Predicted:',''.join([idx2char[x] for x in idx]),end='')print(',Epoch[%d/15] loss=%.3f' % (epoch+1,loss.item()))

③one-hot的不足

1，维度过高；一个单词得占用一个维度
2，one-hot向量过于稀疏；就一个1，其余全是0
3，硬编码；一对一

解决方法：EMBEDDING
思路:将高维的向量映射到一个稠密的低维的向量空间里面
即：数据的降维

优化RNN

官网torch.nn.Embedding函数详细参数解释

参数	含义
num_embeddings	one-hot的维度
embedding_dim	embedding的维度
Input: (*)(∗), IntTensor or LongTensor of arbitrary shape containing the indices to extract	输入需要是一个整型或者长整型IntTensor or LongTensor
Output: (*, H), where * is the input shape and H=embedding_dim	(input shape,embedding_dim )

网络架构