def __init__(self, input_size, batch_size=64, hidden_size=512, num_layer=2):
super(StackedRNNForGPU, self).__init__()
self.batch_size = batch_size
self.input_size = input_size
self.num_classes = 11
self.reshape = P.Reshape()
self.cast = P.Cast()
k = (1 / hidden_size) ** 0.5
weight_shape = 4 * hidden_size * (input_size + 3 * hidden_size + 4)
self.weight = Parameter(np.random.uniform(-k, k, (weight_shape, 1, 1)).astype(np.float32), name='weight')
self.h = Tensor(np.zeros(shape=(num_layer, batch_size, hidden_size)).astype(np.float32))
self.c = Tensor(np.zeros(shape=(num_layer, batch_size, hidden_size)).astype(np.float32))
self.lstm = nn.LSTM(input_size, hidden_size, num_layers=2)
self.lstm.weight = self.weight
self.fc_weight = np.random.random((self.num_classes, hidden_size)).astype(np.float32)
self.fc_bias = np.random.random(self.num_classes).astype(np.float32)
self.fc = nn.Dense(in_channels=hidden_size, out_channels=self.num_classes, weight_init=Tensor(self.fc_weight),
bias_init=Tensor(self.fc_bias))
self.fc.to_float(mstype.float32)
self.expand_dims = P.ExpandDims()
self.concat = P.Concat()
self.transpose = P.Transpose()
def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
bidirectional, num_classes, weight, batch_size):
super(SentimentNet, self).__init__()
# Mapp words to vectors
self.embedding = nn.Embedding(vocab_size,
embed_size,
embedding_table=weight)
self.embedding.embedding_table.requires_grad = False
self.trans = P.Transpose()
self.perm = (1, 0, 2)
self.encoder = nn.LSTM(input_size=embed_size,
hidden_size=num_hiddens,
num_layers=num_layers,
has_bias=True,
bidirectional=bidirectional,
dropout=0.0)
w_init = init_lstm_weight(embed_size, num_hiddens, num_layers,
bidirectional)
self.encoder.weight = w_init
self.h, self.c = lstm_default_state(batch_size, num_hiddens,
num_layers, bidirectional)
self.concat = P.Concat(1)
if bidirectional:
self.decoder = nn.Dense(num_hiddens * 4, num_classes)
else:
self.decoder = nn.Dense(num_hiddens * 2, num_classes)
def __init__(self, input_size, hidden_size, num_layers, has_bias,
batch_first, bidirectional):
super(LstmTestNet, self).__init__()
self.lstm = nn.LSTM(input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
has_bias=has_bias,
batch_first=batch_first,
bidirectional=bidirectional,
dropout=0.0)
def __init__(self, batch_size, input_size, hidden_size, num_layers,
has_bias, bidirectional, dropout):
super(LstmNet, self).__init__()
num_directions = 1
if bidirectional:
num_directions = 2
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, has_bias,
bidirectional, dropout)
input_np = np.array([[[0.6755, -1.6607, 0.1367],
[0.4276, -0.7850, -0.3758]],
[[-0.6424, -0.6095, 0.6639],
[0.7918, 0.4147, -0.5089]],
[[-1.5612, 0.0120, -0.7289],
[-0.6656, -0.6626, -0.5883]],
[[-0.9667, -0.6296, -0.7310],
[0.1026, -0.6821, -0.4387]],
[[-0.4710, 0.6558, -0.3144],
[-0.8449, -0.2184, -0.1806]]]).astype(np.float32)
self.x = Tensor(input_np)
self.h = Tensor(
np.array([0., 0., 0., 0.]).reshape(
(num_directions, batch_size, hidden_size)).astype(np.float32))
self.c = Tensor(
np.array([0., 0., 0., 0.]).reshape(
(num_directions, batch_size, hidden_size)).astype(np.float32))
self.h = tuple((self.h, ))
self.c = tuple((self.c, ))
wih = np.array([
[3.4021e-01, -4.6622e-01, 4.5117e-01],
[-6.4257e-02, -2.4807e-01, 1.3550e-02], # i
[-3.2140e-01, 5.5578e-01, 6.3589e-01],
[1.6547e-01, -7.9030e-02, -2.0045e-01],
[-6.9863e-01, 5.9773e-01, -3.9062e-01],
[-3.0253e-01, -1.9464e-01, 7.0591e-01],
[-4.0835e-01, 3.6751e-01, 4.7989e-01],
[-5.6894e-01, -5.0359e-01, 4.7491e-01]
]).astype(np.float32).reshape([1, -1])
whh = np.array([[-0.4820, -0.2350], [-0.1195,
0.0519], [0.2162, -0.1178],
[0.6237, 0.0711], [0.4511, -0.3961], [-0.5962, 0.0906],
[0.1867, -0.1225],
[0.1831, 0.0850]]).astype(np.float32).reshape([1, -1])
bih = np.zeros((1, 8)).astype(np.float32)
w_np = np.concatenate((wih, whh, bih), axis=1).reshape([-1, 1, 1])
self.w = Parameter(initializer(Tensor(w_np), w_np.shape), name='w')
self.lstm.weight = ParameterTuple((self.w, ))
def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
bidirectional, num_classes, weight, batch_size):
super(SentimentNet, self).__init__()
# Mapp words to vectors
self.embedding = nn.Embedding(vocab_size,
embed_size,
embedding_table=weight)
self.embedding.embedding_table.requires_grad = False
self.trans = P.Transpose()
self.perm = (1, 0, 2)
if context.get_context("device_target") in STACK_LSTM_DEVICE:
# stack lstm by user
self.encoder = StackLSTM(input_size=embed_size,
hidden_size=num_hiddens,
num_layers=num_layers,
has_bias=True,
bidirectional=bidirectional,
dropout=0.0)
self.h, self.c = stack_lstm_default_state(batch_size, num_hiddens,
num_layers,
bidirectional)
elif context.get_context("device_target") == "GPU":
# standard lstm
self.encoder = nn.LSTM(input_size=embed_size,
hidden_size=num_hiddens,
num_layers=num_layers,
has_bias=True,
bidirectional=bidirectional,
dropout=0.0)
self.h, self.c = lstm_default_state(batch_size, num_hiddens,
num_layers, bidirectional)
else:
self.encoder = StackLSTMAscend(input_size=embed_size,
hidden_size=num_hiddens,
num_layers=num_layers,
has_bias=True,
bidirectional=bidirectional)
self.h, self.c = stack_lstm_default_state_ascend(
batch_size, num_hiddens, num_layers, bidirectional)
self.concat = P.Concat(1)
self.squeeze = P.Squeeze(axis=0)
if bidirectional:
self.decoder = nn.Dense(num_hiddens * 4, num_classes)
else:
self.decoder = nn.Dense(num_hiddens * 2, num_classes)
def __init__(self, batch_size, input_size, hidden_size, num_layers, has_bias, bidirectional, dropout):
super(MultiLayerBiLstmNet, self).__init__()
num_directions = 1
if bidirectional:
num_directions = 2
self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, has_bias=has_bias,
bidirectional=bidirectional, dropout=dropout)
input_np = np.array([[[-0.1887, -0.4144, -0.0235, 0.7489, 0.7522, 0.5969, 0.3342, 1.2198, 0.6786, -0.9404],
[-0.8643, -1.6835, -2.4965, 2.8093, 0.1741, 0.2707, 0.7387, -0.0939, -1.7990, 0.4765]],
[[-0.5963, -1.2598, -0.7226, 1.1365, -1.7320, -0.7302, 0.1221, -0.2111, -1.6173, -0.0706],
[0.8964, 0.1737, -1.0077, -0.1389, 0.4889, 0.4391, 0.7911, 0.3614, -1.9533, -0.9936]],
[[0.3260, -1.3312, 0.0601, 1.0726, -1.6010, -1.8733, -1.5775, 1.1579, -0.8801, -0.5742],
[-2.2998, -0.6344, -0.5409, -0.9221, -0.6500, 0.1206, 1.5215, 0.7517, 1.3691, 2.0021]],
[[-0.1245, -0.3690, 2.1193, 1.3852, -0.1841, -0.8899, -0.3646, -0.8575, -0.3131, 0.2026],
[1.0218, -1.4331, 0.1744, 0.5442, -0.7808, 0.2527, 0.1566, 1.1484, -0.7766, -0.6747]],
[[-0.6752, 0.9906, -0.4973, 0.3471, -0.1202, -0.4213, 2.0213, 0.0441, 0.9016, 1.0365],
[1.2223, -1.3248, 0.1207, -0.8256, 0.1816, 0.7057, -0.3105, 0.5713, 0.2804,
-1.0685]]]).astype(np.float32)
self.x = Tensor(input_np)
self.h0 = Tensor(np.ones((num_directions, batch_size, hidden_size)).astype(np.float32))
self.c0 = Tensor(np.ones((num_directions, batch_size, hidden_size)).astype(np.float32))
self.h1 = Tensor(np.ones((num_directions, batch_size, hidden_size)).astype(np.float32))
self.c1 = Tensor(np.ones((num_directions, batch_size, hidden_size)).astype(np.float32))
self.h = tuple((self.h0, self.h1))
self.c = tuple((self.c0, self.c1))
input_size_list = [input_size, hidden_size * num_directions]
weights = []
bias_size = 0 if not has_bias else num_directions * hidden_size * 4
for i in range(num_layers):
weight_size = (input_size_list[i] + hidden_size) * num_directions * hidden_size * 4
w_np = np.ones([weight_size, 1, 1]).astype(np.float32) * 0.02
if has_bias:
bias_np = np.zeros([bias_size, 1, 1]).astype(np.float32)
w_np = np.concatenate([w_np, bias_np], axis=0)
weights.append(Parameter(initializer(Tensor(w_np), w_np.shape), name='weight' + str(i)))
self.lstm.weight = weights
def __init__(self, seq_len, batch_size, input_size, hidden_size,
num_layers, has_bias, bidirectional, dropout):
super(MultiLayerBiLstmNet, self).__init__()
num_directions = 1
if bidirectional:
num_directions = 2
self.lstm = nn.LSTM(input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
has_bias=has_bias,
bidirectional=bidirectional,
dropout=dropout)
input_np = np.array([[[
-0.1887, -0.4144, -0.0235, 0.7489, 0.7522, 0.5969, 0.3342, 1.2198,
0.6786, -0.9404
],
[
-0.8643, -1.6835, -2.4965, 2.8093, 0.1741,
0.2707, 0.7387, -0.0939, -1.7990, 0.4765
]],
[[
-0.5963, -1.2598, -0.7226, 1.1365, -1.7320,
-0.7302, 0.1221, -0.2111, -1.6173, -0.0706
],
[
0.8964, 0.1737, -1.0077, -0.1389, 0.4889,
0.4391, 0.7911, 0.3614, -1.9533, -0.9936
]],
[[
0.3260, -1.3312, 0.0601, 1.0726, -1.6010,
-1.8733, -1.5775, 1.1579, -0.8801, -0.5742
],
[
-2.2998, -0.6344, -0.5409, -0.9221, -0.6500,
0.1206, 1.5215, 0.7517, 1.3691, 2.0021
]],
[[
-0.1245, -0.3690, 2.1193, 1.3852, -0.1841,
-0.8899, -0.3646, -0.8575, -0.3131, 0.2026
],
[
1.0218, -1.4331, 0.1744, 0.5442, -0.7808,
0.2527, 0.1566, 1.1484, -0.7766, -0.6747
]],
[[
-0.6752, 0.9906, -0.4973, 0.3471, -0.1202,
-0.4213, 2.0213, 0.0441, 0.9016, 1.0365
],
[
1.2223, -1.3248, 0.1207, -0.8256, 0.1816,
0.7057, -0.3105, 0.5713, 0.2804, -1.0685
]]]).astype(np.float32)
self.x = Parameter(initializer(Tensor(input_np),
[seq_len, batch_size, input_size]),
name='x')
self.h0 = Parameter(initializer(
Tensor(
np.ones((num_directions, batch_size,
hidden_size)).astype(np.float32)),
[num_directions, batch_size, hidden_size]),
name='h0')
self.c0 = Parameter(initializer(
Tensor(
np.ones((num_directions, batch_size,
hidden_size)).astype(np.float32)),
[num_directions, batch_size, hidden_size]),
name='c0')
self.h1 = Parameter(initializer(
Tensor(
np.ones((num_directions, batch_size,
hidden_size)).astype(np.float32)),
[num_directions, batch_size, hidden_size]),
name='h1')
self.c1 = Parameter(initializer(
Tensor(
np.ones((num_directions, batch_size,
hidden_size)).astype(np.float32)),
[num_directions, batch_size, hidden_size]),
name='c1')
self.h = ParameterTuple((self.h0, self.h1))
self.c = ParameterTuple((self.c0, self.c1))
