| import math |
| import torch |
| from torch.autograd import Variable |
| from torch.nn.parameter import Parameter |
| import torch.nn.functional as F |
|
|
| from rnn_cell_base import RNNCellBase |
|
|
|
|
| |
| class SRU(RNNCellBase): |
|
|
| def __init__(self, input_size, hidden_size, device, bias=True, sigmoid=None, tanh=None, gpu=False, base_stack=False): |
| super(SRU, self).__init__() |
| self.input_size = input_size |
| self.hidden_size = hidden_size |
| self.bias = bias |
| self.device = device |
| self.gpu = gpu |
| 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(3 * hidden_size, input_size)) |
| if bias: |
| self.bias_ih = Parameter(torch.Tensor(3 * hidden_size)) |
| else: |
| self.register_parameter('bias_ih', 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.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) |
| |
| self.check_forward_input(input_data[0]) |
| self.check_forward_hidden(input_data[0], self.hidden) |
| |
| if self.gpu: |
| gis = F.linear(input_data, self.weight_ih, self.bias_ih) |
| |
| for i, gi in enumerate(gis.split(1)): |
| i_r, i_f, i_n = gi.squeeze().chunk(3, 1) |
|
|
| readgate = self.sigmoid(i_r) |
| forgetgate = self.sigmoid(i_f) |
| newgate = i_n |
| self.hidden = newgate + forgetgate * (self.hidden - newgate) |
| outputs[i] = newgate + readgate * (self.tanh(self.hidden) - newgate) |
| else: |
| for i, input_t in enumerate(input_data.split(1)): |
| x = input_t.view(batch_size, features) |
| gi = F.linear(x, self.weight_ih, self.bias_ih) |
| i_r, i_f, i_n = gi.chunk(3, 1) |
|
|
| readgate = self.sigmoid(i_r) |
| forgetgate = self.sigmoid(i_f) |
| newgate = i_n |
| self.hidden = newgate + forgetgate * (self.hidden - newgate) |
| outputs[i] = newgate + readgate * (self.tanh(self.hidden) - newgate) |
| if self.base_stack: |
| return outputs |
| else: |
| out = self.dense(outputs[-1]) |
| out = self.relu(out) |
| return out |
| |
|
|
|
|
| |
| class SRU_stack(torch.nn.Module): |
| def __init__(self, input_size, hidden_size, device, stacks=1, bias=True, sigmoid=None, tanh=None): |
| super(SRU_stack, self).__init__() |
| self.input_size = input_size |
| self.hidden_size = hidden_size |
| self.stacks = stacks |
| self.device = device |
| if stacks == 1: |
| self.cell1 = SRU(input_size, hidden_size, device, bias, sigmoid, tanh) |
| elif stacks == 2: |
| self.cell1 = SRU(input_size, 14, device, bias, sigmoid, tanh, base_stack=True) |
| self.cell2 = SRU(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 = SRU_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) |
|
|
