def __init__(
self,
eprojs,
odim,
dtype,
dlayers,
dunits,
sos,
eos,
att,
verbose=0,
char_list=None,
labeldist=None,
lsm_weight=0.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, n_layers, in_size, out_size, n_target_vocab):
super(AttGRUdec, self).__init__(
W1=L.Linear(in_size, att_size),
W2=L.Linear(in_size, att_size),
W3=L.Linear(out_size * 2, out_size),
rnn=L.StatelessGRU(in_size, out_size),
)
self.in_size = in_size
def __init__(self, in_size, out_size, init=None, inner_init=None, bias_init=None):
log.info("Creating GRUCell(%i, %i)" % (in_size, out_size))
super(GRUCell, self).__init__(
gru=L.StatelessGRU(in_size, out_size, init=init, inner_init=inner_init, bias_init=bias_init),
)
self.add_param("initial_state", (1, out_size))
self.initial_state.data[...] = self.xp.random.randn(out_size)
self.out_size = out_size
self.in_size = in_size
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, 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, hidden_dims, f_dims, g_dims, x_dims, ar_tau,
ar_noise_variance, batch_size, xp):
super(GaussianGenerator, self).__init__()
with self.init_scope():
self.hidden_dims = hidden_dims
self.gru = L.StatelessGRU(in_size=in_size, out_size=hidden_dims)
self.l_g0_mu = L.Linear(None, g_dims)
self.l_g0_ln_var = L.Linear(None, g_dims)
self.l_f = L.Linear(None, f_dims)
self.l_x_mu = L.Linear(None, x_dims)
self.l_x_ln_var = L.Linear(None, x_dims)
self.l_u_mu = L.Linear(None, in_size)
self.l_u_ln_var = L.Linear(None, in_size)
self.g_dims = g_dims
self.u_dims = in_size
# self.hoge = L.Linear(1,log_evar_dims)
# process variance, the variance at time t over all instantiations of AR(1)
log_evar = F.log(xp.asarray(ar_noise_variance, dtype=xp.float32))
self.log_evar = log_evar
# \tau, the autocorrelation time constant of the AR(1) process
log_atau = xp.log(ar_tau)
# alpha in x_t = \mu + alpha x_tm1 + \eps
# alpha = exp(-1/tau)
# alpha = exp(-1/exp(logtau))
# alpha = exp(-exp(-logtau))
alphas = xp.exp(-xp.exp(-log_atau), dtype=xp.float32)
alphas_p1 = xp.array(xp.float32(1.0) + alphas)
alphas_m1 = xp.array(xp.float32(1.0) - alphas)
self.alphas = alphas
# process noise
# pvar = evar / (1- alpha^2)
# logpvar = log ( exp(logevar) / (1 - alpha^2) )
# logpvar = logevar - log(1-alpha^2)
# logpvar = logevar - (log(1-alpha) + log(1+alpha))
log_pvar = log_evar - xp.log(alphas_m1) - xp.log(alphas_p1)
self.log_pvar = log_pvar
def __init__(self, in_size, hidden_dims):
super(GaussianController, self).__init__()
with self.init_scope():
self.hidden_dims = hidden_dims
self.gru = L.StatelessGRU(in_size=in_size, out_size=hidden_dims)
def __init__(self, dim_zc=50, dim_zm=10, dim_zl=0, out_channels=3, \
n_filters=64, video_len=16):
super(ImageGenerator, self).__init__()
self.dim_zc = dim_zc
self.dim_zm = dim_zm
self.dim_zl = dim_zl
self.out_channels = out_channels
self.n_filters = n_filters
self.video_len = video_len
n_hidden = dim_zc + dim_zm
self.n_hidden = n_hidden
self.use_label = dim_zl != 0
self.name = self.__class__.__name__
with self.init_scope():
w = chainer.initializers.GlorotNormal()
# Rm
if self.use_label:
self.g0 = L.StatelessGRU(self.dim_zm + self.dim_zl,
self.dim_zm)
else:
self.g0 = L.StatelessGRU(self.dim_zm, self.dim_zm)
# G
self.dc1 = L.DeconvolutionND(2,
n_hidden,
n_filters * 8,
4,
stride=1,
pad=0,
initialW=w)
self.dc2 = L.DeconvolutionND(2,
n_filters * 8,
n_filters * 4,
4,
stride=2,
pad=1,
initialW=w)
self.dc3 = L.DeconvolutionND(2,
n_filters * 4,
n_filters * 2,
4,
stride=2,
pad=1,
initialW=w)
self.dc4 = L.DeconvolutionND(2,
n_filters * 2,
n_filters,
4,
stride=2,
pad=1,
initialW=w)
self.dc5 = L.DeconvolutionND(2,
n_filters,
out_channels,
4,
stride=2,
pad=1,
initialW=w)
self.bn1 = L.BatchNormalization(n_filters * 8)
self.bn2 = L.BatchNormalization(n_filters * 4)
self.bn3 = L.BatchNormalization(n_filters * 2)
self.bn4 = L.BatchNormalization(n_filters)