十三、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 ) |