Exemple #1
0
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, n_class: int, med_dim: int=1024):
     """Initialize."""
     super(LBAL, self).__init__()
     with self.init_scope():
         self.med_fc = links.Linear(
             None, med_dim, initialW=initializers.Normal(scale=0.01))
         self.bn = links.BatchNormalization(med_dim)
         self.tail_fc = links.Linear(
             med_dim, n_class, initialW=initializers.Normal(scale=0.01))
 def __init__(self, n_class: int, med_dim: int=1024, drop_rate: float=0.5) -> None:
     """Initialize."""
     super(LADL, self).__init__()
     with self.init_scope():
         self.med_fc = links.Linear(
             None, med_dim, initialW=initializers.Normal(scale=0.01))
         self.tail_fc = links.Linear(
             med_dim, n_class, initialW=initializers.Normal(scale=0.01))
     self.drop_rate = drop_rate
Exemple #4
0
 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()))
Exemple #5
0
 def __init__(self):
     super(QNet, 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,
                       OUTPUT_LAYER_SIZE,
                       initialW=initializers.Normal(scale=0.01)),
     )
Exemple #6
0
 def __init__(self, bert):
     super(BertPretrainer, self).__init__()
     with self.init_scope():
         self.bert = bert
         self.masked_lm_dense = L.Linear(None, self.bert.config.hidden_size,
                                         initialW=initializers.Normal(scale=self.bert.config.initializer_range))
         self.activate = get_activation('gelu')
         self.mask_bias = variable.Parameter(initializers.Zero(), shape=self.bert.config.vocab_size)
         self.next_sentence_weights = variable.Parameter(
             initializers.Normal(scale=self.bert.config.initializer_range),
             shape=(2, self.bert.config.hidden_size))
         self.next_sentence_bias = variable.Parameter(initializers.Zero(), shape=2)
         self.layer_norm = LayerNormalization3D(None)
 def __init__(self, insize, outsize):
     super(NN,
           self).__init__(
               # bn1=L.BatchNormalization(insize),
               layer1=L.Linear(insize,
                               110,
                               initialW=initializers.Normal(scale=0.05)),
               layer2=L.Linear(110,
                               100,
                               initialW=initializers.Normal(scale=0.05)),
               layer3=L.Linear(100,
                               outsize,
                               initialW=np.zeros((outsize, 100),
                                                 dtype=np.float32)))
Exemple #8
0
    def __init__(self, vocab_size, hidden_size, dropout_ratio, ignore_label):
        super(NStepLSTMLanguageModel, self).__init__()
        with self.init_scope():
            self.embed_word = L.EmbedID(vocab_size,
                                        hidden_size,
                                        initialW=initializers.Normal(1.0),
                                        ignore_label=ignore_label)
            self.embed_img = L.Linear(hidden_size,
                                      initialW=initializers.Normal(0.01))
            self.lstm = L.NStepLSTM(1, hidden_size, hidden_size, dropout_ratio)
            self.decode_caption = L.Linear(hidden_size,
                                           vocab_size,
                                           initialW=initializers.Normal(0.01))

        self.dropout_ratio = dropout_ratio
Exemple #9
0
 def __init__(self, in_ch, out_ch):
     w = initializers.Normal(0.02)
     super(ResBlock, self).__init__()
     with self.init_scope():
         self.cbg0 = C1BG(in_ch, out_ch)
         self.c0 = L.Convolution1D(in_ch, in_ch, 3, 1, 1, initialW=w)
         self.bn0 = L.BatchNormalization(in_ch)
Exemple #10
0
    def __init__(self,
                 dim_in,
                 dim_out,
                 kernel_size=3,
                 activ=F.relu,
                 wscale=0.02):
        super(pad_conv_norm, self).__init__()
        self.activ = activ
        w = I.Normal(wscale)
        with self.init_scope():
            if kernel_size == 1:
                self.conv = L.Convolution2D(dim_in,
                                            dim_out,
                                            ksize=kernel_size,
                                            stride=1,
                                            pad=0,
                                            nobias=True,
                                            initialW=w)
            else:
                self.conv = L.Convolution2D(dim_in,
                                            dim_out,
                                            ksize=kernel_size,
                                            stride=1,
                                            pad=1,
                                            nobias=True,
                                            initialW=w)

            self.bn = L.BatchNormalization(dim_out,
                                           initial_gamma=I.Constant(
                                               np.random.normal(loc=1.,
                                                                scale=wscale,
                                                                size=dim_out)))
