RNN循环神经网络基础

RNN的基本结构：

如何创建NN Cell:

代码实现：

import torch
#先设定参数
batch_size=1
seq_len=3#x1,x2,x3
input_size=4#x1,x2,x3,x4是一个4个元素的向量
hidden_size=2#hidden里面是2个元素的向量
cell=torch.nn.RNNCell(input_size=input_size,hidden_size=hidden_size)#初始化
datasets=torch.randn(seq_len,batch_size,input_size)
hidden=torch.zeros(batch_size,hidden_size)#隐层h0做成全0
for idx,input in enumerate(datasets):#训练的循环
	print('='*20,idx,'='*20)
	print('Input_size:',input.shape)
	hidden=cell(input,hidden)#这次的隐层=这次的输入和上次的隐层
	print('output size:',hidden.shape)
	print(hidden)

怎么使用RNN:

out,hidden=cell(inputs,hidden)

inputs是x1…xn
后面的hidden是h0
out是h1…hn
前面的hidden是hn
使用RNN的话就不需要循环了，RNN可以自动帮助循环


例子：
输入：hello如何输出ohlol

RNNseq2seq:

import torch
input_size=4
hidden_size=4
batch_size=1
idx2char=['e','h','l','o']
x_data=[1,0,2,2,3]#hello
y_data=[3,1,2,3,2]#ohlol
one_hot_lookup=[[1,0,0,0],#ehlo
                [0,1,0,0],
                [0,0,1,0],
                [0,0,0,1]]
x_one_hot=[one_hot_lookup[x] for x in x_data]
'''
[[0, 1, 0, 0], 
[1, 0, 0, 0], 
[0, 0, 1, 0], 
[0, 0, 1, 0], 
[0, 0, 0, 1]]
'''
inputs=torch.Tensor(x_one_hot).view(-1,batch_size,input_size)
'''
tensor([[[0., 1., 0., 0.]],
        [[1., 0., 0., 0.]],
        [[0., 0., 1., 0.]],
        [[0., 0., 1., 0.]],
        [[0., 0., 0., 1.]]])
'''
labels=torch.LongTensor(y_data).view(-1,1)
'''
 tensor([[3],
        [1],
        [2],
        [3],
        [2]])
'''
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)
cirterion=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(),lr=0.1)#优化器进行优化
#训练，共训练15轮
for epoch in range(15):
    loss=0
    optimizer.zero_grad()#优化器的梯度归0
    hidden=net.init_hidden()#算h0
    print('Predicted string:',end='')
    # inputs=seq_len*batch_size*inputsize，input=batch_size*input_size
    #labels=seq_length*1
    for input,label in zip(inputs,labels):
        hidden=net(input,hidden)
        loss+=cirterion(hidden,label)#损失累积到一起
        _,idx=hidden.max(dim=1)#找hidden里面输出的最大值，因为hidden是最大值，最大的下标找到
        print(idx2char[idx.item()],end='')#输出预测结果
    loss.backward()#反向传播
    optimizer.step()#优化更新
    print(',Epoch [%d/15] loss=%.4f' %(epoch+1,loss.item()))

one-hot vs Embedding:
数据的降维：



加入了embedding和linear layer层：
embedding的参数（num_embeddings,embedding_dim)
num_embeddings就是Input_size的独热向量是几维的
embedding_dim每一个embedding向量的size



LSTM：


GRU: