| import math |
| import torch |
| from torch.autograd import Variable |
| from torch.nn.parameter import Parameter |
| import torch.nn as nn |
| import torch.nn.functional as F |
|
|
| from rnn_cell_base import RNNCellBase |
|
|
|
|
| |
| class LSTM(RNNCellBase): |
|
|
| def __init__(self, input_size, hidden_size, device, bias=True, sigmoid=None, tanh=None, base_stack=False): |
| super(LSTM, self).__init__() |
| self.input_size = input_size |
| self.hidden_size = hidden_size |
| self.bias = bias |
| self.device = device |
| self.dense = torch.nn.Linear(hidden_size, 7) |
| self.relu = F.relu |
| self.base_stack = base_stack |
| self.sigmoid = F.sigmoid if sigmoid is None else self.get_activation(sigmoid) |
| self.tanh = F.tanh if tanh is None else self.get_activation(tanh) |
| self.weight_ih = Parameter(torch.Tensor(4 * hidden_size, input_size)) |
| self.weight_hh = Parameter(torch.Tensor(4 * hidden_size, hidden_size)) |
| if bias: |
| self.bias_ih = Parameter(torch.Tensor(4 * hidden_size)) |
| self.bias_hh = Parameter(torch.Tensor(4 * hidden_size)) |
| else: |
| self.register_parameter('bias_ih', None) |
| self.register_parameter('bias_hh', None) |
| self.reset_parameters() |
|
|
| def reset_parameters(self): |
| stdv = 1.0 / math.sqrt(self.hidden_size) |
| for weight in self.parameters(): |
| weight.data.uniform_(-stdv, stdv) |
| self.hidden = None |
| |
| def reset_hidden(self): |
| self.hidden = None |
| |
| def detach_hidden(self): |
| self.hidden[0].detach_() |
| self.hidden[1].detach_() |
|
|
| def forward(self, input_data, future=0): |
| timesteps, batch_size, features = input_data.size() |
| outputs = Variable(torch.zeros(timesteps + future, batch_size, self.hidden_size, device=self.device), requires_grad=False) |
| |
| if self.hidden is None: |
| self.hidden = (Variable(torch.zeros(batch_size, self.hidden_size, device=self.device), requires_grad=False), |
| Variable(torch.zeros(batch_size, self.hidden_size, device=self.device), requires_grad=False)) |
|
|
| for i, input_t in enumerate(input_data.split(1)): |
| hx, cx = self.hidden |
| gates = F.linear(input_t.view(batch_size, features), self.weight_ih, self.bias_ih) + \ |
| F.linear(hx, self.weight_hh, self.bias_hh) |
|
|
| ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1) |
|
|
| ingate = self.sigmoid(ingate) |
| forgetgate = self.sigmoid(forgetgate) |
| cellgate = self.tanh(cellgate) |
| outgate = self.sigmoid(outgate) |
| cy = (forgetgate * cx) + (ingate * cellgate) |
| hy = outgate * self.tanh(cy) |
| |
| self.hidden = hy, cy |
| outputs[i] = self.hidden[0] |
| if self.base_stack: |
| return outputs |
| else: |
| out = self.dense(outputs[-1]) |
| out = self.relu(out) |
| return out |
| |
|
|
|
|
| |
| class LSTM_stack(torch.nn.Module): |
| def __init__(self, input_size, hidden_size, device, stacks=1, bias=True, sigmoid=None, tanh=None): |
| super(LSTM_stack, self).__init__() |
| self.input_size = input_size |
| self.hidden_size = hidden_size |
| self.stacks = stacks |
| self.device = device |
| if stacks == 1: |
| self.cell1 = LSTM(input_size, hidden_size, device, bias, sigmoid, tanh) |
| elif stacks == 2: |
| self.cell1 = LSTM(input_size, 14, device, bias, sigmoid, tanh, base_stack=True) |
| self.cell2 = LSTM(input_size, hidden_size, device, bias, sigmoid, tanh, base_stack=False) |
|
|
| def detach_hidden(self): |
| self.cell1.detach_hidden() |
| if self.stacks == 2: |
| self.cell2.detach_hidden() |
|
|
| def forward(self, input_data, future=0): |
| if self.stacks == 1: |
| x = self.cell1(input_data) |
| elif self.stacks == 2: |
| x = self.cell1(input_data) |
| x = self.cell2(x) |
| return x |
|
|
|
|
| if __name__ == "__main__": |
| |
| import numpy as np |
| for i in [5, 10, 20, 50]: |
| Model = LSTM_stack(14, i, None, 2) |
| model_parameters = filter(lambda p: p.requires_grad, Model.parameters()) |
| params = sum([np.prod(p.size()) for p in model_parameters]) |
| print(params) |
|
|