Exemple #11
0
    def __init__(self, scale, cur_dim, num_resblock, wscale=0.02):
        super(Scale_Block, self).__init__()
        self.scale = scale
        self.num_resblock = num_resblock

        w = I.Normal(wscale)
        with self.init_scope():
            if self.scale != 4:
                self.upsample = Up_Sapmling(cur_dim, cur_dim)

            if self.scale in reduce_dim_at:
                self.red_conv = pad_conv_norm(cur_dim, cur_dim // 2)
                cur_dim = cur_dim // 2

            for i in range(self.num_resblock):
                setattr(self, f"resblock_{i}", ResnetBlock(cur_dim))

            if self.scale in img_scales:
                self.tensor2img = L.Convolution2D(cur_dim,
                                                  3,
                                                  ksize=3,
                                                  stride=1,
                                                  pad=1,
                                                  initialW=w,
                                                  initial_bias=w)
 def __init__(self, n_units, n_out):
     super().__init__()
     with self.init_scope():
         w = I.Normal(scale=1.0)
         self.l1 = L.Linear(None, n_units, initialW=w)
         self.l2 = L.Linear(None, n_units, initialW=w)
         self.l3 = L.Linear(None, n_out, initialW=w)
Exemple #13
0
 def __init__(self,
              sent_dim,
              noise_dim,
              row,
              col,
              channel,
              wscale=0.02,
              activ=None):
     super(Sent2FeatMap, self).__init__()
     self.row = row
     self.col = col
     self.channel = channel
     self.activ = activ
     w = I.Normal(wscale)
     with self.init_scope():
         out_dim = row * col * channel
         self.l1_dense = L.Linear(sent_dim + noise_dim,
                                  out_dim,
                                  nobias=True,
                                  initialW=w)
         self.l1_bn = L.BatchNormalization(out_dim,
                                           initial_gamma=I.Constant(
                                               np.random.normal(
                                                   loc=1.,
                                                   scale=wscale,
                                                   size=out_dim)))
Exemple #14
0
 def __init__(self, in_ch, out_ch):
     w = initializers.Normal(0.02)
     super(RRDB,self).__init__()
     with self.init_scope():
         self.dense0 = Dense_Block(in_ch, out_ch)
         self.dense1 = Dense_Block(out_ch, out_ch)
         self.dense2 = Dense_Block(out_ch, out_ch)
Exemple #15
0
    def __init__(self, base=64):
        w = initializers.Normal(0.02)
        super(Discriminator, self).__init__()

        with self.init_scope():
            self.c0 = CBR(3, base, 4, 2, 1, down=True, activation=F.leaky_relu)
            self.c1 = CBR(base,
                          base * 2,
                          4,
                          2,
                          1,
                          down=True,
                          activation=F.leaky_relu)
            self.c2 = CBR(base * 2,
                          base * 4,
                          4,
                          2,
                          1,
                          down=True,
                          activation=F.leaky_relu)
            self.c3 = CBR(base * 4,
                          base * 8,
                          4,
                          2,
                          1,
                          down=True,
                          activation=F.leaky_relu)
            self.c4 = L.Convolution2D(base * 8, 1, 1, 1, 0, initialW=w)
class BboxHead(chainer.Chain):
    _prior = 0.01
    _conf_last_init = {
        'initialW': initializers.Normal(0.01),
        'initial_bias': initializers.Constant(-np.log((1 - _prior) / _prior))
    }

    def __init__(self, n_fg_class, ratios, scales):
        super(BboxHead, self).__init__()
        with self.init_scope():
            self.loc = create_fcn(
                (256, 256, 256, 256, 4 * len(ratios) * len(scales)))
            self.conf = create_fcn(
                (256, 256, 256, 256, (n_fg_class) * len(ratios) * len(scales)),
                [None, None, None, None, self._conf_last_init])
        self._n_fg_class = n_fg_class

    def forward(self, hs):
        b = hs[0].shape[0]
        locs = [
            F.reshape(F.transpose(self.loc(h), (0, 2, 3, 1)), (b, -1, 4))
            for h in hs
        ]
        confs = [
            F.reshape(F.transpose(self.conf(h), (0, 2, 3, 1)),
                      (b, -1, self._n_fg_class)) for h in hs
        ]
        locs = F.concat(locs, axis=1)
        confs = F.concat(confs, axis=1)

        return locs, confs
 def __init__(self, n_class: int, drop_rate: float=0.5):
     """Initialize."""
     super(DropoutLinear, self).__init__()
     with self.init_scope():
         self.tail_fc = links.Linear(
             None, n_class, initialW=initializers.Normal(scale=0.01))
     self.drop_rate = drop_rate
Exemple #18
0
    def __init__(self,  in_channels, out_channels, ksize, pooling, zoneout, bias, wgain=1.):
        """
          Initialize ConvLSTM cell.
          Parameters
          ----------
          input_size: (int, int)
              Height and width of input tensor as (height, width).
          input_dim: int
              Number of channels of input tensor.
          out_channels: int
              Number of channels of hidden state.
          ksize: (int, int, int)
              Size of the convolutional kernel.
          bias: bool
              Whether or not to add the bias.
        """
        super(ConvQRNN, self).__init__()
        self.num_split = len(pooling) + 1
        self._pooling = pooling  # f or fo or ifo

        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = ksize  # typical is (3, 1, 1)
        self.bias = bias
        self._zoneout = zoneout
        self._using_zoneout = True if self._zoneout > 0 else False
        self.padding = (ksize[0]-1, ksize[1]//2, ksize[2]//2)
        wstd = math.sqrt(wgain / in_channels / ksize[0])
        with self.init_scope():
            self.conv = L.ConvolutionND(ndim=3, in_channels=self.in_channels,
                                        out_channels=self.num_split * self.out_channels,
                                        ksize=self.kernel_size,  stride=1, pad=self.padding,
                                        nobias=not self.bias, initialW=initializers.Normal(wstd))
Exemple #19
0
    def __init__(self, n_class, scales):
        super(BboxHead, self).__init__()

        fc_init = {
            'initialW': Caffe2FCUniform(),
            'initial_bias': Caffe2FCUniform(),
        }
        with self.init_scope():
            self.fc1 = L.Linear(1024, **fc_init)
            self.fc2 = L.Linear(1024, **fc_init)
            self.loc = L.Linear(n_class * 4,
                                initialW=initializers.Normal(0.001))
            self.conf = L.Linear(n_class, initialW=initializers.Normal(0.01))

        self._n_class = n_class
        self._scales = scales
Exemple #20
0
    def __init__(self, n_units, n_vocab, encoder, max_memory, hops):
        super(MemNN, self).__init__()

        with self.init_scope():
            self.embeds = chainer.ChainList()
            self.temporals = chainer.ChainList()

        normal = initializers.Normal()
        # Shares both embeded matrixes in adjacent layres
        for _ in six.moves.range(hops + 1):
            self.embeds.append(L.EmbedID(n_vocab, n_units, initialW=normal))
            self.temporals.append(
                L.EmbedID(max_memory, n_units, initialW=normal))

        self.memories = [
            Memory(self.embeds[i], self.embeds[i + 1], self.temporals[i],
                   self.temporals[i + 1], encoder)
            for i in six.moves.range(hops)
        ]
        # The question embedding is same as the input embedding of the
        # first layer
        self.B = self.embeds[0]
        # The answer prediction matrix W is same as the final output layer
        self.W = lambda u: F.linear(u, self.embeds[-1].W)

        self.encoder = encoder

        self.n_units = n_units
        self.max_memory = max_memory
        self.hops = hops
Exemple #21
0
 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)))
