def __init__(self, inplanes, gpu): super(hourglass, self).__init__() self.gpu = gpu self.conv1 = Sequential( convbn_3d(inplanes, inplanes * 2, kernel_size=3, stride=2, pad=1), F.relu).to_gpu(self.gpu) self.conv2 = convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1).to_gpu(self.gpu) self.conv3 = Sequential( convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=2, pad=1), F.relu).to_gpu(self.gpu) self.conv4 = Sequential( convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1), F.relu).to_gpu(self.gpu) self.conv5 = Sequential( L.DeconvolutionND(3, inplanes * 2, inplanes * 2, ksize=4, stride=2, pad=1, nobias=True, initialW=ini.Normal(math.sqrt(2. / 32))), L.BatchNormalization(inplanes * 2, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero())).to_gpu( self.gpu) # +conv2 self.conv6 = Sequential( L.DeconvolutionND(3, inplanes * 2, inplanes, ksize=4, stride=2, pad=1, nobias=True), L.BatchNormalization(inplanes, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero())).to_gpu( self.gpu) # +x
def __init__(self, size, decay=0.9, eps=2e-5, dtype=numpy.float32, use_gamma=True, use_beta=True, initial_gamma=None, initial_beta=None): super(BatchNormalization, self).__init__() if use_gamma: self.add_param('gamma', size, dtype=dtype) if initial_gamma is None: initial_gamma = initializers.One() #initializers.init_weight(self.gamma.data, initial_gamma) self.gamma = chainer.Parameter(initial_gamma, (size, )) if use_beta: self.add_param('beta', size, dtype=dtype) if initial_beta is None: initial_beta = initializers.Zero() #initializers.init_weight(self.beta.data, initial_beta) self.beta = chainer.Parameter(initial_beta, (size, )) self.add_persistent('avg_mean', numpy.zeros(size, dtype=dtype)) self.add_persistent('avg_var', numpy.zeros(size, dtype=dtype)) self.add_persistent('N', 0) self.decay = decay self.eps = eps
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, channels): super(AffineChannel2D, self).__init__() with self.init_scope(): self.W = chainer.variable.Parameter(initializers.One(), (channels, )) self.b = chainer.variable.Parameter(initializers.Zero(), (channels, ))
def __init__(self, shape, glow_encoder): super().__init__() self.encoder = glow_encoder with self.init_scope(): self.b = chainer.Parameter(initializers.Zero(), shape) self.m = chainer.Parameter(initializers.One(), (3, 8, 8))
def convbn_3d(in_planes, out_planes, kernel_size, stride, pad): return Sequential( L.ConvolutionND(3, in_planes, out_planes, ksize=kernel_size, stride=stride, pad=pad, nobias=True, initialW=ini.Normal(math.sqrt(2. / (kernel_size * kernel_size * kernel_size * out_planes)))), L.BatchNormalization(out_planes, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero()), )
def __init__(self, in_size, n_units=15): super(ConvolutionalModel, self).__init__() with self.init_scope(): initial_w = initializers.One(dtype=np.float32) self.conv = L.ConvolutionND(ndim=1, in_channels=1, out_channels=n_units, ksize=in_size, stride=1, pad=0, initialW=initial_w) self.fc = L.Linear(n_units, 1)
def __init__(self, n_in, n_out): super(QNetNout, self).__init__( lin=L.Linear(INPUT_LAYER_SIZE, MID1_LAYER_SIZE, initialW=initializers.Normal(scale=0.01)), lm1=L.Linear(MID1_LAYER_SIZE, MID2_LAYER_SIZE, initialW=initializers.Normal(scale=0.01)), lout=L.Linear(MID2_LAYER_SIZE, NUM_SLOTS, initialW=initializers.Normal(scale=0.01)), lq=L.Linear(2, 1, initialW=initializers.One()))
def __init__(self, eps=1e-6, initial_gamma=None, initial_beta=None): super(LayerNormalization, self).__init__() self.add_uninitialized_param('gamma') self.add_uninitialized_param('beta') if initial_gamma is None: initial_gamma = initializers.One() self._gamma_initializer = initial_gamma if initial_beta is None: initial_beta = initializers.Zero() self._beta_initializer = initial_beta self.eps = eps utils.experimental( 'chainer.links.normalization.layer_normalization.py')
def __init__(self, size=None, eps=1e-6, initial_gamma=None, initial_beta=None): super(LayerNormalizationLink, self).__init__() self.add_uninitialized_param('gamma') self.add_uninitialized_param('beta') if initial_gamma is None: initial_gamma = initializers.One() self._gamma_initializer = initial_gamma if initial_beta is None: initial_beta = initializers.Zero() self._beta_initializer = initial_beta self.eps = eps if size is not None: self._initialize_params(size)
def __init__(self, in_channels, out_channels, ksize=None, stride=1, pad=0, dilate=1, groups=1, nobias=True, initialW=None, initial_bias=None, use_scale=True, activ=F.relu): """ CTOR. """ super(FixupConv2D, self).__init__() if initialW is None: # NOTE: update it to zero initializer initialW = I.Zero() with self.init_scope(): self.conv = L.Convolution2D(in_channels, out_channels, ksize=ksize, stride=stride, pad=pad, nobias=nobias, initialW=initialW, initial_bias=initial_bias, dilate=dilate, groups=groups) # bias term for conv input and output self.bias_in = chainer.Parameter(initializer=I.Zero(), shape=1) self.bias_out = chainer.Parameter(initializer=I.Zero(), shape=1) # NOTE: activ controls whether to use scale as well if use_scale or activ is None: self.scale = chainer.Parameter(initializer=I.One(), shape=1) else: self.scale = None # activation self.activ = activ
def _make_layer(self, block, planes, blocks, stride, pad, dilation): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: downsample = Sequential( L.Convolution2D(self.inplanes, planes * block.expansion, ksize=1, stride=stride, nobias=True, initialW=ini.Normal(math.sqrt(2. / (planes * block.expansion)))), L.BatchNormalization(planes * block.expansion, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero()), ) layers = Sequential() layers.append(block(self.inplanes, planes, stride, downsample, pad, dilation)) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append(block(self.inplanes, planes, 1, None, pad, dilation)) return layers
def test_initialize_by_initializer(self): x = chainer.Parameter(initializers.One(), (3, )) np.testing.assert_array_equal(x.data, np.array([1., 1., 1.], dtype='f'))
def __init__(self, z_dim, ch_out): w = init.Normal(1.0) super(AdaIN, self).__init__() with self.init_scope(): self.l1 = L.Linear(z_dim, ch_out, initialW=w, initial_bias=init.One()) self.l2 = L.Linear(z_dim, ch_out, initialW=w)