def __init__(self,
input_size,
rnn_type,
num_units,
num_layers,
dropout,
use_cuda,
residual=False,
dense_residual=False):
super(RNNDecoder, self).__init__()
self.input_size = input_size
self.rnn_type = rnn_type
self.num_units = num_units
self.num_layers = num_layers
self.dropout = dropout
self.use_cuda = use_cuda
self.residual = residual
self.dense_residual = dense_residual
with self.init_scope():
for l in range(num_layers):
decoder_input_size = input_size if l == 0 else num_units
if rnn_type == 'stateless_lstm':
rnn_i = L.StatelessLSTM(in_size=decoder_input_size,
out_size=num_units)
elif rnn_type == 'lstm':
W = L.Linear(decoder_input_size, 4 * num_units)
V = L.Linear(num_units, 4 * num_units)
elif rnn_type == 'gru':
rnn_i = L.StatelessGRU(in_size=decoder_input_size,
out_size=num_units)
else:
raise ValueError(
'rnn_type must be "stateless_lstm" or "lstm" or "gru".'
)
if use_cuda:
if rnn_type == 'lstm':
W.to_gpu()
V.to_gpu()
else:
rnn_i.to_gpu()
if rnn_type == 'stateless_lstm':
setattr(self, 'lstm_l' + str(l), rnn_i)
elif rnn_type == 'lstm':
setattr(self, 'W_l' + str(l), W)
setattr(self, 'V_l' + str(l), V)
else:
setattr(self, rnn_type + '_l' + str(l), rnn_i)
def __init__(self, InitOpt, audiofeat):
units, dim, out = InitOpt
super(Dancer, self).__init__()
with self.init_scope():
self.audiofeat = audiofeat(dim)
self.enc_lstm1 = L.StatelessLSTM(dim, units)
self.enc_lstm2 = L.StatelessLSTM(units, units)
self.enc_lstm3 = L.StatelessLSTM(units, units)
self.fc01 = L.Linear(units, dim)
self.dec_lstm1 = L.StatelessLSTM(dim + out, units)
self.dec_lstm2 = L.StatelessLSTM(units, units)
self.dec_lstm3 = L.StatelessLSTM(units, units)
self.out_signal = L.Linear(units, out)
self.state = {
'ec1': None,
'ec2': None,
'ec3': None,
'eh1': None,
'eh2': None,
'eh3': None,
'dc1': None,
'dc2': None,
'dc3': None,
'dh1': None,
'dh2': None,
'dh3': None
}
self.delta_sgn = 0
self.ot = 0
self.h = 0
def __init__(self,
eprojs,
odim,
dtype,
dlayers,
dunits,
sos,
eos,
att,
verbose=0,
char_list=None,
labeldist=None,
lsm_weight=0.,
sampling_probability=0.0):
super(Decoder, self).__init__()
with self.init_scope():
self.embed = DL.EmbedID(odim, dunits)
self.rnn0 = L.StatelessLSTM(dunits + eprojs, dunits) if dtype == "lstm" \
else L.StatelessGRU(dunits + eprojs, dunits)
for l in six.moves.range(1, dlayers):
setattr(
self, 'rnn%d' % l,
L.StatelessLSTM(dunits, dunits)
if dtype == "lstm" else L.StatelessGRU(dunits, dunits))
self.output = L.Linear(dunits, odim)
self.dtype = dtype
self.loss = None
self.att = att
self.dlayers = dlayers
self.dunits = dunits
self.sos = sos
self.eos = eos
self.verbose = verbose
self.char_list = char_list
# for label smoothing
self.labeldist = labeldist
self.vlabeldist = None
self.lsm_weight = lsm_weight
self.sampling_probability = sampling_probability
def __init__(self, eprojs, odim, dlayers, dunits, sos, eos, att, verbose=0,
char_list=None, labeldist=None, lsm_weight=0.):
super(Decoder, self).__init__()
with self.init_scope():
self.embed = DL.EmbedID(odim, dunits)
self.lstm0 = L.StatelessLSTM(dunits + eprojs, dunits)
for l in six.moves.range(1, dlayers):
setattr(self, 'lstm%d' % l, L.StatelessLSTM(dunits, dunits))
self.output = L.Linear(dunits, odim)
self.loss = None
self.att = att
self.dlayers = dlayers
self.dunits = dunits
self.sos = sos
self.eos = eos
self.verbose = verbose
self.char_list = char_list
# for label smoothing
self.labeldist = labeldist
self.vlabeldist = None
self.lsm_weight = lsm_weight
def setUp(self):
self.link = links.StatelessLSTM(self.in_size, self.out_size)
upward = self.link.upward.W.data
upward[...] = numpy.random.uniform(-1, 1, upward.shape)
lateral = self.link.lateral.W.data
lateral[...] = numpy.random.uniform(-1, 1, lateral.shape)
self.link.zerograds()
self.upward = upward.copy() # fixed on CPU
self.lateral = lateral.copy() # fixed on CPU
x_shape = (4, self.in_size)
self.x = numpy.random.uniform(-1, 1, x_shape).astype(numpy.float32)
def __init__(self, n_vocab, n_layers, n_units, typ="lstm"):
super(RNNLM, self).__init__()
with self.init_scope():
self.embed = DL.EmbedID(n_vocab, n_units)
self.rnn = chainer.ChainList(
*[L.StatelessLSTM(n_units, n_units) for _ in range(n_layers)]) if typ == "lstm" \
else chainer.ChainList(*[L.StatelessGRU(n_units, n_units) for _ in range(n_layers)])
self.lo = L.Linear(n_units, n_vocab)
for param in self.params():
param.data[...] = np.random.uniform(-0.1, 0.1, param.data.shape)
self.n_layers = n_layers
self.n_units = n_units
self.typ = typ
def __init__(self, in_size, out_size, lateral_init=None, upward_init=None, bias_init=None, forget_bias_init=None):
log.info("Creating GatedLSTMCell(%i, %i)" % (in_size, out_size))
assert in_size == out_size
super(GatedLSTMCell, self).__init__(
lstm=L.StatelessLSTM(in_size, out_size, lateral_init=lateral_init, upward_init=upward_init, bias_init=bias_init, forget_bias_init=forget_bias_init),
gate_w=L.Linear(in_size, in_size)
)
self.add_param("initial_state", (1, out_size))
self.initial_state.data[...] = self.xp.random.randn(out_size)
self.add_persistent("initial_cell", self.xp.zeros((1, out_size), dtype=self.xp.float32))
self.add_persistent("initial_output", self.xp.zeros((1, out_size), dtype=self.xp.float32))
self.out_size = out_size
self.in_size = in_size
def __init__(self,
vocabulary_size: int,
word_embeddings_size: int,
hidden_layer_size: int,
attention_hidden_layer_size: int,
encoder_output_size: int,
maxout_layer_size: int,
maxout_pool_size: int = 2,
ignore_label: int = -1,
dynamic_attention: bool = False):
super(Decoder, self).__init__()
with self.init_scope():
self.embed_id = L.EmbedID(vocabulary_size,
word_embeddings_size,
ignore_label=ignore_label)
self.rnn = L.StatelessLSTM(
word_embeddings_size + encoder_output_size,
hidden_layer_size
)
self.maxout = L.Maxout(word_embeddings_size +
encoder_output_size +
hidden_layer_size,
maxout_layer_size,
maxout_pool_size)
self.linear = L.Linear(maxout_layer_size, vocabulary_size)
if dynamic_attention:
self.attention = DynamicAttentionModule(
encoder_output_size,
attention_hidden_layer_size,
hidden_layer_size,
word_embeddings_size
)
else:
self.attention = AttentionModule(
encoder_output_size,
attention_hidden_layer_size,
hidden_layer_size,
word_embeddings_size
)
self.bos_state = Parameter(
initializer=self.xp.random.randn(
1,
hidden_layer_size
).astype('f')
)
self.vocabulary_size = vocabulary_size
self.word_embeddings_size = word_embeddings_size
self.hidden_layer_size = hidden_layer_size
self.encoder_output_size = encoder_output_size
def setUp(self):
in_u = 2
out_u = 4
hidden_shape = (self.batch, out_u, out_u)
state_shape = (self.batch, in_u, out_u)
x_shape = (self.batch, in_u)
self.c_prev = numpy.random.uniform(-1, 1,
state_shape).astype(self.dtype)
self.h = numpy.random.uniform(-1, 1, hidden_shape).astype(self.dtype)
self.x = numpy.random.uniform(-1, 1, x_shape).astype(self.dtype)
self.model = L.StatelessLSTM(2, 4)
def __init__(self, n_hidden):
super(Encoder, self).__init__()
with self.init_scope():
self.lstm_forward1 = L.StatelessLSTM(n_hidden, n_hidden)
self.lstm_backward1 = L.StatelessLSTM(n_hidden, n_hidden)
self.lstm_forward2 = L.StatelessLSTM(n_hidden, n_hidden)
self.lstm_backward2 = L.StatelessLSTM(n_hidden, n_hidden)
self.lstm_forward3 = L.StatelessLSTM(n_hidden, n_hidden)
self.lstm_backward3 = L.StatelessLSTM(n_hidden,
n_hidden) #wordとpersona
def __init__(self,
n_vocab,
n_units,
n_attention_units,
n_encoder_output_units,
n_maxout_units,
n_maxout_pools=2):
super(Decoder, self).__init__()
with self.init_scope():
self.embed_y = L.EmbedID(n_vocab, n_units, ignore_label=-1)
self.lstm = L.StatelessLSTM(n_units + n_encoder_output_units,
n_units)
self.maxout = L.Maxout(n_units + n_encoder_output_units + n_units,
n_maxout_units, n_maxout_pools)
self.w = L.Linear(n_maxout_units, n_vocab)
self.attention = AttentionModule(n_encoder_output_units,
n_attention_units, n_units)
self.n_units = n_units
def __init__(self,
n_vocab,
n_units,
n_attention_units,
n_encoder_output_units,
n_maxout_units,
n_maxout_pools=2):
super(Decoder, self).__init__()
with self.init_scope():
self.embed_y = L.EmbedID(n_vocab, n_units, ignore_label=-1)
self.lstm = L.StatelessLSTM(n_units + n_encoder_output_units,
n_units)
self.maxout = L.Maxout(n_units + n_encoder_output_units + n_units,
n_maxout_units, n_maxout_pools)
self.w = L.Linear(n_maxout_units, n_vocab)
self.attention = AttentionModule(n_encoder_output_units,
n_attention_units, n_units)
self.bos_state = Parameter(
initializer=self.xp.random.randn(1, n_units).astype('f'))
self.n_units = n_units
def __init__(self, hidden_dim):
super(LstmRnn,
self).__init__(lstm=L.StatelessLSTM(hidden_dim, hidden_dim), )