Exemple #22
0
 def __init__(self,
              ch_in,
              ch_out,
              stride=1,
              activation=F.relu,
              skip_ratio=0):
     initializer = initializers.Normal(scale=math.sqrt(2.0 /
                                                       (ch_out * 3 * 3)))
     super(PyramidBlock, self).__init__(
         conv1=L.Convolution2D(ch_in,
                               ch_out,
                               3,
                               stride,
                               1,
                               initialW=initializer),
         conv2=L.Convolution2D(ch_out,
                               ch_out,
                               3,
                               1,
                               1,
                               initialW=initializer),
         bn1=L.BatchNormalization(ch_in),
         bn2=L.BatchNormalization(ch_out),
         bn3=L.BatchNormalization(ch_out),
     )
     self.activation = activation
     self.skip_ratio = skip_ratio
Exemple #23
0
 def __init__(self):
     super().__init__()
     init_w = initializers.Normal(0.1)
     init_b = initializers.Constant(0.1)
     with self.init_scope():
         self.fc1 = L.Linear(7*7*48, 100, initialW=init_w, initial_bias=init_b)
         self.fc2 = L.Linear(100, 1, initialW=init_w, initial_bias=init_b)
Exemple #24
0
    def __init__(self,
                 n_layer,
                 n_class=None,
                 pretrained_model=None,
                 mean=None,
                 initialW=None,
                 fc_kwargs={},
                 arch='fb'):
        if arch == 'fb':
            stride_first = False
            conv1_no_bias = True
        elif arch == 'he':
            stride_first = True
            # Kaiming He uses bias only for ResNet50
            conv1_no_bias = n_layer != 50
        else:
            raise ValueError('arch is expected to be one of [\'he\', \'fb\']')
        blocks = self._blocks[n_layer]

        param, path = utils.prepare_pretrained_model(
            {
                'n_class': n_class,
                'mean': mean
            }, pretrained_model, self._models[arch][n_layer], {
                'n_class': 1000,
                'mean': _imagenet_mean
            })
        self.mean = param['mean']

        if initialW is None:
            initialW = initializers.HeNormal(scale=1., fan_option='fan_out')
        if 'initialW' not in fc_kwargs:
            fc_kwargs['initialW'] = initializers.Normal(scale=0.01)
        if pretrained_model:
            # As a sampling process is time-consuming,
            # we employ a zero initializer for faster computation.
            initialW = initializers.constant.Zero()
            fc_kwargs['initialW'] = initializers.constant.Zero()
        kwargs = {'initialW': initialW, 'stride_first': stride_first}

        super(ResNet, self).__init__()
        with self.init_scope():
            self.conv1 = Conv2DBNActiv(None,
                                       64,
                                       7,
                                       2,
                                       3,
                                       nobias=conv1_no_bias,
                                       initialW=initialW)
            self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2)
            self.res2 = ResBlock(blocks[0], None, 64, 256, 1, **kwargs)
            self.res3 = ResBlock(blocks[1], None, 128, 512, 2, **kwargs)
            self.res4 = ResBlock(blocks[2], None, 256, 1024, 2, **kwargs)
            self.res5 = ResBlock(blocks[3], None, 512, 2048, 2, **kwargs)
            self.pool5 = lambda x: F.average(x, axis=(2, 3))
            self.fc6 = L.Linear(None, param['n_class'], **fc_kwargs)
            self.prob = F.softmax

        if path:
            chainer.serializers.load_npz(path, self)
