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)