def __init__(self,
in_size,
out_size,
lateral_init=None,
upward_init=None,
bias_init=0,
forget_bias_init=0):
super(LNStatelessLSTM,
self).__init__(upward=linear.Linear(in_size,
4 * out_size,
initialW=0),
lateral=linear.Linear(out_size,
4 * out_size,
initialW=0,
nobias=True),
upward_ln=LayerNormalization(),
lateral_ln=LayerNormalization(),
output_ln=LayerNormalization())
self.state_size = out_size
self.lateral_init = lateral_init
self.upward_init = upward_init
self.bias_init = bias_init
self.forget_bias_init = forget_bias_init
if in_size is not None:
self._initialize_params()
def __init__(self, in_size, out_size):
super(SGU, self).__init__(
W_xh=linear.Linear(in_size, out_size),
W_zxh=linear.Linear(out_size, out_size),
W_xz=linear.Linear(in_size, out_size),
W_hz=linear.Linear(out_size, out_size),
)
def __init__(self, use_cudnn=True, conv4_out_channels=384):
super(AlexOWT, self).__init__(
conv1=convolution_2d.Convolution2D(3,
64,
11,
stride=4,
pad=2,
use_cudnn=use_cudnn),
conv2=convolution_2d.Convolution2D(64,
192,
5,
pad=2,
use_cudnn=use_cudnn),
conv3=convolution_2d.Convolution2D(192,
384,
3,
pad=1,
use_cudnn=use_cudnn),
conv4=convolution_2d.Convolution2D(384,
conv4_out_channels,
3,
pad=1,
use_cudnn=use_cudnn),
conv5=convolution_2d.Convolution2D(conv4_out_channels,
256,
3,
pad=1,
use_cudnn=use_cudnn),
fc6=linear.Linear(9216, 4096),
fc7=linear.Linear(4096, 4096),
fc8=linear.Linear(4096, 1000))
def __init__(self,
in_size,
out_size=None,
lateral_init=None,
upward_init=None,
bias_init=None,
forget_bias_init=None):
if out_size is None:
out_size, in_size = in_size, None
super(LSTMBase, self).__init__()
if bias_init is None:
bias_init = 0
if forget_bias_init is None:
forget_bias_init = 1
self.state_size = out_size
self.lateral_init = lateral_init
self.upward_init = upward_init
self.bias_init = bias_init
self.forget_bias_init = forget_bias_init
with self.init_scope():
self.upward = linear.Linear(in_size, 4 * out_size, initialW=0)
self.lateral = linear.Linear(out_size,
4 * out_size,
initialW=0,
nobias=True)
if in_size is not None:
self._initialize_params()
def __init__(self,
n_units,
n_inputs=None,
n_units2=None,
initU=None,
initW=None,
initV=None,
bias_init=0):
"""
:param n_units: Number of hidden units
:param n_inputs: Number of input units
:param initU: Input-to-hidden weight matrix initialization
:param initW: Hidden-to-hidden weight matrix initialization
:param bias_init: Bias initialization
"""
if n_inputs is None:
n_inputs = n_units
# H0 takes care of the initial hidden-to-hidden input for t=0
super(ElmanBaseFB, self).__init__(
U=linear.Linear(n_inputs,
n_units,
initialW=initU,
initial_bias=bias_init),
W=linear.Linear(n_units, n_units, initialW=initW, nobias=True),
V=linear.Linear(n_units2, n_units, initialW=initV, nobias=True),
H0=Offset(n_units),
)
def __init__(self, in_size, out_size):
super(LSTM, self).__init__(
upward=linear.Linear(in_size, 4 * out_size),
lateral=linear.Linear(out_size, 4 * out_size, nobias=True),
)
self.state_size = out_size
self.reset_state()
def __init__(self,
in_size,
out_size,
lateral_init=None,
upward_init=None,
bias_init=0,
forget_bias_init=0):
super(LSTMBase, self).__init__(
upward=linear.Linear(in_size, 4 * out_size, initialW=0),
lateral=linear.Linear(out_size,
4 * out_size,
initialW=0,
nobias=True),
)
self.state_size = out_size
for i in six.moves.range(0, 4 * out_size, out_size):
initializers.init_weight(self.lateral.W.data[i:i + out_size, :],
lateral_init)
initializers.init_weight(self.upward.W.data[i:i + out_size, :],
upward_init)
a, i, f, o = lstm._extract_gates(
self.upward.b.data.reshape(1, 4 * out_size, 1))
initializers.init_weight(a, bias_init)
initializers.init_weight(i, bias_init)
initializers.init_weight(f, forget_bias_init)
initializers.init_weight(o, bias_init)
def __init__(self, n_units, n_inputs=None):
if n_inputs is None:
n_inputs = n_units
super(GRUBase2, self).__init__(
W_r_z=linear.Linear(n_inputs + n_units, n_units * 2),
W_h=linear.Linear(n_inputs + n_units, n_units),
)
self.n_units = n_units
def __init__(self, in_size, out_size):
super(ChildSumTreeLSTM, self).__init__(
W_x=linear.Linear(in_size, 4 * out_size),
W_h_aio=linear.Linear(out_size, 3 * out_size, nobias=True),
W_h_f=linear.Linear(out_size, out_size, nobias=True),
)
self.in_size = in_size
self.state_size = out_size
utils.experimental('chainer.links.tree_lstm.py')
def __init__(self, in_size, out_size):
super(ChildSumTreeLSTM, self).__init__()
with self.init_scope():
self.W_x = linear.Linear(in_size, 4 * out_size)
self.W_h_aio = linear.Linear(out_size, 3 * out_size, nobias=True)
self.W_h_f = linear.Linear(out_size, out_size, nobias=True)
self.in_size = in_size
self.state_size = out_size
def __init__(self, in_size, out_size, c_ratio=0.5, h_ratio=0.5):
super(StatefulZoneoutLSTM, self).__init__(
upward=linear.Linear(in_size, 4 * out_size),
lateral=linear.Linear(out_size, 4 * out_size, nobias=True),
)
self.state_size = out_size
self.c_ratio = c_ratio
self.h_ratio = h_ratio
self.reset_state()
def __init__(self, in_size, out_size):
super(StatefulPeepholeLSTM, self).__init__(
upward=linear.Linear(in_size, 4 * out_size),
lateral=linear.Linear(out_size, 4 * out_size, nobias=True),
peep_i=linear.Linear(out_size, out_size, nobias=True),
peep_f=linear.Linear(out_size, out_size, nobias=True),
peep_o=linear.Linear(out_size, out_size, nobias=True),
)
self.state_size = out_size
self.reset_state()
def __init__(self, in_size, out_size, batch_norm_type='upward'):
super(StatefulLinearRNN, self).__init__(upward=L.Linear(in_size, out_size),
lateral=L.Linear(out_size, out_size))
if batch_norm_type not in ('none', 'upward', 'lateral', 'output'):
raise ValueError('Invalid batch_norm_type:{}'.format(batch_norm_type))
self.batch_norm_type = batch_norm_type
if batch_norm_type != 'none':
batch_norm = B.BatchNormalization(out_size)
self.add_link('batch_norm', batch_norm)
self.reset_state()
def __init__(self, in_out_size, nobias=False, activate=relu.relu,
init_Wh=None, init_Wt=None, init_bh=None, init_bt=-1):
super(Highway, self).__init__()
self.activate = activate
with self.init_scope():
self.plain = linear.Linear(
in_out_size, in_out_size, nobias=nobias,
initialW=init_Wh, initial_bias=init_bh)
self.transform = linear.Linear(
in_out_size, in_out_size, nobias=nobias,
initialW=init_Wt, initial_bias=init_bt)
def __init__(self, in_size, out_size, n_ary=2):
assert (n_ary >= 2)
super(NaryTreeLSTM,
self).__init__(W_x=linear.Linear(in_size,
(3 + n_ary) * out_size), )
for i in range(1, n_ary + 1):
self.add_link(
'W_h{}'.format(i),
linear.Linear(out_size, (3 + n_ary) * out_size, nobias=True))
self.in_size = in_size
self.state_size = out_size
self.n_ary = n_ary
utils.experimental('chainer.links.tree_lstm.py')
def __init__(self, vocab_size=10, rnn_unit='LSTM'):
embed = embed_id.EmbedID(vocab_size, 10)
if rnn_unit == 'LSTM':
rnns = link.ChainList(lstm.LSTM(10, 20), lstm.LSTM(20, 20))
elif rnn_unit == 'GRU':
rnns = link.ChainList(gru.StatefulGRU(20, 10),
gru.StatefulGRU(20, 20))
else:
raise ValueError('Invalid RNN unit:{}'.format(rnn_unit))
linears = link.ChainList(linear.Linear(20, 10),
linear.Linear(10, vocab_size))
super(BigLSTM, self).__init__(embed=embed, rnns=rnns, linears=linears)
def __init__(self, in_size, out_size, n_ary=2):
assert (n_ary >= 1)
super(NaryTreeLSTM, self).__init__()
with self.init_scope():
self.W_x = linear.Linear(in_size, (3 + n_ary) * out_size)
for i in range(1, n_ary + 1):
l = linear.Linear(out_size, (3 + n_ary) * out_size,
nobias=True)
setattr(self, 'W_h{}'.format(i), l)
self.in_size = in_size
self.state_size = out_size
self.n_ary = n_ary
def __init__(self,
children,
in_size,
out_size,
lateral_init=None,
upward_init=None,
bias_init=0,
forget_bias_init=0):
super(SLSTM, self).__init__(
upward=linear.Linear(in_size, 4 * out_size, initialW=0))
self.state_size = out_size
self.n_children = children
for i in range(0, 4 * out_size, out_size):
initializers.init_weight(self.upward.W.data[i:i + out_size, :],
upward_init)
a, i, f, o = numpy_extract_gates(
self.upward.b.data.reshape(1, 4 * out_size, 1))
initializers.init_weight(a, bias_init)
initializers.init_weight(i, bias_init)
initializers.init_weight(f, forget_bias_init)
initializers.init_weight(o, bias_init)
#hidden unit gates for each child
for i in range(self.n_children):
self.add_link(
self.U_I_H.format(i),
linear.Linear(out_size,
out_size,
initialW=lateral_init,
nobias=True))
self.add_link(
self.U_O_H.format(i),
linear.Linear(out_size,
out_size,
initialW=lateral_init,
nobias=True))
self.add_link(
self.U_A_H.format(i),
linear.Linear(out_size,
out_size,
initialW=lateral_init,
nobias=True))
for j in range(self.n_children):
self.add_link(
self.U_F_H.format(i, j),
linear.Linear(out_size,
out_size,
initialW=lateral_init,
nobias=True))
def __init__(self, n_units, n_inputs=None):
if n_inputs is None:
n_inputs = n_units
super(GRUBase, self).__init__(
W_r_z_h=linear.Linear(n_inputs, n_units * 3),
U_r_z=linear.Linear(n_units, n_units * 2),
# W_r=linear.Linear(n_inputs, n_units),
# U_r = linear.Linear(n_units, n_units),
# W_z=linear.Linear(n_inputs, n_units),
# U_z=linear.Linear(n_units, n_units),
# W=linear.Linear(n_inputs, n_units),
U=linear.Linear(n_units, n_units),
)
self.n_units = n_units
def __init__(self, use_cudnn=True):
super(VGG_A, self).__init__(
conv1=convolution_2d.Convolution2D(3, 64, 3, pad=1, use_cudnn=use_cudnn),
conv2=convolution_2d.Convolution2D(64, 128, 3, pad=1, use_cudnn=use_cudnn),
conv3_1=convolution_2d.Convolution2D(128, 256, 3, pad=1, use_cudnn=use_cudnn),
conv3_2=convolution_2d.Convolution2D(256, 256, 3, pad=1, use_cudnn=use_cudnn),
conv4_1=convolution_2d.Convolution2D(256, 512, 3, pad=1, use_cudnn=use_cudnn),
conv4_2=convolution_2d.Convolution2D(512, 512, 3, pad=1, use_cudnn=use_cudnn),
conv5_1=convolution_2d.Convolution2D(512, 512, 3, pad=1, use_cudnn=use_cudnn),
conv5_2=convolution_2d.Convolution2D(512, 512, 3, pad=1, use_cudnn=use_cudnn),
fc6=linear.Linear(512 * 7 * 7, 4096),
fc7=linear.Linear(4096, 4096),
fc8=linear.Linear(4096, 1000)
)
self.use_cudnn = use_cudnn
def __init__(self, in_size, out_size,
lateral_init=None, upward_init=None,
bias_init=0, forget_bias_init=0):
super(LSTMBase, self).__init__(
upward=linear.Linear(in_size, 4 * out_size, initialW=0),
lateral=linear.Linear(out_size, 4 * out_size,
initialW=0, nobias=True),
)
self.state_size = out_size
self.lateral_init = lateral_init
self.upward_init = upward_init
self.bias_init = bias_init
self.forget_bias_init = forget_bias_init
if in_size is not None:
self._initialize_params()
def __init__(self, in_size, out_size, pool_size,
initialW=None, initial_bias=0):
super(Maxout, self).__init__()
linear_out_size = out_size * pool_size
if initialW is not None:
initialW = initialW.reshape(linear_out_size, in_size)
if initial_bias is not None:
if numpy.isscalar(initial_bias):
initial_bias = numpy.full(
(linear_out_size,), initial_bias, dtype=numpy.float32)
elif isinstance(initial_bias, (numpy.ndarray, cuda.ndarray)):
initial_bias = initial_bias.reshape(linear_out_size)
else:
raise ValueError(
'initial bias must be float, ndarray, or None')
with self.init_scope():
self.linear = linear.Linear(
in_size, linear_out_size,
nobias=initial_bias is None, initialW=initialW,
initial_bias=initial_bias)
self.out_size = out_size
self.pool_size = pool_size
def __init__(self, in_size, out_size, c_ratio=0.5, h_ratio=0.5, **kwargs):
argument.check_unexpected_kwargs(
kwargs,
train='train argument is not supported anymore. '
'Use chainer.using_config')
argument.assert_kwargs_empty(kwargs)
super(StatefulZoneoutLSTM, self).__init__()
self.state_size = out_size
self.c_ratio = c_ratio
self.h_ratio = h_ratio
self.reset_state()
with self.init_scope():
self.upward = linear.Linear(in_size, 4 * out_size)
self.lateral = linear.Linear(out_size, 4 * out_size, nobias=True)
def __init__(self, use_cudnn=True):
super(C3D, self).__init__(conv1a=Convolution3D(3,
64,
3,
pad=1,
use_cudnn=use_cudnn),
conv2a=Convolution3D(64,
128,
3,
pad=1,
use_cudnn=use_cudnn),
conv3a=Convolution3D(128,
256,
3,
pad=1,
use_cudnn=use_cudnn),
conv3b=Convolution3D(256,
256,
3,
pad=1,
use_cudnn=use_cudnn),
conv4a=Convolution3D(256,
512,
3,
pad=1,
use_cudnn=use_cudnn),
conv4b=Convolution3D(512,
512,
3,
pad=1,
use_cudnn=use_cudnn),
conv5a=Convolution3D(512,
512,
3,
pad=1,
use_cudnn=use_cudnn),
conv5b=Convolution3D(512,
512,
3,
pad=1,
use_cudnn=use_cudnn),
fc6=linear.Linear(4608, 4096),
fc7=linear.Linear(4096, 4096),
fc8=linear.Linear(4096, 487))
self.use_cudnn = use_cudnn
def __init__(self, n_units, n_inputs=None):
if n_inputs is None:
n_inputs = n_units
super(PeepHoleLSTMBase, self).__init__(
W_fh=linear.Linear(n_inputs, n_units),
W_fc=linear.Linear(n_inputs, n_units),
W_oh=linear.Linear(n_inputs, n_units),
W_oc=linear.Linear(n_inputs, n_units),
W_ch=linear.Linear(n_inputs, n_units),
W_fx=linear.Linear(n_inputs, n_units),
W_ox=linear.Linear(n_inputs, n_units),
W_cx=linear.Linear(n_inputs, n_units),
)
def __init__(self, n_units, n_inputs=None, init=None, bias_init=None):
if n_inputs is None:
n_inputs = n_units
super(GRUBase, self).__init__(
W_r_z_h=linear.Linear(n_inputs,
n_units * 3,
initialW=init,
initial_bias=bias_init),
U_r_z=linear.Linear(n_units,
n_units * 2,
initialW=init,
initial_bias=bias_init),
# W_r=linear.Linear(n_inputs, n_units),
# U_r = linear.Linear(n_units, n_units),
# W_z=linear.Linear(n_inputs, n_units),
# U_z=linear.Linear(n_units, n_units),
# W=linear.Linear(n_inputs, n_units),
U=linear.Linear(n_units, n_units),
)
self.n_units = n_units
def __init__(self,
n_units,
n_inputs=None,
init=None,
inner_init=None,
bias_init=0):
if n_inputs is None:
n_inputs = n_units
super(GRUBase, self).__init__(
W_r=linear.Linear(n_inputs,
n_units,
initialW=init,
initial_bias=bias_init),
U_r=linear.Linear(n_units,
n_units,
initialW=inner_init,
initial_bias=bias_init),
W_z=linear.Linear(n_inputs,
n_units,
initialW=init,
initial_bias=bias_init),
U_z=linear.Linear(n_units,
n_units,
initialW=inner_init,
initial_bias=bias_init),
W=linear.Linear(n_inputs,
n_units,
initialW=init,
initial_bias=bias_init),
U=linear.Linear(n_units,
n_units,
initialW=inner_init,
initial_bias=bias_init),
)
def __init__(self,
in_size,
out_size,
init=None,
inner_init=None,
bias_init=None):
super(GRUBase, self).__init__()
with self.init_scope():
self.W_r = linear.Linear(in_size,
out_size,
initialW=init,
initial_bias=bias_init)
self.U_r = linear.Linear(out_size,
out_size,
initialW=inner_init,
initial_bias=bias_init)
self.W_z = linear.Linear(in_size,
out_size,
initialW=init,
initial_bias=bias_init)
self.U_z = linear.Linear(out_size,
out_size,
initialW=inner_init,
initial_bias=bias_init)
self.W = linear.Linear(in_size,
out_size,
initialW=init,
initial_bias=bias_init)
self.U = linear.Linear(out_size,
out_size,
initialW=inner_init,
initial_bias=bias_init)
def __init__(self, in_size, out_size,
init=None,upward_init=None,lateral_init=None, inner_init=None, bias_init=0, forget_bias_init=0):
super(LSTMBase, self).__init__(
W_i=linear.Linear(in_size, out_size,initialW=upward_init, initial_bias=bias_init),
U_i=linear.Linear(out_size, out_size,initialW=lateral_init, nobias=True),
W_f=linear.Linear(in_size, out_size,initialW=upward_init, initial_bias=forget_bias_init),
U_f=linear.Linear(out_size, out_size,initialW=lateral_init, nobias=True),
W_a=linear.Linear(in_size, out_size,initialW=upward_init, initial_bias=bias_init),
U_a=linear.Linear(out_size, out_size,initialW=lateral_init, nobias=True),
W_o=linear.Linear(in_size, out_size,initialW=upward_init, initial_bias=bias_init),
U_o=linear.Linear(out_size, out_size,initialW=lateral_init, nobias=True),
)
self.state_size = out_size
def __init__(self,
in_size,
out_size=None,
lateral_init=None,
upward_init=None,
bias_init=None,
forget_bias_init=None,
h_fusion_init=None,
a_fusion_init=None):
super(ActionConditionedLSTM,
self).__init__(in_size, out_size, lateral_init, upward_init,
bias_init, forget_bias_init)
if out_size is None:
out_size, in_size = in_size, None
self.h_fusion_init = h_fusion_init
self.a_fusion_init = a_fusion_init
with self.init_scope():
self.Wh = linear.Linear(out_size,
out_size,
initialW=0,
nobias=True)
self.Wa = linear.Linear(None, out_size, initialW=0, nobias=True)