def create_initializer(init_type, scale=None, fillvalue=None):
if init_type == 'identity':
return initializers.Identity() if scale is None else initializers.Identity(scale=scale)
if init_type == 'constant':
return initializers.Constant(fillvalue)
if init_type == 'zero':
return initializers.Zero()
if init_type == 'one':
return initializers.One()
if init_type == 'normal':
return initializers.Normal() if scale is None else initializers.Normal(scale)
if init_type == 'glorotNormal':
return initializers.GlorotNormal() if scale is None else initializers.GlorotNormal(scale)
if init_type == 'heNormal':
return initializers.HeNormal() if scale is None else initializers.HeNormal(scale)
if init_type == 'orthogonal':
return initializers.Orthogonal(
scale) if scale is None else initializers.Orthogonal(scale)
if init_type == 'uniform':
return initializers.Uniform(
scale) if scale is None else initializers.Uniform(scale)
if init_type == 'leCunUniform':
return initializers.LeCunUniform(
scale) if scale is None else initializers.LeCunUniform(scale)
if init_type == 'glorotUniform':
return initializers.GlorotUniform(
scale) if scale is None else initializers.GlorotUniform(scale)
if init_type == 'heUniform':
return initializers.HeUniform(
scale) if scale is None else initializers.HeUniform(scale)
raise ValueError("Unknown initializer type: {0}".format(init_type))
def __init__(self,
input_space,
output_space,
zero_bias=False,
in_channels=None):
super(ChainerDQN, self).__init__()
assert isinstance(input_space, gym.Space)
assert input_space.shape is not None
if isinstance(output_space, gym.spaces.Discrete):
out_units = output_space.n
elif isinstance(output_space, gym.spaces.Box):
assert len(output_space.shape) == 1
out_units = output_space.shape[0]
else:
raise NotImplementedError
self._input_space = input_space
self._output_space = output_space
initial_bias = None if zero_bias else I.Uniform(1e-4)
in_channels = get_in_channels(input_space, in_channels)
with self.init_scope():
self.conv0 = L.Convolution2D(in_channels,
32,
ksize=8,
stride=4,
initialW=I.HeUniform(),
initial_bias=initial_bias)
self.conv1 = L.Convolution2D(None,
64,
ksize=4,
stride=2,
initialW=I.HeUniform(),
initial_bias=initial_bias)
self.conv2 = L.Convolution2D(None,
64,
ksize=3,
stride=1,
initialW=I.HeUniform(),
initial_bias=initial_bias)
self.fc0 = L.Linear(None,
512,
initialW=I.HeNormal(scale=0.01),
initial_bias=initial_bias)
self.fc1 = L.Linear(None,
out_units,
initialW=I.HeNormal(scale=0.01),
initial_bias=initial_bias)
self(np.zeros((1, ) + input_space.shape, input_space.dtype))
def __init__(self, emb_dim, n_out, depth=[2, 2, 2, 2]):
super(VDCNN, self).__init__()
with self.init_scope():
self.embed = L.EmbedID(emb_dim,
16,
initializers.Normal(),
ignore_label=-1)
self.conv1 = L.ConvolutionND(1,
16,
64,
3,
1,
1,
initialW=initializers.HeUniform(),
initial_bias=initializers.Uniform(
np.sqrt(6 / (16 * 3))))
self.cb2 = BuildBlock(depth[0], 64, 128)
self.cb3 = BuildBlock(depth[1], 128, 256)
self.cb4 = BuildBlock(depth[2], 256, 512)
self.cb5 = BuildBlock(depth[3], 512, 512)
self.fc6 = L.Linear(
4096,
2048,
initialW=initializers.Uniform(1 / np.sqrt(4096)),
initial_bias=initializers.Uniform(1 / np.sqrt(4096)))
self.fc7 = L.Linear(
2048,
2048,
initialW=initializers.Uniform(1 / np.sqrt(2048)),
initial_bias=initializers.Uniform(1 / np.sqrt(2048)))
self.fc8 = L.Linear(
2048,
n_out,
initialW=initializers.Uniform(1 / np.sqrt(2048)),
initial_bias=initializers.Uniform(1 / np.sqrt(2048)))
def __init__(self, ch_size, out_size):
initialW = initializers.HeUniform()
super(ConvBlock, self).__init__()
with self.init_scope():
self.conv1 = L.ConvolutionND(1,
ch_size,
ch_size,
3,
1,
1,
initialW=initialW,
initial_bias=initializers.Uniform(
np.sqrt(6 / (ch_size * 3))))
self.bn1 = L.BatchNormalization(ch_size,
initial_gamma=Uniform(1.0))
self.conv2 = L.ConvolutionND(1,
ch_size,
out_size,
3,
1,
1,
initialW=initialW,
initial_bias=initializers.Uniform(
np.sqrt(6 / (ch_size * 3))))
self.bn2 = L.BatchNormalization(out_size,
initial_gamma=Uniform(1.0))
def __init__(self, lng_net, att_net, h_size=200, margin=1.):
super(Net, self).__init__(lng_net, h_size, margin)
initialW = initializers.HeUniform()
with self.init_scope():
self.att_net = att_net
self.l_vis_act = L.Linear(None, h_size, initialW=initialW)
self.l_vis_rsn = L.Linear(None, h_size, initialW=initialW)
self.l_lng_act = L.Linear(None, h_size, initialW=initialW)
self.l_lng_rsn = L.Linear(None, h_size, initialW=initialW)
def __init__(self, n_vocab, wvec):
super(TextCNN, self).__init__()
initialW = initializers.HeUniform()
with self.init_scope():
self.emb = L.EmbedID(n_vocab, 300, initialW=wvec, ignore_label=-1)
self.conv_2 = L.Convolution2D(1,
100,
ksize=(2, 300),
stride=1,
pad=(1, 0),
initialW=initialW)
self.l = L.Linear(300, initialW=initializers.GlorotUniform())
def __init__(self, adj, labels, feat_size, dropout=0.5):
super(TextGCN, self).__init__()
n_class = np.max(labels) + 1
initializer = initializers.HeUniform()
with self.init_scope():
self.gconv1 = GraphConvolution(adj.shape[1], feat_size)
self.gconv2 = GraphConvolution(feat_size, n_class)
self.input_repr = chainer.Parameter(initializer,
(adj.shape[0], feat_size))
# This Variable will not be updated because require_grad=False
self.input = to_chainer_sparse_variable(sp.identity(adj.shape[1]))
self.adj = adj
self.labels = labels
self.dropout = dropout
def __init__(self,
input_space,
output_space,
hidden_layer_sizes=(512, 512, 512),
activation=F.relu,
zero_bias=False):
"""
Args:
input_space -- the space that inputs will be drawn from
output_space -- the space that outputs will be drawn from.
Keyword Args:
hidden_layer_sizes -- the number of units in each hidden layer in order
[(512, 512, 512)]
activation -- the activation function used on all layers [relu]
zero_bias -- whether the bias should be initialized to zero [False]
"""
assert isinstance(input_space, gym.Space)
assert input_space.shape is not None
if isinstance(output_space, gym.spaces.Discrete):
out_units = output_space.n
elif isinstance(output_space, gym.spaces.Box):
assert len(output_space.shape) == 1
out_units = output_space.shape[0]
else:
raise NotImplementedError
self._input_space = input_space
self._output_space = output_space
self._num_hidden = len(hidden_layer_sizes)
assert self._num_hidden > 0
initial_weights = I.HeUniform()
initial_bias = None if zero_bias else I.Uniform(1e-4)
links = []
for units in hidden_layer_sizes:
links.append(
L.Linear(None, units, False, initial_weights, initial_bias))
links.append(
L.Linear(None, out_units, False, initial_weights, initial_bias))
self._activation = activation
super(ChainerMLP, self).__init__(*links)
self(np.zeros((1, ) + input_space.shape, input_space.dtype))
def __init__(self, lng_net, h_size=200, margin=.4):
super(NonVisualNet, self).__init__()
initialW = initializers.HeUniform()
with self.init_scope():
self.lng_net = lng_net
self.ocr_l = L.Linear(None,
h_size,
initialW=initializers.HeNormal())
self.act_l = L.Linear(None,
h_size,
initialW=initializers.HeNormal())
self.rsn_l = L.Linear(None,
h_size,
initialW=initializers.HeNormal())
self.margin = margin
def __init__(self,
in_size,
out_size=None,
nobias=False,
initialW=None,
initial_bias=None):
super(GraphConvolution, self).__init__()
if out_size is None:
in_size, out_size = None, in_size
self.out_size = out_size
with self.init_scope():
W_initializer = initializers.HeUniform()
self.W = Parameter(W_initializer, (in_size, out_size))
if nobias:
self.b = None
else:
if initial_bias is None:
initial_bias = 0
bias_initializer = initializers._get_initializer(initial_bias)
self.b = Parameter(bias_initializer, out_size)
import unittest
from chainer import cuda
from chainer import initializers
from chainer import testing
from chainer.testing import attr
import numpy
@testing.parameterize({'initializer': initializers.Uniform(scale=0.1)},
{'initializer': initializers.LeCunUniform(scale=0.1)},
{'initializer': initializers.GlorotUniform(scale=0.1)},
{'initializer': initializers.HeUniform(scale=0.1)})
class TestUniform(unittest.TestCase):
shape = (2, 3, 4)
def check_initializer(self, w):
self.initializer(w)
self.assertTupleEqual(w.shape, self.shape)
self.assertEqual(w.dtype, numpy.float32)
xp = cuda.get_array_module(w)
self.assertIsInstance(w, xp.ndarray)
def test_initializer_cpu(self):
w = numpy.empty(self.shape, dtype=numpy.float32)
self.check_initializer(w)
@attr.gpu
def test_initializer_gpu(self):
w = cuda.cupy.empty(self.shape, dtype=numpy.float32)