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)