File size: 4,602 Bytes
1403119 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | 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
# see: https://github.com/jpeg729/pytorch_bits/tree/master/nn ----------------------------- #
class RAN(RNNCellBase):
def __init__(self, input_size, hidden_size, device, bias=True, sigmoid=None, tanh=None, base_stack=False):
super(RAN, 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(3 * hidden_size, input_size))
self.weight_hh = Parameter(torch.Tensor(2 * hidden_size, hidden_size))
if bias:
self.bias_ih = Parameter(torch.Tensor(3 * hidden_size))
self.bias_hh = Parameter(torch.Tensor(2 * 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.detach_()
def forward(self, input_data, future=0):
timesteps, batch_size, features = input_data.size()
# print("t %d, b %d, f %d" % (timesteps, batch_size, features))
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)
# else:
# self.hidden.detach_()
self.check_forward_input(input_data[0])
self.check_forward_hidden(input_data[0], self.hidden)
for i, input_t in enumerate(input_data.split(1)):
gi = F.linear(input_t.view(batch_size, features), self.weight_ih, self.bias_ih)
gh = F.linear(self.hidden, self.weight_hh, self.bias_hh)
i_i, i_f, i_n = gi.chunk(3, 1)
h_i, h_f = gh.chunk(2, 1)
inputgate = self.sigmoid(i_i + h_i)
forgetgate = self.sigmoid(i_f + h_f)
newgate = i_n
self.hidden = inputgate * newgate + forgetgate * self.hidden
outputs[i] = self.tanh(self.hidden)
if self.base_stack:
return outputs
else:
out = self.dense(outputs[-1])
out = self.relu(out)
return out
# ------------------------------------------------------------------------------------------------- #
# Added a way to stack up to 2 layers. For a stack of 2 the first layer has the same output shape than its input
class RAN_stack(torch.nn.Module):
def __init__(self, input_size, hidden_size, device, stacks=1, bias=True, sigmoid=None, tanh=None):
super(RAN_stack, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.stacks = stacks
self.device = device
if stacks == 1:
self.cell1 = RAN(input_size, hidden_size, device, bias, sigmoid, tanh)
elif stacks == 2:
self.cell1 = RAN(input_size, 14, device, bias, sigmoid, tanh, base_stack=True)
self.cell2 = RAN(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__":
# Displays the number of trainable parameters for different input sizes
import numpy as np
for i in [5, 10, 20, 50]:
Model = RAN_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)
|