pytorch rnn 2
阿新 • • 發佈:2018-11-05
tput data forward output step form sed nump eight
import torch import torch.nn as nn import numpy as np import torch.optim as optim class RNN(nn.Module): def __init__(self,input_dim , hidden_dim , out_dim): super(RNN,self).__init__() self.linear_1 = nn.Linear(input_dim , hidden_dim) self.linear_2 = nn.Linear(hidden_dim , hidden_dim) self.linear_3 = nn.Linear(hidden_dim, out_dim) self.relu = nn.ReLU() self.sigmoid = nn.Sigmoid() self.hidden_size = hidden_dim def forward(self, input , hidden_input): input = input.view(1, 1, -1) hy = self.relu(self.linear_1(input) + self.linear_2(hidden_input)) output = self.sigmoid(self.linear_3(hy)) return output , hy def init_weight(self): nn.init.normal_(self.linear_1.weight.data , 0 , np.sqrt(2 / 16)) nn.init.uniform_(self.linear_1.bias, 0, 0) nn.init.normal_(self.linear_2.weight.data, 0, np.sqrt(2 / 16)) nn.init.uniform_(self.linear_2.bias, 0, 0) nn.init.normal_(self.linear_3.weight.data , 0 , np.sqrt(2 / 16)) nn.init.uniform_(self.linear_3.bias, 0, 0) def init_hidden(self): return torch.zeros([1,1,self.hidden_size]) def train(input_seq , target, encoder , optim , criterion ,max_length): optim.zero_grad() hidden = encoder.init_hidden() encoder_outputs = torch.zeros(max_length) for ndx in range(max_length): x_in = torch.Tensor([input_seq[0][ndx] , input_seq[1][ndx]]) output , hidden = encoder(x_in , hidden) encoder_outputs[ndx] = output[0,0] target = torch.Tensor(target) loss = criterion(encoder_outputs, target) loss.backward() optim.step() return loss , encoder_outputs def trainIter(batch_x , batch_y , encoder , max_length,learning_rate): encoder_optimizer = optim.Adam(encoder.parameters(), lr=learning_rate) criterion = nn.MSELoss() loss = 0 predict = np.zeros([batch_size , max_length]) for ndx in range(len(batch_x)): loss_ , encoder_outputs = train(batch_x[ndx],batch_y[ndx], encoder ,encoder_optimizer,criterion, max_length) loss += loss_ predict[ndx] = encoder_outputs.detach().numpy() return loss , predict def getBinDict(bit_size = 16): max = pow(2,bit_size) bin_dict = {} for i in range(max): s = '{:016b}'.format(i) arr = np.array(list(reversed(s))) arr = arr.astype(int) bin_dict[i] = arr return bin_dict binary_dim = 16 int2binary = getBinDict(binary_dim) def getBatch( batch_size , binary_size): x = np.random.randint(0,256,[batch_size , 2]) batch_x = np.zeros([batch_size , 2,binary_size] ) batch_y = np.zeros([batch_size , binary_size]) for i in range(0 , batch_size): batch_x[i][0] = int2binary[x[i][0]] batch_x[i][1] = int2binary[x[i][1]] batch_y[i] = int2binary[x[i][0] + x[i][1]] return batch_x , batch_y , [a + b for a,b in x] def getInt(y , bit_size): arr = np.zeros([len(y)]) for i in range(len(y)): for j in range(bit_size): arr[i] += (int(y[i][j]) * pow(2 , j)) return arr if __name__ == '__main__': input_size = 2 hidden_size = 8 batch_size = 100 net = RNN(input_size, hidden_size , 1) net.init_weight() print(net) for i in range(100000): net.zero_grad() h0 = torch.zeros(1, batch_size, hidden_size) x , y , t = getBatch(batch_size , binary_dim) loss , outputs = trainIter(x , y , net , binary_dim , 0.01) print('iterater:%d loss:%f' % (i, loss)) if i % 100== 0: output2 = np.round(outputs) result = getInt(output2,binary_dim) print(t ,'\n', result) print('iterater:%d loss:%f'%(i , loss))
pytorch rnn 2