pytorch深度学习-RNN

pytorch深度学习-RNN

RNNCell 循环

Predicted string: ooooo, Epoch [1/15] loss=7.8655 
Predicted string: ooooo, Epoch [2/15] loss=6.4431 
Predicted string: olool, Epoch [3/15] loss=5.4130 
Predicted string: olool, Epoch [4/15] loss=4.8994 
Predicted string: olool, Epoch [5/15] loss=4.5087 
Predicted string: ohool, Epoch [6/15] loss=4.1282 
Predicted string: ohlol, Epoch [7/15] loss=3.7627 
Predicted string: ohlol, Epoch [8/15] loss=3.4021 
Predicted string: ohlol, Epoch [9/15] loss=3.0482 
Predicted string: ohlol, Epoch [10/15] loss=2.7343 
Predicted string: ohlol, Epoch [11/15] loss=2.4922 
Predicted string: ohlol, Epoch [12/15] loss=2.3251 
Predicted string: ohlol, Epoch [13/15] loss=2.2231 
Predicted string: ohlol, Epoch [14/15] loss=2.1580 
Predicted string: ohlol, Epoch [15/15] loss=2.0906 

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.num_layers = num_layers
        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('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模块

Predicted:  ohohl, Epoch [1/15] loss=1.2034 
Predicted:  ohlol, Epoch [2/15] loss=1.0763 
Predicted:  ohlol, Epoch [3/15] loss=0.9678 
Predicted:  ohlol, Epoch [4/15] loss=0.8785 
Predicted:  ohlol, Epoch [5/15] loss=0.8067 
Predicted:  ohlol, Epoch [6/15] loss=0.7477 
Predicted:  ohlol, Epoch [7/15] loss=0.6980 
Predicted:  ohlol, Epoch [8/15] loss=0.6560 
Predicted:  ohlol, Epoch [9/15] loss=0.6207 
Predicted:  ohlol, Epoch [10/15] loss=0.5907 
Predicted:  ohlol, Epoch [11/15] loss=0.5645 
Predicted:  ohlol, Epoch [12/15] loss=0.5409 
Predicted:  ohlol, Epoch [13/15] loss=0.5193 
Predicted:  ohlol, Epoch [14/15] loss=0.4998 
Predicted:  ohlol, Epoch [15/15] loss=0.4833 

Process finished with exit code 0

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_one_hot = [one_hot_lookup[x] for x in x_data]

inputs = torch.Tensor(x_one_hot).view(seq_len,batch_size,input_size)
labels = torch.LongTensor(y_data)

#搭建模型
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=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)

#优化器
criterion = torch.nn.CrossEntropyLoss()    #交叉熵
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)

for epoch in range(15):
    loss = 0
    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()))