python类BatchNormalization()的实例源码

wgan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 26 收藏 0 点赞 0 评论 0
def __init__(self, bottom_width=8, ch=512, wscale=0.005):
        w = chainer.initializers.Normal(wscale)
        super(DiscriminatorPFN, self).__init__(
            c0_0=L.Convolution2D(3, ch // 8, 3, 1, 1, initialW=w),
            c0_1=L.Convolution2D(ch // 8, ch // 4, 4, 2, 1, initialW=w),
            c1_0=L.Convolution2D(ch // 4, ch // 4, 3, 1, 1, initialW=w),
            c1_1=L.Convolution2D(ch // 4, ch // 2, 4, 2, 1, initialW=w),
            c2_0=L.Convolution2D(ch // 2, ch // 2, 3, 1, 1, initialW=w),
            c2_1=L.Convolution2D(ch // 2, ch // 1, 4, 2, 1, initialW=w),
            c3_0=L.Convolution2D(ch // 1, ch // 1, 3, 1, 1, initialW=w),
            l4=L.Linear(bottom_width * bottom_width * ch, 1, initialW=w),
            bn0_1=L.BatchNormalization(ch // 4, use_gamma=False),
            bn1_0=L.BatchNormalization(ch // 4, use_gamma=False),
            bn1_1=L.BatchNormalization(ch // 2, use_gamma=False),
            bn2_0=L.BatchNormalization(ch // 2, use_gamma=False),
            bn2_1=L.BatchNormalization(ch // 1, use_gamma=False),
            bn3_0=L.BatchNormalization(ch // 1, use_gamma=False),
        )
vaegan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 28 收藏 0 点赞 0 评论 0
def __init__(self, density=1, size=64, latent_size=128, channel=3):
        assert (size % 16 == 0)
        initial_size = size / 16
        super(Generator, self).__init__(
            g1=L.Linear(latent_size, initial_size * initial_size * 256 * density, wscale=0.02 * math.sqrt(latent_size)),
            norm1=L.BatchNormalization(initial_size * initial_size * 256 * density),
            g2=L.Deconvolution2D(256 * density, 128 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 256 * density)),
            norm2=L.BatchNormalization(128 * density),
            g3=L.Deconvolution2D(128 * density, 64 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 128 * density)),
            norm3=L.BatchNormalization(64 * density),
            g4=L.Deconvolution2D(64 * density, 32 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 64 * density)),
            norm4=L.BatchNormalization(32 * density),
            g5=L.Deconvolution2D(32 * density, channel, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 32 * density)),
        )
        self.density = density
        self.latent_size = latent_size
        self.initial_size = initial_size
vaegan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 36 收藏 0 点赞 0 评论 0
def __init__(self, density=1, size=64, channel=3):
        assert (size % 16 == 0)
        initial_size = size / 16
        super(Discriminator, self).__init__(
            dis1=L.Convolution2D(channel, 32 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * channel * density)),
            dis2=L.Convolution2D(32 * density, 64 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 32 * density)),
            norm2=L.BatchNormalization(64 * density),
            dis3=L.Convolution2D(64 * density, 128 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 64 * density)),
            norm3=L.BatchNormalization(128 * density),
            dis4=L.Convolution2D(128 * density, 256 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 128 * density)),
            norm4=L.BatchNormalization(256 * density),
            dis5=L.Linear(initial_size * initial_size * 256 * density, 512,
                          wscale=0.02 * math.sqrt(initial_size * initial_size * 256 * density)),
            norm5=L.BatchNormalization(512),
            dis6=L.Linear(512, 2, wscale=0.02 * math.sqrt(512)),
        )
vaegan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 30 收藏 0 点赞 0 评论 0
def __init__(self, density=1, size=64, latent_size=100, channel=3):
        assert (size % 16 == 0)
        initial_size = size / 16
        super(Encoder_origin, self).__init__(
            enc1=L.Convolution2D(channel, 32 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * channel * density)),
            enc2=L.Convolution2D(32 * density, 64 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 32 * density)),
            norm2=L.BatchNormalization(64 * density),
            enc3=L.Convolution2D(64 * density, 128 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 64 * density)),
            norm3=L.BatchNormalization(128 * density),
            enc4=L.Convolution2D(128 * density, 256 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 128 * density)),
            norm4=L.BatchNormalization(256 * density),
            mean=L.Linear(initial_size * initial_size * 256 * density, latent_size,
                          wscale=0.02 * math.sqrt(initial_size * initial_size * 256 * density)),
            ln_var=L.Linear(initial_size * initial_size * 256 * density, latent_size,
                            wscale=0.02 * math.sqrt(initial_size * initial_size * 256 * density)),
        )
vaegan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 31 收藏 0 点赞 0 评论 0
def __init__(self, density=1, size=64, latent_size=100, channel=3):
        assert (size % 16 == 0)
        initial_size = size / 16
        super(Generator_origin, self).__init__(
            g1=L.Linear(latent_size, initial_size * initial_size * 256 * density, wscale=0.02 * math.sqrt(latent_size)),
            norm1=L.BatchNormalization(initial_size * initial_size * 256 * density),
            g2=L.Deconvolution2D(256 * density, 128 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 256 * density)),
            norm2=L.BatchNormalization(128 * density),
            g3=L.Deconvolution2D(128 * density, 64 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 128 * density)),
            norm3=L.BatchNormalization(64 * density),
            g4=L.Deconvolution2D(64 * density, 32 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 64 * density)),
            norm4=L.BatchNormalization(32 * density),
            g5=L.Deconvolution2D(32 * density, channel, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 32 * density)),
        )
        self.density = density
        self.latent_size = latent_size
        self.initial_size = initial_size
