def __init__(self, in_size, out_size, decay=0.9, eps=2e-5, dtype=numpy.float32):
        super(SharedEmbeddingBatchNormalization, self).__init__(
            size=out_size, decay=decay, eps=eps, dtype=dtype)

        with self.init_scope():
            self.linear_gamma = SNLinear(in_size, out_size, nobias=True)
            self.linear_beta = SNLinear(in_size, out_size, nobias=True)
예제 #2
0
 def __init__(self, ch=64, n_classes=0, activation=F.relu):
     super(SNResNetProjectionDiscriminator, self).__init__()
     self.activation = activation
     initializer = chainer.initializers.GlorotUniform()
     with self.init_scope():
         self.block1 = OptimizedBlock(3, ch)
         self.block2 = Block(ch,
                             ch * 2,
                             activation=activation,
                             downsample=True)
         self.block3 = Block(ch * 2,
                             ch * 4,
                             activation=activation,
                             downsample=True)
         self.block4 = Block(ch * 4,
                             ch * 8,
                             activation=activation,
                             downsample=True)
         self.block5 = Block(ch * 8,
                             ch * 16,
                             activation=activation,
                             downsample=True)
         self.block6 = Block(ch * 16,
                             ch * 16,
                             activation=activation,
                             downsample=False)
         self.l7 = SNLinear(ch * 16, 1, initialW=initializer)
         if n_classes > 0:
             self.l_y = SNEmbedID(n_classes, ch * 16, initialW=initializer)
예제 #3
0
    def __init__(self, ch=128, n_classes=0, activation=F.relu):
        super(SNResNetProjectionDiscriminator, self).__init__()
        self.activation = activation
        with self.init_scope():
            self.block1 = OptimizedBlock(3, ch)
            self.block2 = Block(ch, ch, activation=activation, downsample=True)
            self.block3 = Block(ch,
                                ch,
                                activation=activation,
                                downsample=False)
            self.block4 = Block(ch,
                                ch,
                                activation=activation,
                                downsample=False)
            self.l5 = SNLinear(ch,
                               1,
                               initialW=chainer.initializers.GlorotUniform(),
                               nobias=True)
            self.l5.u = np.ones((1, 1)).astype(np.float32)

            if n_classes > 0:
                self.l_y = SNEmbedID(
                    n_classes,
                    ch,
                    initialW=chainer.initializers.GlorotUniform())
        seed_weights(self)
예제 #4
0
    def __init__(self,
                 in_size,
                 out_size,
                 decay=0.9,
                 eps=2e-5,
                 dtype=numpy.float32,
                 use_moving_average=True):
        super(HyperBatchNormalization,
              self).__init__(size=out_size,
                             decay=decay,
                             eps=eps,
                             dtype=dtype,
                             use_moving_average=use_moving_average)

        with self.init_scope():
            self.linear_gamma = SNLinear(in_size, out_size, nobias=True)
            self.linear_beta = SNLinear(in_size, out_size, nobias=True)
예제 #5
0
 def __init__(self, ch=128, n_classes=0, activation=F.relu, sn=False, ch_input=3):
     super(SNResNetProjectionDiscriminator, self).__init__()
     self.activation = activation
     self.n_classes = n_classes
     with self.init_scope():
         self.block1 = OptimizedBlock(ch_input, ch, sn=sn)
         self.block2 = Block(ch, ch, activation=activation, downsample=True, sn=sn)
         self.block3 = Block(ch, ch, activation=activation, downsample=False, sn=sn)
         self.block4 = Block(ch, ch, activation=activation, downsample=False, sn=sn)
         self.l5 = SNLinear(ch, 1, initialW=chainer.initializers.GlorotUniform(), nobias=True)
         if n_classes > 0:
             self.l_y = SNEmbedID(n_classes, ch, initialW=chainer.initializers.GlorotUniform())
예제 #6
0
 def __init__(self, ch=96):
     self.ch = ch
     super(Generator, self).__init__()
     with self.init_scope():
         self.linear = L.Linear(1000, 128, nobias=True)
         self.G_linear = SNLinear(20, 4 * 4 * 16 * ch)
         self.GBlock = ResBlock(148, 16 * ch, 16 * ch)
         self.GBlock_1 = ResBlock(148, 16 * ch, 8 * ch)
         self.GBlock_2 = ResBlock(148, 8 * ch, 8 * ch)
         self.GBlock_3 = ResBlock(148, 8 * ch, 4 * ch)
         self.GBlock_4 = ResBlock(148, 4 * ch, 2 * ch)
         self.attention = NonLocalBlock(2 * ch)
         self.GBlock_5 = ResBlock(148, 2 * ch, ch)
         self.ScaledCrossReplicaBN = L.BatchNormalization(ch)
         self.conv_2d = SNConvolution2D(ch, 3, 3, 1, 1)
 def __init__(self, ch=128, n_classes=0, activation=F.relu):
     super(SRDiscriminator, self).__init__()
     self.activation = activation
     with self.init_scope():
         self.block1 = OptimizedBlock(3, ch)
         self.block2 = Block(ch, ch, activation=activation, downsample=True)
         self.block3 = Block(ch,
                             ch,
                             activation=activation,
                             downsample=False)
         self.block4 = Block(ch,
                             ch,
                             activation=activation,
                             downsample=False)
         self.l5 = SNLinear(ch,
                            1,
                            initialW=chainer.initializers.GlorotUniform(),
                            nobias=True)
         if n_classes > 0:
             self.l_y = SNEmbedID(
                 n_classes,
                 ch,
                 initialW=chainer.initializers.GlorotUniform())