Exemple #25
0
    def __init__(self, base=128):
        w = initializers.Normal(0.02)
        super(GeneratorWithCIN, self).__init__()
        with self.init_scope():
            self.c0 = L.Convolution2D(1, base, (15, 5), 1, (7, 2), initialW=w)
            self.cbg0 = C2BG(int(base / 2), base * 2, down=True)
            self.cbg1 = C2BG(base, base * 4, down=True)

            self.c1 = L.Convolution1D(2304, base * 2, 1, 1, 0, initialW=w)
            self.bn1 = L.BatchNormalization(base * 2)

            self.res0 = ResBlock(base * 2, base * 4)
            self.res1 = ResBlock(base * 2, base * 4)
            self.res2 = ResBlock(base * 2, base * 4)
            self.res3 = ResBlock(base * 2, base * 4)
            self.res4 = ResBlock(base * 2, base * 4)
            self.res5 = ResBlock(base * 2, base * 4)
            self.res6 = ResBlock(base * 2, base * 4)
            self.res7 = ResBlock(base * 2, base * 4)
            self.res8 = ResBlock(base * 2, base * 4)

            self.c2 = L.Convolution1D(base * 2, 2304, 1, 1, 0, initialW=w)
            self.bn2 = L.BatchNormalization(2304)

            self.cbg2 = C2BG(base * 2, base * 8, up=True)
            self.cbg3 = C2BG(base * 4, 72, up=True)

            self.c3 = L.Convolution2D(36, 1, 3, 1, 1, initialW=w)
Exemple #26
0
 def __init__(self, in_size, out_size):
     super(Linear, self).__init__()
     with self.init_scope():
         self.W = chainer.Parameter(
             initializers.Normal(1. / math.sqrt(in_size)),
             (out_size, in_size))
         self.b = chainer.Parameter(0, (out_size, ))
Exemple #27
0
 def __init__(self, n_in, n_out):
     super(NN, self).__init__(
         L1=L.Linear(n_in, 100),
         L2=L.Linear(100, 100),
         L3=L.Linear(100, 100),
         Q_value=L.Linear(100, n_out, initialW=initializers.Normal(scale=0.05))
     )
Exemple #28
0
    def __init__(self,
                 in_ch,
                 out_ch,
                 kernel,
                 stride,
                 padding,
                 activation=F.relu,
                 down=False,
                 up=False):

        w = initializers.Normal(0.02)
        super(CBR, self).__init__()

        self.activ = activation
        self.down = down
        self.up = up

        with self.init_scope():
            self.c = L.Convolution2D(in_ch,
                                     out_ch,
                                     kernel,
                                     stride,
                                     padding,
                                     initialW=w)
            self.bn = L.BatchNormalization(out_ch)
Exemple #29
0
def Convolution(in_channels, out_channels, ksize, stride, pad):
    return L.Convolution2D(in_channels,
                           out_channels,
                           ksize,
                           stride,
                           pad,
                           initialW=initializers.Normal(0.02))
Exemple #30
0
 def __init__(self, n_units, n_out):
     w = I.Normal(scale=0.05)  # モデルパラメータの初期化
     super(MLP, self).__init__(
         conv1=L.Convolution2D(1, 16, 5, 1, 0),  # 1層目の畳み込み層(フィルタ数は16)
         conv2=L.Convolution2D(16, 32, 5, 1, 0),  # 2層目の畳み込み層(フィルタ数は32)
         l3=L.Linear(None, n_out, initialW=w),  #クラス分類用
     )