def __init__(self, ninput, nhidden, noutput, nlayer=2, actfun=F.relu):
"""
:param ninput: number of inputs
:param nhidden: number of hidden units
:param noutput: number of outputs
:param nlayer: number of weight matrices (2; standard MLP)
:param actfun: used activation function (ReLU)
"""
links = ChainList()
if nlayer == 1:
links.add_link(L.Linear(ninput, noutput))
else:
links.add_link(L.Linear(ninput, nhidden))
for i in range(nlayer - 2):
links.add_link(L.Linear(nhidden, nhidden))
links.add_link(L.Linear(nhidden, noutput))
self.ninput = ninput
self.nhidden = nhidden
self.noutput = noutput
self.nlayer = nlayer
self.actfun = actfun
self.h = {}
super(DeepNeuralNetwork, self).__init__(links)
class WaveCRF(object):
def __init__(self):
self.log = {
('test', 'accuracy'): (),
('test', 'loss'): (),
('training', 'accuracy'): (),
('training', 'loss'): ()
}
self.model = ChainList(_WaveNet(), _CRF())
self.optimizer = optimizers.Adam(0.0002, 0.5)
self.optimizer.setup(self.model)
def __call__(self, x):
k, psi_u = self.model[0](x)
Q_hat = self.model[1](F.reshape(F.transpose(k, (0, 3, 1, 2)),
(-1, 61, 61)),
F.reshape(F.transpose(psi_u, (0, 3, 1, 2)),
(-1, 2, 61)))
return F.transpose(F.reshape(Q_hat, (x.shape[0], x.shape[3], 2, 61)),
(0, 2, 3, 1))
@classmethod
def load(cls, directory):
self = cls()
self.log = np.load('{}/log.npy'.format(directory))
serializers.load_npz('{}/model.npz'.format(directory), self.model)
serializers.load_npz('{}/optimizer.npz'.format(directory),
self.optimizer)
return self
def save(self, directory):
np.save('{}/log.npy'.format(directory), self.log)
serializers.save_npz('{}/model.npz'.format(directory), self.model)
serializers.save_npz('{}/optimizer.npz'.format(directory),
self.optimizer)
def test(self, Q, x):
with chainer.using_config('train', False):
Q_hat = self(x)
loss = F.softmax_cross_entropy(Q_hat, Q)
self.log['test', 'accuracy'] += (float(F.accuracy(Q_hat,
Q).data), )
self.log['test', 'loss'] += (float(loss.data), )
def train(self, Q, x):
Q_hat = self(x)
loss = F.softmax_cross_entropy(Q_hat, Q)
self.model.cleargrads()
loss.backward()
self.optimizer.update()
self.log['training', 'accuracy'] += (float(F.accuracy(Q_hat,
Q).data), )
self.log['training', 'loss'] += (float(loss.data), )
def __init__(self, ninput, nhidden, noutput, nlayer=2, link=L.LSTM):
"""
:param ninput: number of inputs
:param nhidden: number of hidden units
:param noutput: number of outputs
:param nlayer: number of weight matrices (2 = standard RNN with one layer of hidden units)
:param link: used recurrent link (LSTM)
"""
links = ChainList()
if nlayer == 1:
links.add_link(L.Linear(ninput, noutput))
else:
links.add_link(link(ninput, nhidden))
for i in range(nlayer - 2):
links.add_link(link(nhidden, nhidden))
links.add_link(L.Linear(nhidden, noutput))
self.ninput = ninput
self.nhidden = nhidden
self.noutput = noutput
self.nlayer = nlayer
self.h = {}
super(RecurrentNeuralNetwork, self).__init__(links)
def __init__(self, inplanes, scales=6, mingrid=1):
super(TUM, self).__init__()
self.scales = scales
with self.init_scope():
ecs = []
for s in range(scales-1):
if s == 0:
conv = Conv2DBNActiv(inplanes, 256, 3, 2, pad=1, nobias=True)
elif s == scales-2 and mingrid == 1:
conv = Conv2DBNActiv(256, 256, 3, 2, nobias=True)
else:
conv = Conv2DBNActiv(256, 256, 3, 2, pad=1, nobias=True)
ecs.append(conv)
self.ecs = ChainList(*ecs)
dcs = []
for s in range(scales):
if s == scales-1:
conv = Conv2DBNActiv(inplanes, 256, 3, pad=1, nobias=True)
else:
conv = Conv2DBNActiv(256, 256, 3, pad=1, nobias=True)
dcs.append(conv)
self.dcs = ChainList(*dcs)
self.scs = ChainList(*[Conv2DBNActiv(256, 128, 1, nobias=True) for _ in range(scales)])
def __init__(self, n_input, n_output, n_hidden=10, n_hidden_layers=1, actfun=F.relu):
"""
:param n_input: number of inputs
:param n_output: number of outputs
:param n_hidden: number of hidden units
:param n_hidden_layers: number of hidden layers (1; standard MLP)
:param actfun: used activation function (ReLU)
"""
links = ChainList()
if n_hidden_layers == 0:
links.add_link(L.Linear(n_input, n_output))
else:
links.add_link(L.Linear(n_input, n_hidden))
for i in range(n_hidden_layers - 1):
links.add_link(L.Linear(n_hidden, n_hidden))
links.add_link(L.Linear(n_hidden, n_output))
self.n_input = n_input
self.n_hidden = n_hidden
self.n_output = n_output
self.n_hidden_layers = n_hidden_layers
self.actfun = actfun
self.monitor = []
super(MLP, self).__init__(links)
def __init__(self, n_input, n_output, n_hidden=10, n_hidden_layers=1, link=L.LSTM):
"""
:param n_input: number of inputs
:param n_hidden: number of hidden units
:param n_output: number of outputs
:param n_hidden_layers: number of hidden layers
:param link: used recurrent link (LSTM)
"""
links = ChainList()
if n_hidden_layers == 0:
links.add_link(L.Linear(n_input, n_output))
else:
links.add_link(link(n_input, n_hidden))
for i in range(n_hidden_layers - 1):
links.add_link(link(n_hidden, n_hidden))
links.add_link(L.Linear(n_hidden, n_output))
self.n_input = n_input
self.n_hidden = n_hidden
self.n_output = n_output
self.n_hidden_layers = n_hidden_layers
self.monitor = []
super(RNN, self).__init__(links)
def __init__(self, depth, num_heads, model_dim, ff_dim, p_drop):
super().__init__()
with self.init_scope():
self.unit_links = ChainList()
for i in range(depth):
self.unit_links.append(
TransformerDecoderUnit(num_heads, model_dim, ff_dim,
p_drop))
def __init__(self, link, epoch=20, batch_size=100, visualize=True):
ChainList.__init__(self, link)
self.optimizer = optimizers.AdaDelta()
self.optimizer.setup(self)
self.loss_function = F.mean_squared_error
self.epoch = epoch
self.batch_size = batch_size
self.visualize = visualize
def __init__(self, link, epoch=10, batch_size=100, visualize=False):
ChainList.__init__(self, link)
self.optimizer = optimizers.AdaDelta()
self.optimizer.setup(self)
self.loss_function = F.mean_squared_error
self.epoch = epoch
self.batch_size = batch_size
self.visualize = visualize
def __init__(self, emb_dim, vocab_size, layer_dims, label_dim, z_dim):
super(SequenceDecoder, self).__init__(
rnn=Rnn(emb_dim, vocab_size, layer_dims, label_dim, suppress_output=False),
)
ls_zh = ChainList()
for d in layer_dims:
ls_zh.add_link(L.Linear(z_dim, d))
self.add_link('ls_zh', ls_zh)
class NNAutoEncoder():
def __init__(self,
encoder,
decoder,
optimizer,
epoch=20,
batch_size=100,
log_path="",
export_path="",
gpu_flag=-1):
self.encoder = encoder
self.decoder = decoder
self.optimizer = optimizer
self.epoch = epoch
self.batch_size = batch_size
self.log_path = log_path
self.export_path = export_path
self.autoencoded = ChainList()
self.gpu_flag = gpu_flag
def fit(self, x_train):
for layer in range(0, len(self.encoder)):
# Creating model
self.model = ChainList(self.encoder[layer].copy(),
self.decoder[layer].copy())
NNManager.forward = self.forward
nn = NNManager(self.model,
self.optimizer,
F.mean_squared_error,
self.epoch,
self.batch_size,
self.log_path,
gpu_flag=self.gpu_flag)
# Training
x_data = self.encode(x_train, layer).data
nn.fit(x_data, x_data)
self.autoencoded.add_link(nn.model[0].copy())
if self.export_path != "":
if self.gpu_flag >= 0:
self.autoencoded.to_cpu()
pickle.dump(self.autoencoded, open(self.export_path, 'wb'), -1)
return self
def predict(self, x_test):
raise Exception("Prediction for AutoEncoder is not implemented.")
def encode(self, x, n):
if n == 0:
return Variable(x)
else:
h = self.encode(x, n - 1)
return F.relu(self.autoencoded[n - 1](h))
def forward(self, x):
h = F.dropout(F.relu(self.model[0](x)))
return F.dropout(F.relu(self.model[1](h)))
def __init__(self, in_dim, hidden_dims, active):
super(_Mlp, self).__init__()
self.active = active
ds = [in_dim] + hidden_dims
ls = ChainList()
for d_in, d_out in zip(ds, ds[1:]):
l = L.Linear(d_in, d_out)
ls.add_link(l)
self.add_link('ls', ls)
def __init__(self, in_dim, hidden_dims, active):
super(_Mlp, self).__init__()
self.active = active
ds = [in_dim] + hidden_dims
ls = ChainList()
for d_in, d_out in zip(ds, ds[1:]):
l = L.Linear(d_in, d_out)
ls.add_link(l)
self.add_link('ls', ls)
def __init__(self, emb_dim, vocab_size, layer_dims, label_dim, z_dim):
super(SequenceDecoder, self).__init__(rnn=Rnn(emb_dim,
vocab_size,
layer_dims,
label_dim,
suppress_output=False), )
ls_zh = ChainList()
for d in layer_dims:
ls_zh.add_link(L.Linear(z_dim, d))
self.add_link('ls_zh', ls_zh)
def __init__(self, levels=8, scales=6, mingrid=1):
super(MLFPN, self).__init__()
self.levels = levels
with self.init_scope():
self.ffmv1 = FFMv1()
self.tums = ChainList(*[TUM(768, scales, mingrid) if l == 0 else TUM(256, scales, mingrid) for l in range(levels)])
self.ffmv2s = ChainList(*[FFMv2() for _ in range(levels-1)])
self.sfam = SFAM(levels, scales)
def __init__(self):
self.log = {
('test', 'accuracy'): (),
('test', 'loss'): (),
('training', 'accuracy'): (),
('training', 'loss'): ()
}
self.model = ChainList(_WaveNet(), _CRF())
self.optimizer = optimizers.Adam(0.0002, 0.5)
self.optimizer.setup(self.model)
def __construct(self):
"""
Instead of __init.
For correspond to gridsearchCV.
"""
self.last_unit = self.n_units[-1]
self.n_units = self.n_units[0:-1]
self.total_layer = len(self.n_units)
ChainList.__init__(self)
self.__collect_child_model()
self.optimizer.setup(self)
self.__constructed = True
def __init__(self, d, f, R):
self.d = d
self.f = f
self.R = R
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[
ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
for j in six.moves.range(5)
])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R)])
self.model = Chain(H=H, W=W, g=g)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def __init__(self):
super(QNet, self).__init__(_hidden_layers=ChainList(
L.Linear(None, 64),
L.Linear(None, 64),
L.Linear(None, 32),
),
_output_layer=L.Linear(None, 2))
def __init__(self, d, f, R, gpu):
self.d = d
self.f = f
self.R = R
self.gpu = gpu
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R + 1)])
self.optimizer = optimizers.Adam()
self.model = Chain(H=H, W=W, g=g)
if gpu:
self.model.to_gpu(0)
self.optimizer.setup(self.model)
self.to = [[] for i in six.moves.range(2)]
self.atom_sid = [[] for i in six.moves.range(2)]
self.anum = [[] for i in six.moves.range(2)]
class TUM(chainer.Chain):
def __init__(self, inplanes, scales=6, mingrid=1):
super(TUM, self).__init__()
self.scales = scales
with self.init_scope():
ecs = []
for s in range(scales - 1):
if s == 0:
conv = Conv2DBNActiv(inplanes,
256,
3,
2,
pad=1,
nobias=True)
elif s == scales - 2 and mingrid == 1:
conv = Conv2DBNActiv(256, 256, 3, 2, nobias=True)
else:
conv = Conv2DBNActiv(256, 256, 3, 2, pad=1, nobias=True)
ecs.append(conv)
self.ecs = ChainList(*ecs)
dcs = []
for s in range(scales):
if s == scales - 1:
conv = Conv2DBNActiv(inplanes, 256, 3, pad=1, nobias=True)
else:
conv = Conv2DBNActiv(256, 256, 3, pad=1, nobias=True)
dcs.append(conv)
self.dcs = ChainList(*dcs)
self.scs = ChainList(*[
Conv2DBNActiv(256, 128, 1, nobias=True) for _ in range(scales)
])
def __call__(self, x):
e = x
es = [e]
for conv in self.ecs.children():
e = conv(e)
es.append(e)
d = es[-1]
ds = [d]
for s in range(self.scales - 2):
d = F.resize_images(
self.dcs[s](d),
(es[-(s + 2)].shape[2], es[-(s + 2)].shape[3])) + es[-(s + 2)]
ds.append(d)
d = F.resize_images(
self.dcs[self.scales - 2](d),
(x.shape[2], x.shape[3])) + self.dcs[self.scales - 1](x)
ds.append(d)
ys = []
for s in range(self.scales):
ys.append(self.scs[s](ds[s]))
return ys[::-1]
def __init__(self):
super(PolicyNet, self).__init__(hidden_layers=ChainList(
L.Linear(None, 32),
L.Linear(None, 32),
L.Linear(None, 16),
),
output_layer=L.Linear(None, 2))
def __init__(self, levels=8, scales=6, planes=1024):
super(SFAM, self).__init__()
self.levels = levels
self.scales = scales
with self.init_scope():
self.ses = ChainList(*[SEBlock(planes) for _ in range(scales)])
def __init__(self, num_molecules, rep_dim, max_degree, num_levels):
super(Mol2Vec2, self).__init__()
num_degree_type = max_degree + 1
with self.init_scope():
self.mol_embed_layer = L.EmbedID(num_molecules, rep_dim)
self.atom_embed_layer = L.EmbedID(MAX_NUMBER_ATOM, rep_dim)
self.edge_layer = L.Linear(rep_dim, rep_dim * MAX_EDGE_TYPE)
self.out = L.Linear(rep_dim, MAX_ATOM_TYPE)
self.H = ChainList(*[ChainList(
*[L.Linear(rep_dim, rep_dim)
for i in six.moves.range(num_degree_type)])
for j in six.moves.range(num_levels)])
# representation dim of molecules, substructures and atoms
self.rep_dim = rep_dim
self.max_degree_type = num_degree_type
self.num_mol = num_molecules
self.n_levels = num_levels
class TransformerEncoder(Chain):
def __init__(self, depth, num_heads, model_dim, ff_dim, p_drop):
super().__init__()
with self.init_scope():
self.unit_links = ChainList()
for i in range(depth):
self.unit_links.append(
TransformerEncoderUnit(num_heads, model_dim, ff_dim,
p_drop))
def forward(self, input_encodings, input_masks=None):
unit_inputs = [input_encodings]
for unit_link in self.unit_links:
x = unit_inputs[-1]
o = unit_link(x, input_masks=input_masks)
unit_inputs.append(o)
return unit_inputs[-1]
class NNAutoEncoder ():
def __init__(self, encoder, decoder, optimizer,
epoch=20, batch_size=100, log_path="", export_path="", gpu_flag=-1):
self.encoder = encoder
self.decoder = decoder
self.optimizer = optimizer
self.epoch = epoch
self.batch_size = batch_size
self.log_path = log_path
self.export_path = export_path
self.autoencoded = ChainList()
self.gpu_flag= gpu_flag
def fit(self, x_train):
for layer in range(0, len(self.encoder)):
# Creating model
self.model = ChainList(self.encoder[layer].copy(), self.decoder[layer].copy())
NNManager.forward = self.forward
nn = NNManager(self.model, self.optimizer, F.mean_squared_error,
self.epoch, self.batch_size, self.log_path, gpu_flag=self.gpu_flag)
# Training
x_data = self.encode(x_train, layer).data
nn.fit(x_data, x_data)
self.autoencoded.add_link(nn.model[0].copy())
if self.export_path != "":
if self.gpu_flag >= 0:
self.autoencoded.to_cpu()
pickle.dump(self.autoencoded, open(self.export_path, 'wb'), -1)
return self
def predict(self, x_test):
raise Exception("Prediction for AutoEncoder is not implemented.")
def encode(self, x, n):
if n == 0:
return Variable(x)
else:
h = self.encode(x, n-1)
return F.relu(self.autoencoded[n-1](h))
def forward(self, x):
h = F.dropout(F.relu(self.model[0](x)))
return F.dropout(F.relu(self.model[1](h)))
def __init__(self):
super(ValueNet, self).__init__(
_hidden_layers = ChainList(
L.Linear(None, 32),
L.Linear(None, 32),
L.Linear(None, 16),
),
_output_layer = L.Linear(None, 1)
)
def __init__(self, n_output, resolution, n_stack, n_dilateStack,
n_in_channel, n_skip_channel, useGPU):
self.n_output = n_output
firstConv = L.Convolution2D(None, n_in_channel, ksize=1)
wn = []
for s in range(n_stack):
for d in range(n_dilateStack):
wn.append(WaveBlock(n_in_channel, n_skip_channel, 2**d,
useGPU))
lastConv0 = L.Convolution2D(n_skip_channel, n_skip_channel, ksize=1)
lastConv1 = L.Convolution2D(n_skip_channel, n_skip_channel, ksize=1)
linear = [L.Linear(None, resolution) for i in range(n_output)]
super(Wavenet, self).__init__(firstConv=firstConv,
waveBlocks=ChainList(*wn),
lastConv0=lastConv0,
lastConv1=lastConv1,
linear=ChainList(*linear))
def __init__(self,
encoder,
decoder,
optimizer,
epoch=20,
batch_size=100,
log_path="",
export_path="",
gpu_flag=-1):
self.encoder = encoder
self.decoder = decoder
self.optimizer = optimizer
self.epoch = epoch
self.batch_size = batch_size
self.log_path = log_path
self.export_path = export_path
self.autoencoded = ChainList()
self.gpu_flag = gpu_flag
def __init__(self, n_units, epoch=10, batch_size=20, visualize=True, is_classification=True, **keywords):
ChainList.__init__(self)
self.n_units = n_units[0:-1]
self.last_unit = n_units[-1]
self.total_layer = len(n_units)
self.set_optimizer()
self.epoch = epoch
self.batch_size = batch_size
self.visualize = visualize
self.is_classification = is_classification
self.pre_trained = False
if 'nobias' in keywords.keys():
self.nobias = keywords['nobias']
else:
self.nobias = False
self.keywords = keywords
self.collect_child_model()
def __init__(self, rnns, dims, pyramidal, dropout_ratio):
super(MultiLayerRnn, self).__init__(rnns=rnns, )
self.pyramidal = pyramidal
if self.pyramidal:
self.add_link('combine_twos', ChainList())
for in_dim, out_dim in zip(dims, dims[1:]):
combine_two = CombineTwo(in_dim, out_dim)
self.combine_twos.add_link(combine_two)
assert len(self.rnns) == len(self.combine_twos) + 1
self.dropout_ratio = dropout_ratio
def __init__(self, encoder, decoder, optimizer,
epoch=20, batch_size=100, log_path="", export_path="", gpu_flag=-1):
self.encoder = encoder
self.decoder = decoder
self.optimizer = optimizer
self.epoch = epoch
self.batch_size = batch_size
self.log_path = log_path
self.export_path = export_path
self.autoencoded = ChainList()
self.gpu_flag= gpu_flag
def __init__(self, emb_dim, vocab_size, layer_dims, label_dim, z_dim):
super(SequenceEncoder, self).__init__(rnn=Rnn(emb_dim,
vocab_size,
layer_dims,
label_dim,
suppress_output=True), )
ls_mu = ChainList()
ls_ln_var = ChainList()
for d in layer_dims:
ls_mu.add_link(L.Linear(d, z_dim))
ls_ln_var.add_link(L.Linear(d, z_dim))
self.add_link('ls_mu', ls_mu)
self.add_link('ls_ln_var', ls_ln_var)
def __init__(self, size, levels, first_channels, last_channels): super().__init__() in_channels = [first_channels] * levels out_channels = [last_channels] * levels for i in range(1, levels): channels = min(first_channels, last_channels * 2 ** i) in_channels[-i] = channels out_channels[-i - 1] = channels with self.init_scope(): self.init = InitialSkipArchitecture(size, in_channels[0], out_channels[0]) self.skips = ChainList(*[SkipArchitecture(size, i, o) for i, o in zip(in_channels[1:], out_channels[1:])])
def __init__(self):
super(PolicyNet, self).__init__(
_hidden_layers = ChainList(
L.Linear(None, 32),
L.Linear(None, 32),
L.Linear(None, 16),
),
_output_layer = L.Linear(None, 2)
)
self._eps = 1e-5 #sigma=0を避けるための微小数
def __init__(self, probability=0.5): super().__init__() self.probability = probability with self.init_scope(): self.manipulations = ChainList(*[ Mirror(), Rotation(), Shift(), AffineTransformation(), ColorAffineTransformation(), AdditiveNoise(), Cutout()])
def __init__(self, in_vocab_size, hidden_dim, layer_num, out_vocab_size, gru, bidirectional, pyramidal, dropout_ratio, src_vocab_size=None):
super(AttentionalEncoderDecoder, self).__init__()
if src_vocab_size is None:
# use same vocabulary for source/target
word_emb = L.EmbedID(in_vocab_size, hidden_dim, ignore_label=IGNORE_ID)
self.add_link('word_emb', word_emb)
self.word_emb_src = word_emb
self.word_emb_trg = word_emb
else:
word_emb_src = L.EmbedID(src_vocab_size, hidden_dim, ignore_label=IGNORE_ID)
word_emb_trg = L.EmbedID(in_vocab_size, hidden_dim, ignore_label=IGNORE_ID)
self.add_link('word_emb_src', word_emb_src)
self.add_link('word_emb_trg', word_emb_trg)
rnns = ChainList()
Rnn = GruRnn if gru else LstmRnn
for i in range(layer_num):
if bidirectional:
rnn_f = Rnn(hidden_dim)
rnn_b = Rnn(hidden_dim)
rnn = BiRnn(rnn_f, rnn_b)
else:
rnn = Rnn(hidden_dim)
rnns.add_link(rnn)
multi_rnn = MultiLayerRnn(rnns, [hidden_dim] * layer_num, pyramidal, dropout_ratio)
self.add_link('encoder', Encoder(self.word_emb_src, multi_rnn))
self.add_link('decoder', AttentionalDecoder(self.word_emb_trg, hidden_dim, layer_num, out_vocab_size, gru, dropout_ratio))
self.in_vocab_size = in_vocab_size
self.hidden_dim = hidden_dim
self.layer_num = layer_num
self.out_vocab_size = out_vocab_size
self.gru = gru
self.bidirectional = bidirectional
self.pyramidal = pyramidal
def __init__(self, emb_dim, vocab_size, layer_dims, label_dim, z_dim):
super(SequenceEncoder, self).__init__(
rnn=Rnn(emb_dim, vocab_size, layer_dims, label_dim, suppress_output=True),
)
ls_mu = ChainList()
ls_ln_var = ChainList()
for d in layer_dims:
ls_mu.add_link(L.Linear(d, z_dim))
ls_ln_var.add_link(L.Linear(d, z_dim))
self.add_link('ls_mu', ls_mu)
self.add_link('ls_ln_var', ls_ln_var)
def __init__(self, emb_dim, vocab_size, layer_dims, feature_dim, suppress_output, eos_id=0):
"""
Recurrent Neural Network with multiple layers.
in_dim -> layers[0] -> ... -> layers[-1] -> out_dim (optional)
:param int emb_dim: dimension of embeddings
:param int vocab_size: size of vocabulary
:param layer_dims: dimensions of hidden layers
:param int feature_dim: dimesion of external feature
:type layer_dims: list of int
:param bool suppress_output: whether to suppress output
:param int eos_id: ID of <BOS> and <EOS>
"""
super(Rnn, self).__init__(emb=F.EmbedID(vocab_size, emb_dim))
self.emb_dim = emb_dim
self.vocab_size = vocab_size
self.layer_dims = layer_dims
self.feature_dim = feature_dim
self.suppress_output = suppress_output
self.eos_id = eos_id
# add hidden layer_dims
ls_xh = ChainList()
ls_hh = ChainList()
ls_fh = ChainList()
layer_dims = [emb_dim] + layer_dims
for in_dim, out_dim in zip(layer_dims, layer_dims[1:]):
ls_xh.add_link(F.Linear(in_dim, out_dim*4))
ls_hh.add_link(F.Linear(out_dim, out_dim*4))
ls_fh.add_link(F.Linear(feature_dim, out_dim*4))
self.add_link('ls_xh', ls_xh)
self.add_link('ls_hh', ls_hh)
self.add_link('ls_fh', ls_fh)
if not suppress_output:
# add output layer
self.add_link('l_y', F.Linear(layer_dims[-1], self.vocab_size))