vaegan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 30 收藏 0 点赞 0 评论 0
def __init__(self, density=1, size=64, channel=3):
        assert (size % 16 == 0)
        initial_size = size / 16
        super(Discriminator_org, self).__init__(
            dis1=L.Convolution2D(channel, 32 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * channel * density)),
            dis2=L.Convolution2D(32 * density, 64 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 32 * density)),
            norm2=L.BatchNormalization(64 * density),
            dis3=L.Convolution2D(64 * density, 128 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 64 * density)),
            norm3=L.BatchNormalization(128 * density),
            dis4=L.Convolution2D(128 * density, 256 * density, 4, stride=2, pad=1,
                                 wscale=0.02 * math.sqrt(4 * 4 * 128 * density)),
            norm4=L.BatchNormalization(256 * density),
            dis5=L.Linear(initial_size * initial_size * 256 * density, 2,
                          wscale=0.02 * math.sqrt(initial_size * initial_size * 256 * density)),
        )
vaewgan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def __init__(self, size=64, ch=512, wscale=0.005):
        assert (size % 16 == 0)
        initial_size = size // 16
        w = chainer.initializers.Normal(wscale)
        super(Discriminator, self).__init__(
            c0_0=L.Convolution2D(3, ch // 8, 3, 1, 1, initialW=w),
            c0_1=L.Convolution2D(ch // 8, ch // 4, 4, 2, 1, initialW=w),
            c1_1=L.Convolution2D(ch // 4, ch // 2, 4, 2, 1, initialW=w),
            c2_1=L.Convolution2D(ch // 2, ch // 1, 4, 2, 1, initialW=w),
            c3_0=L.Convolution2D(ch // 1, ch // 1, 4, 2, 1, initialW=w),
            l4=L.Linear(initial_size * initial_size * ch, 1, initialW=w),
            bn0_1=L.BatchNormalization(ch // 4, use_gamma=False),
            bn1_1=L.BatchNormalization(ch // 2, use_gamma=False),
            bn2_1=L.BatchNormalization(ch // 1, use_gamma=False),
            bn3_0=L.BatchNormalization(ch // 1, use_gamma=False),
        )
vaewgan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 31 收藏 0 点赞 0 评论 0
def __init__(self, size=64, ch=512, wscale=0.005):
        assert (size % 16 == 0)
        initial_size = size // 16
        w = chainer.initializers.Normal(wscale)
        super(Discriminator2, self).__init__(
            c0_0=L.Convolution2D(3, ch // 8, 3, 1, 1, initialW=w),
            c0_1=L.Convolution2D(ch // 8, ch // 4, 4, 2, 1, initialW=w),
            c1_1=L.Convolution2D(ch // 4, ch // 2, 4, 2, 1, initialW=w),
            c2_1=L.Convolution2D(ch // 2, ch // 1, 4, 2, 1, initialW=w),
            c3_0=L.Convolution2D(ch // 1, ch // 1, 4, 2, 1, initialW=w),
            l4=L.Linear(initial_size * initial_size * ch, 1, initialW=w),
            bn0_1=L.BatchNormalization(ch // 4),
            bn1_1=L.BatchNormalization(ch // 2),
            bn2_1=L.BatchNormalization(ch // 1),
            bn3_0=L.BatchNormalization(ch // 1),
        )
vaewgan.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 26 收藏 0 点赞 0 评论 0
def __init__(self, size=64, n_hidden=128, ch=512, wscale=0.02):
        assert (size % 16 == 0)
        initial_size = size / 16
        w = chainer.initializers.Normal(wscale)
        super(Encoder, self).__init__(
            c0_0=L.Convolution2D(3, ch // 8, 3, 1, 1, initialW=w),
            c0_1=L.Convolution2D(ch // 8, ch // 4, 4, 2, 1, initialW=w),
            c1_1=L.Convolution2D(ch // 4, ch // 2, 4, 2, 1, initialW=w),
            c2_1=L.Convolution2D(ch // 2, ch // 1, 4, 2, 1, initialW=w),
            c3_0=L.Convolution2D(ch // 1, ch // 1, 4, 2, 1, initialW=w),
            mean=L.Linear(initial_size * initial_size * ch, n_hidden, initialW=w),
            ln_var=L.Linear(initial_size * initial_size * ch, n_hidden, initialW=w),
            bn0_1=L.BatchNormalization(ch // 4, use_gamma=False),
            bn1_1=L.BatchNormalization(ch // 2, use_gamma=False),
            bn2_1=L.BatchNormalization(ch // 1, use_gamma=False),
            bn3_0=L.BatchNormalization(ch // 1, use_gamma=False),
        )

    # noinspection PyCallingNonCallable,PyUnresolvedReferences
model.py 文件源码 项目:chainer-image-generation 作者: fukuta0614 项目源码 文件源码 阅读 29 收藏 0 点赞 0 评论 0
def __init__(self, ch0, ch1, bn=True, sample='down', activation=F.relu, dropout=False, noise=False):
        self.bn = bn
        self.activation = activation
        self.dropout = dropout
        self.noise = noise
        layers = {}
        w = chainer.initializers.Normal(0.02)
        if sample == 'down':
            layers['c'] = L.Convolution2D(ch0, ch1, 4, 2, 1, initialW=w)
        elif sample == 'up':
            layers['c'] = L.Deconvolution2D(ch0, ch1, 4, 2, 1, initialW=w)
        elif sample == 'c7s1':
            layers['c'] = L.Convolution2D(ch0, ch1, 7, 1, 3, initialW=w)
        if bn:
            if self.noise:
                layers['batchnorm'] = L.BatchNormalization(ch1, use_gamma=False)
            else:
                layers['batchnorm'] = L.BatchNormalization(ch1)
        super(CBR, self).__init__(**layers)
resnet50.py 文件源码 项目:chainer-DPNs 作者: oyam 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def __init__(self, in_size, ch, out_size, stride=2):
        super(BottleNeckA, self).__init__()
        initialW = initializers.HeNormal()

        with self.init_scope():
            self.conv1 = L.Convolution2D(
                in_size, ch, 1, stride, 0, initialW=initialW, nobias=True)
            self.bn1 = L.BatchNormalization(ch)
            self.conv2 = L.Convolution2D(
                ch, ch, 3, 1, 1, initialW=initialW, nobias=True)
            self.bn2 = L.BatchNormalization(ch)
            self.conv3 = L.Convolution2D(
                ch, out_size, 1, 1, 0, initialW=initialW, nobias=True)
            self.bn3 = L.BatchNormalization(out_size)

            self.conv4 = L.Convolution2D(
                in_size, out_size, 1, stride, 0,
                initialW=initialW, nobias=True)
            self.bn4 = L.BatchNormalization(out_size)
net.py 文件源码 项目:cv-api 作者: yasunorikudo 项目源码 文件源码 阅读 20 收藏 0 点赞 0 评论 0
def __init__(self):
        super(FastStyleNet, self).__init__(
            c1=L.Convolution2D(3, 32, 9, stride=1, pad=4),
            c2=L.Convolution2D(32, 64, 4, stride=2, pad=1),
            c3=L.Convolution2D(64, 128, 4,stride=2, pad=1),
            r1=ResidualBlock(128, 128),
            r2=ResidualBlock(128, 128),
            r3=ResidualBlock(128, 128),
            r4=ResidualBlock(128, 128),
            r5=ResidualBlock(128, 128),
            d1=L.Deconvolution2D(128, 64, 4, stride=2, pad=1),
            d2=L.Deconvolution2D(64, 32, 4, stride=2, pad=1),
            d3=L.Deconvolution2D(32, 3, 9, stride=1, pad=4),
            b1=L.BatchNormalization(32),
            b2=L.BatchNormalization(64),
            b3=L.BatchNormalization(128),
            b4=L.BatchNormalization(64),
            b5=L.BatchNormalization(32),
        )
model.py 文件源码 项目:chainer-DenseNet 作者: t-hanya 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def __init__(self, in_channels, n_layers, growth_rate,
                 dropout_ratio=None):

        super(DenseBlock, self).__init__()

        self._layers = []
        sum_channels = in_channels
        for l in range(n_layers):
            W = initializers.HeNormal()
            conv = L.Convolution2D(sum_channels, growth_rate, 3, pad=1,
                                   initialW=W)
            norm = L.BatchNormalization(sum_channels)
            self.add_link('conv{}'.format(l + 1), conv)
            self.add_link('norm{}'.format(l + 1), norm)
            self._layers.append((conv, norm))
            sum_channels += growth_rate

        self.add_persistent('dropout_ratio', dropout_ratio)
model.py 文件源码 项目:chainer-DenseNet 作者: t-hanya 项目源码 文件源码 阅读 18 收藏 0 点赞 0 评论 0
def __init__(self, depth=40, growth_rate=12, in_channels=16,
                 dropout_ratio=0.2, n_class=10):

        assert (depth - 4) % 3 == 0
        n_layers = int((depth - 4) / 3)
        n_ch = [in_channels + growth_rate * n_layers * i for i in range(4)]
        dropout_ratio = dropout_ratio if dropout_ratio > 0 else None

        super(DenseNet, self).__init__(
            conv0=L.Convolution2D(3, n_ch[0], 3, pad=1),
            dense1=DenseBlock(
                n_ch[0], n_layers, growth_rate, dropout_ratio),
            trans1=TransitionLayer(n_ch[1], n_ch[1], dropout_ratio),
            dense2=DenseBlock(
                n_ch[1], n_layers, growth_rate, dropout_ratio),
            trans2=TransitionLayer(n_ch[2], n_ch[2], dropout_ratio),
            dense3=DenseBlock(
                n_ch[2], n_layers, growth_rate, dropout_ratio),
            norm4=L.BatchNormalization(n_ch[3]),
            fc4=L.Linear(n_ch[3], n_class),
        )
net.py 文件源码 项目:GAN 作者: lyakaap 项目源码 文件源码 阅读 28 收藏 0 点赞 0 评论 0
def __init__(self, n_hidden, bottom_width=4, ch=512, wscale=0.02):
        super(Generator, self).__init__()
        self.n_hidden = n_hidden
        self.ch = ch
        self.bottom_width = bottom_width

        with self.init_scope():
            w = chainer.initializers.Normal(wscale)
            self.l0 = L.Linear(self.n_hidden, bottom_width * bottom_width * ch,
                               initialW=w)
            self.dc1 = L.Deconvolution2D(ch, ch // 2, 4, 2, 1, initialW=w)
            self.dc2 = L.Deconvolution2D(ch // 2, ch // 4, 4, 2, 1, initialW=w)
            self.dc3 = L.Deconvolution2D(ch // 4, ch // 8, 4, 2, 1, initialW=w)
            self.dc4 = L.Deconvolution2D(ch // 8, 3, 3, 1, 1, initialW=w)
            self.bn0 = L.BatchNormalization(bottom_width * bottom_width * ch)
            self.bn1 = L.BatchNormalization(ch // 2)
            self.bn2 = L.BatchNormalization(ch // 4)
            self.bn3 = L.BatchNormalization(ch // 8)
net.py 文件源码 项目:GAN 作者: lyakaap 项目源码 文件源码 阅读 23 收藏 0 点赞 0 评论 0
def __init__(self, bottom_width=4, ch=512, wscale=0.02):
        w = chainer.initializers.Normal(wscale)
        super(Discriminator, self).__init__()
        with self.init_scope():
            self.c0_0 = L.Convolution2D(3, ch // 8, 3, 1, 1, initialW=w)
            self.c0_1 = L.Convolution2D(ch // 8, ch // 4, 4, 2, 1, initialW=w)
            self.c1_0 = L.Convolution2D(ch // 4, ch // 4, 3, 1, 1, initialW=w)
            self.c1_1 = L.Convolution2D(ch // 4, ch // 2, 4, 2, 1, initialW=w)
            self.c2_0 = L.Convolution2D(ch // 2, ch // 2, 3, 1, 1, initialW=w)
            self.c2_1 = L.Convolution2D(ch // 2, ch // 1, 4, 2, 1, initialW=w)
            self.c3_0 = L.Convolution2D(ch // 1, ch // 1, 3, 1, 1, initialW=w)
            self.l4 = L.Linear(bottom_width * bottom_width * ch, 1, initialW=w)
            self.bn0_1 = L.BatchNormalization(ch // 4, use_gamma=False)
            self.bn1_0 = L.BatchNormalization(ch // 4, use_gamma=False)
            self.bn1_1 = L.BatchNormalization(ch // 2, use_gamma=False)
            self.bn2_0 = L.BatchNormalization(ch // 2, use_gamma=False)
            self.bn2_1 = L.BatchNormalization(ch // 1, use_gamma=False)
            self.bn3_0 = L.BatchNormalization(ch // 1, use_gamma=False)
MNIST_classify.py 文件源码 项目:GAN 作者: lyakaap 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def __init__(self):
        initializer = initializers.HeNormal()
        dis = Discriminator()
        chainer.serializers.load_npz('result/dis_iter_500000.npz', dis)
        super(DiscriminatorClassifier, self).__init__(
            c0 = L.Convolution2D(1, 64, 4, stride=2, pad=1, initialW=dis.c0.W.data, initial_bias=dis.c0.b.data),
            c1 = L.Convolution2D(64, 128, 4, stride=2, pad=1, initialW=dis.c1.W.data, initial_bias=dis.c1.b.data),
            l2 = L.Linear(7*7*128, 10, initialW = initializer),
            bn1 = L.BatchNormalization(128),
        )
        self.c0.disable_update()

#    def __init__(self):
#        initializer = initializers.HeNormal()
#        super(DiscriminatorClassifier, self).__init__(
#            c0 = L.Convolution2D(1, 64, 4, stride=2, pad=1, initialW=initializer),
#            c1 = L.Convolution2D(64, 128, 4, stride=2, pad=1, initialW=initializer),
#            l2 = L.Linear(7*7*128, 10, initialW = initializer),
#            bn1 = L.BatchNormalization(128),
#        )
#
model.py 文件源码 项目:reinforcement-learning 作者: musyoku 项目源码 文件源码 阅读 18 收藏 0 点赞 0 评论 0
def build_network(self):
        config.check()
        wscale = config.q_wscale

        # Fully connected part of Q-Network
        fc_attributes = {}
        fc_units = zip(config.q_fc_units[:-1], config.q_fc_units[1:])

        for i, (n_in, n_out) in enumerate(fc_units):
            fc_attributes["layer_%i" % i] = L.Linear(n_in, n_out, wscale=wscale)
            fc_attributes["batchnorm_%i" % i] = BatchNormalization(n_out)

        fc = FullyConnectedNetwork(**fc_attributes)
        fc.n_hidden_layers = len(fc_units) - 1
        fc.activation_function = config.q_fc_activation_function
        fc.apply_batchnorm = config.apply_batchnorm
        fc.apply_dropout = config.q_fc_apply_dropout
        fc.apply_batchnorm_to_input = config.q_fc_apply_batchnorm_to_input
        if config.use_gpu:
            fc.to_gpu()
        return fc
model.py 文件源码 项目:reinforcement-learning 作者: musyoku 项目源码 文件源码 阅读 26 收藏 0 点赞 0 评论 0
def build_network(self, units=None):
        if units is None:
            raise Exception()
        config.check()
        wscale = config.q_wscale

        # Fully connected part of Q-Network
        fc_attributes = {}
        units[-1] *= config.q_k_heads
        fc_units = zip(units[:-1], units[1:])

        for i, (n_in, n_out) in enumerate(fc_units):
            fc_attributes["layer_%i" % i] = L.Linear(n_in, n_out, wscale=wscale)
            fc_attributes["batchnorm_%i" % i] = BatchNormalization(n_out)

        fc = FullyConnectedNetwork(**fc_attributes)
        fc.n_hidden_layers = len(fc_units) - 1
        fc.activation_function = config.q_fc_activation_function
        fc.apply_batchnorm = config.apply_batchnorm
        fc.apply_dropout = config.q_fc_apply_dropout
        fc.apply_batchnorm_to_input = config.q_fc_apply_batchnorm_to_input
        if config.use_gpu:
            fc.to_gpu()
        return fc
model.py 文件源码 项目:reinforcement-learning 作者: musyoku 项目源码 文件源码 阅读 22 收藏 0 点赞 0 评论 0
def build_head(self, k=0, units=None):
        if units is None:
            raise Exception()
        config.check()
        wscale = config.q_wscale

        # Fully connected part of Q-Network
        fc_attributes = {}
        fc_units = zip(units[:-1], units[1:])

        for i, (n_in, n_out) in enumerate(fc_units):
            fc_attributes["layer_%i" % i] = LinearHead(n_in, n_out, config.q_k_heads, wscale=wscale)
            fc_attributes["batchnorm_%i" % i] = BatchNormalization(n_out)

        fc = FullyConnectedNetwork(**fc_attributes)
        fc.n_hidden_layers = len(fc_units) - 1
        fc.activation_function = config.q_fc_activation_function
        fc.apply_dropout = config.q_fc_apply_dropout
        if config.use_gpu:
            fc.to_gpu()
        return fc


问题


面经


文章

微信
公众号

扫码关注公众号