pytorch深度学习实践4——循环神经网络RNN

循环神经网络（基础篇）

在RNN反向传播的过程中，如果参数w的值过小，在经过反向传播后，到达终点时的值可能为0，会出现梯度消失的问题；反之，若参数w的值过大，到达终点后会出现梯度爆炸的现象，而LSTM可以解决这个问题。

RNN主要处理有序列关系的数据：天气、股市、自然语言等有时间序列的数据

RNN示例：

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)
dataset = torch.randn(seq_len,batch_size,input_size)
hidden = torch.zeros(batch_size,hidden_size)
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)

RNN工作方式：

RNN示例2：

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)
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)

RNN的实现：

import torch

input_size = 4
hidden_size = 4
batch_size =1

idx2char = ['e','h','l','o']
x_data = [1,0,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)
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)
        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('input',inputs)
    print('Predicted string:',end='')
    for input,label in zip(inputs,labels):
        hidden = net(input,hidden)
        loss+=criterion(hidden,label)
        _,idx = hidden.max(dim = 1)
        print(idx2char[idx.item()],end = '')
    loss.backward()
    optimizer.step()
    print(',Epoch [%d/15] loss = %.4f' % (epoch+1,loss.item()))

运用RNN：

import torch

input_size = 4
hidden_size = 4
batch_size =1
seq_len=5

idx2char = ['e','h','l','o']
x_data = [1,0,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_data与one_hot_lookup相对应
#x_data中的1对应one_hot_lookup中的[0,1,0,0]
#x_data中的2对应one_hot_lookup中的[0,0,1,0]
#x_data中的3对应one_hot_lookup中的[0,0,0,1]
#x_data中的0对应one_hot_lookup中的[1,0,0,0]
x_one_hot = [one_hot_lookup[x] for x in x_data]
print('x_ont_hot:',x_one_hot)
#转换为tensor矩阵
inputs = torch.Tensor(x_one_hot).view(seq_len,batch_size,input_size)
print('inputs:',inputs)
#将y_data转换为tensor矩阵
labels = torch.LongTensor(y_data)
print('labels:',labels)
#定义神经网络模型
class Model(torch.nn.Module):
    def __init__(self,input_size,hidden_size,batch_size,num_layers=1):
        super(Model,self).__init__()
        self.num_layers = num_layers
        self.batch_size = batch_size
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.rnn = torch.nn.RNN(input_size=self.input_size,
                                hidden_size=self.hidden_size,
                                num_layers=self.num_layers)
    def forward(self,input):
        hidden = torch.zeros(self.num_layers,
                             self.batch_size,
                             self.hidden_size)
        out,_=self.rnn(input,hidden)
        return out.view(-1,self.hidden_size)

net = Model(input_size, hidden_size, batch_size,num_layers=1)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr=0.1)


for epoch in range(15):
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(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 = %.4f' % (epoch+1,loss.item()))

嵌入层：

示例3：

LSTM
GRU

循环神经网络训练器

示例：
python中，时间的单位是秒（s）







数据准备：

构建模型：

双向循环神经网络：



训练：

测试：

其他示例

用RNN作诗