コード例 #1
0
ファイル: Models.py プロジェクト: ebsrn/CORE
 def convolution(x):
     x = self.convolution[0](x)
     x = self.convolution[1](x)
     x = self.convolution[2](x)
     x = M.max_pooling_2d(x, 3, 2)
     x = self.convolution[3](x)
     x = self.convolution[4](x)
     x = M.max_pooling_2d(x, 3, 2)
     return x
コード例 #2
0
ファイル: googlenet.py プロジェクト: k-okada/chainercv
 def __init__(self, pretrained_model='auto'):
     super(GoogLeNet, self).__init__(
         conv1=Convolution2D(3, 64, 7, stride=2, pad=3),
         conv2_reduce=Convolution2D(64, 64, 1),
         conv2=Convolution2D(64, 192, 3, stride=1, pad=1),
         inc3a=Inception(192, 64, 96, 128, 16, 32, 32),
         inc3b=Inception(256, 128, 128, 192, 32, 96, 64),
         inc4a=Inception(480, 192, 96, 208, 16, 48, 64),
         inc4b=Inception(512, 160, 112, 224, 24, 64, 64),
         inc4c=Inception(512, 128, 128, 256, 24, 64, 64),
         inc4d=Inception(512, 112, 144, 288, 32, 64, 64),
         inc4e=Inception(528, 256, 160, 320, 32, 128, 128),
         inc5a=Inception(832, 256, 160, 320, 32, 128, 128),
         inc5b=Inception(832, 384, 192, 384, 48, 128, 128),
         loss3_fc=Linear(1024, 1000),
         loss1_conv=Convolution2D(512, 128, 1),
         loss1_fc1=Linear(4 * 4 * 128, 1024),
         loss1_fc2=Linear(1024, 1000),
         loss2_conv=Convolution2D(528, 128, 1),
         loss2_fc1=Linear(4 * 4 * 128, 1024),
         loss2_fc2=Linear(1024, 1000),
     )
     if pretrained_model == 'auto':
         _retrieve(
             'bvlc_googlenet.npz',
             'http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel',
             self)
     elif pretrained_model:
         npz.load_npz(pretrained_model, self)
     self.functions = OrderedDict([
         ('conv1', [self.conv1, relu]),
         ('pool1', [
             lambda x: max_pooling_2d(x, ksize=3, stride=2),
             lambda x: local_response_normalization(x, n=5)
         ]), ('conv2_reduce', [self.conv2_reduce, relu]),
         ('conv2', [self.conv2, relu]),
         ('pool2', [
             lambda x: local_response_normalization(x, n=5),
             lambda x: max_pooling_2d(x, ksize=3, stride=2)
         ]), ('inc3a', [self.inc3a]), ('inc3b', [self.inc3b]),
         ('pool3', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('inc4a', [self.inc4a]), ('inc4b', [self.inc4b]),
         ('inc4c', [self.inc4c]), ('inc4d', [self.inc4d]),
         ('inc4e', [self.inc4e]),
         ('pool4', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('inc5a', [self.inc5a]), ('inc5b', [self.inc5b]),
         ('pool6', [lambda x: average_pooling_2d(x, ksize=7, stride=1)]),
         ('prob', [lambda x: dropout(x, ratio=0.4), self.loss3_fc])
     ])
コード例 #3
0
 def __call__(self, x):
     h = max_pooling_2d.max_pooling_2d(relu.relu(self.conv1(x)),
                                       3,
                                       stride=2)
     h = max_pooling_2d.max_pooling_2d(relu.relu(self.conv2(h)),
                                       3,
                                       stride=2)
     h = relu.relu(self.conv3(h))
     h = relu.relu(self.conv4(h))
     h = max_pooling_2d.max_pooling_2d(relu.relu(self.conv5(h)),
                                       3,
                                       stride=2)
     h = self.fc6(h)
     h = self.fc7(h)
     return self.fc8(h)
コード例 #4
0
ファイル: inceptionbn.py プロジェクト: z331565360/chainer
    def __call__(self, x):
        outs = []

        if self.out1 > 0:
            h1 = self.conv1(x)
            h1 = self.conv1n(h1)
            h1 = relu.relu(h1)
            outs.append(h1)

        h3 = relu.relu(self.proj3n(self.proj3(x)))
        h3 = relu.relu(self.conv3n(self.conv3(h3)))
        outs.append(h3)

        h33 = relu.relu(self.proj33n(self.proj33(x)))
        h33 = relu.relu(self.conv33an(self.conv33a(h33)))
        h33 = relu.relu(self.conv33bn(self.conv33b(h33)))
        outs.append(h33)

        if self.pooltype == 'max':
            p = max_pooling_2d.max_pooling_2d(x, 3, stride=self.stride, pad=1,
                                              cover_all=False)
        else:
            p = average_pooling_2d.average_pooling_2d(x, 3, stride=self.stride,
                                                      pad=1)
        if self.proj_pool is not None:
            p = relu.relu(self.poolpn(self.poolp(p)))
        outs.append(p)

        y = concat.concat(outs, axis=1)
        return y
コード例 #5
0
ファイル: inceptionbn.py プロジェクト: dsanno/chainer
    def __call__(self, x):
        test = not self.train
        outs = []

        if self.out1 > 0:
            h1 = self.conv1(x)
            h1 = self.conv1n(h1, test=test)
            h1 = relu.relu(h1)
            outs.append(h1)

        h3 = relu.relu(self.proj3n(self.proj3(x), test=test))
        h3 = relu.relu(self.conv3n(self.conv3(h3), test=test))
        outs.append(h3)

        h33 = relu.relu(self.proj33n(self.proj33(x), test=test))
        h33 = relu.relu(self.conv33an(self.conv33a(h33), test=test))
        h33 = relu.relu(self.conv33bn(self.conv33b(h33), test=test))
        outs.append(h33)

        if self.pooltype == 'max':
            p = max_pooling_2d.max_pooling_2d(x, 3, stride=self.stride, pad=1)
        else:
            p = average_pooling_2d.average_pooling_2d(x, 3, stride=self.stride,
                                                      pad=1)
        if self.proj_pool is not None:
            p = relu.relu(self.poolpn(self.poolp(p), test=test))
        outs.append(p)

        y = concat.concat(outs, axis=1)
        return y
コード例 #6
0
 def __init__(self, pretrained_model='auto'):
     if pretrained_model:
         # As a sampling process is time-consuming,
         # we employ a zero initializer for faster computation.
         kwargs = {'initialW': constant.Zero()}
     else:
         # employ default initializers used in the original paper
         kwargs = {'initialW': normal.HeNormal(scale=1.0)}
     super(ResNet50Layers, self).__init__(
         conv1=Convolution2D(3, 64, 7, 2, 3, **kwargs),
         bn1=BatchNormalization(64),
         res2=BuildingBlock(3, 64, 64, 256, 1, **kwargs),
         res3=BuildingBlock(4, 256, 128, 512, 2, **kwargs),
         res4=BuildingBlock(6, 512, 256, 1024, 2, **kwargs),
         res5=BuildingBlock(3, 1024, 512, 2048, 2, **kwargs),
         fc6=Linear(2048, 1000),
     )
     if pretrained_model == 'auto':
         _retrieve(
             'ResNet-50-model.npz', 'ResNet-50-model.caffemodel', self)
     elif pretrained_model:
         npz.load_npz(pretrained_model, self)
     self.functions = OrderedDict([
         ('conv1', [self.conv1, self.bn1, relu]),
         ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('res2', [self.res2]),
         ('res3', [self.res3]),
         ('res4', [self.res4]),
         ('res5', [self.res5]),
         ('pool5', [_global_average_pooling_2d]),
         ('fc6', [self.fc6]),
         ('prob', [softmax]),
     ])
コード例 #7
0
 def functions(self):
     return collections.OrderedDict([
         ('conv1', [self.conv1, self.bn1, relu]),
         ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('res2', [self.res2]), ('res3', [self.res3]),
         ('res4', [self.res4]), ('res5', [self.res5])
     ])
コード例 #8
0
ファイル: inceptionbn.py プロジェクト: asi1024/chainer
    def forward(self, x):
        outs = []

        if self.out1 > 0:
            h1 = self.conv1(x)
            h1 = self.conv1n(h1)
            h1 = relu.relu(h1)
            outs.append(h1)

        h3 = relu.relu(self.proj3n(self.proj3(x)))
        h3 = relu.relu(self.conv3n(self.conv3(h3)))
        outs.append(h3)

        h33 = relu.relu(self.proj33n(self.proj33(x)))
        h33 = relu.relu(self.conv33an(self.conv33a(h33)))
        h33 = relu.relu(self.conv33bn(self.conv33b(h33)))
        outs.append(h33)

        if self.pooltype == 'max':
            p = max_pooling_2d.max_pooling_2d(x, 3, stride=self.stride, pad=1,
                                              cover_all=False)
        else:
            p = average_pooling_2d.average_pooling_2d(x, 3, stride=self.stride,
                                                      pad=1)
        if self.proj_pool is not None:
            p = relu.relu(self.poolpn(self.poolp(p)))
        outs.append(p)

        y = concat.concat(outs, axis=1)
        return y
コード例 #9
0
 def __call__(self, x):
     out1 = self.f.conv1(x)
     out3 = self.f.conv3(relu.relu(self.f.proj3(x)))
     out5 = self.f.conv5(relu.relu(self.f.proj5(x)))
     pool = self.f.projp(
         max_pooling_2d.max_pooling_2d(x, 3, stride=1, pad=1))
     y = relu.relu(concat.concat((out1, out3, out5, pool), axis=1))
     return y
コード例 #10
0
ファイル: inception.py プロジェクト: ryuuji5/chainer
 def __call__(self, x):
     out1 = self.f.conv1(x)
     out3 = self.f.conv3(relu.relu(self.f.proj3(x)))
     out5 = self.f.conv5(relu.relu(self.f.proj5(x)))
     pool = self.f.projp(max_pooling_2d.max_pooling_2d(
         x, 3, stride=1, pad=1))
     y = relu.relu(concat.concat((out1, out3, out5, pool), axis=1))
     return y
コード例 #11
0
ファイル: vgg_a.py プロジェクト: yiheng/chainer-deepmark
 def __call__(self, x):
     h = relu.relu(self.conv1(x), self.use_cudnn)
     h = max_pooling_2d.max_pooling_2d(h, 2, stride=2, use_cudnn=self.use_cudnn)
     h = relu.relu(self.conv2(h), self.use_cudnn)
     h = max_pooling_2d.max_pooling_2d(h, 2, stride=2, use_cudnn=self.use_cudnn)
     h = relu.relu(self.conv3_1(h), self.use_cudnn)
     h = relu.relu(self.conv3_2(h), self.use_cudnn)
     h = max_pooling_2d.max_pooling_2d(h, 2, stride=2, use_cudnn=self.use_cudnn)
     h = relu.relu(self.conv4_1(h), self.use_cudnn)
     h = relu.relu(self.conv4_2(h), self.use_cudnn)
     h = max_pooling_2d.max_pooling_2d(h, 2, stride=2, use_cudnn=self.use_cudnn)
     h = relu.relu(self.conv5_1(h), self.use_cudnn)
     h = relu.relu(self.conv5_2(h), self.use_cudnn)
     h = max_pooling_2d.max_pooling_2d(h, 2, stride=2, use_cudnn=self.use_cudnn)
     h = self.fc6(h)
     h = self.fc7(h)
     return self.fc8(h)
コード例 #12
0
 def functions(self):
     return collections.OrderedDict([
         ('conv1', [self.conv1, relu]),
         ('pool1', [lambda x: max_pooling_2d(x, 3, stride=2)]),
         ('fire2', [self.fire2]),
         ('fire3', [self.fire3]),
         ('pool2', [lambda x: max_pooling_2d(x, 3, stride=2)]),
         ('fire4', [self.fire4]),
         ('fire5', [self.fire5]),
         ('pool3', [lambda x: max_pooling_2d(x, 3, stride=2)]),
         ('fire6', [self.fire6]),
         ('fire7', [self.fire7]),
         ('fire8', [self.fire8]),
         ('fire9', [self.fire9, dropout]),
         ('conv10', [self.conv10, relu]),
         ('pool4', [lambda x: average_pooling_2d(x, 13)]),
         ('prob',  [lambda x: reshape(x, (-1, 1000))]),
     ])
コード例 #13
0
ファイル: resnet.py プロジェクト: hidetomasuoka/chainer
 def functions(self):
     return collections.OrderedDict([
         ('conv1', [self.conv1, self.bn1, relu]),
         ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('res2', [self.res2]),
         ('res3', [self.res3]),
         ('res4', [self.res4]),
         ('res5', [self.res5]),
         ('pool5', [_global_average_pooling_2d]),
         ('fc6', [self.fc6]),
         ('prob', [softmax]),
     ])
コード例 #14
0
ファイル: resnet.py プロジェクト: ywatanabe0209/chainer
 def functions(self):
     return collections.OrderedDict([
         ('conv1', [self.conv1, self.bn1, relu]),
         ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('res2', [self.res2]),
         ('res3', [self.res3]),
         ('res4', [self.res4]),
         ('res5', [self.res5]),
         ('pool5', [_global_average_pooling_2d]),
         ('fc6', [self.fc6]),
         ('prob', [softmax]),
     ])
コード例 #15
0
ファイル: alex.py プロジェクト: yiheng/chainer-deepmark
 def __call__(self, x):
     h0 = max_pooling_2d.max_pooling_2d(relu.relu(self.conv1a(x)),
                                        3,
                                        stride=2)
     h1 = max_pooling_2d.max_pooling_2d(relu.relu(self.conv1b(x)),
                                        3,
                                        stride=2)
     h0 = max_pooling_2d.max_pooling_2d(relu.relu(self.conv2a(h0)),
                                        3,
                                        stride=2)
     h1 = max_pooling_2d.max_pooling_2d(relu.relu(self.conv2b(h1)),
                                        3,
                                        stride=2)
     h2 = relu.relu(self.conv3a(h0) + self.conv3b(h1))
     h3 = relu.relu(self.conv3c(h0) + self.conv3d(h1))
     h2 = relu.relu(self.conv4a(h2))
     h3 = relu.relu(self.conv4b(h3))
     h2 = max_pooling_2d.max_pooling_2d(relu.relu(self.conv5a(h2)),
                                        3,
                                        stride=2)
     h3 = max_pooling_2d.max_pooling_2d(relu.relu(self.conv5b(h3)),
                                        3,
                                        stride=2)
     h3 = self.fc6a(h2) + self.fc6b(h3)
     h3 = self.fc7(h3)
     return self.fc8(h3)
コード例 #16
0
ファイル: resnetfcn.py プロジェクト: jonaswgit/fcn
 def functions(self):
     return collections.OrderedDict([
         ('conv1', [self.conv1, self.bn1, relu]),
         ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
         ('res2', [self.res2]),
         ('res3', [self.res3]),
         ('res4', [self.res4]),
         ('res5', [self.res5]),
         #('pool5', [_global_average_pooling_2d]),  #not for us...
         #('fc6', [self.fc6]),
         ('score_fr', [self.score_fr]),
         ('upscore', [self.upscore]),
         #('prob', [softmax]), #the other fcn doesn't have this, as there its in the sofmax crossentropy
     ])
コード例 #17
0
    def forward(self, x):
        """Computes the output of the Inception module.
        Args:
            x (~chainer.Variable): Input variable.
        Returns:
            Variable: Output variable. Its array has the same spatial size and
            the same minibatch size as the input array. The channel dimension
            has size ``out1 + out3 + out5 + proj_pool``.
        """
        out1 = self.conv1(x)
        out3 = self.conv3(relu.relu(self.proj3(x)))
        out5 = self.conv5(relu.relu(self.proj5(x)))
        pool = self.projp(max_pooling_2d.max_pooling_2d(x, 3, stride=1, pad=1))

        y = relu.relu(concat.concat((out1, out3, out5, pool), axis=1))
        return y
コード例 #18
0
ファイル: resnet_50.py プロジェクト: yiheng/chainer-deepmark
 def __call__(self, x):
     h = self.bn1(self.conv1(x), test=not self.train)
     h = max_pooling_2d.max_pooling_2d(relu.relu(h),
                                       3,
                                       stride=2,
                                       use_cudnn=self.use_cudnn)
     h = self.res2(h, self.train)
     h = self.res3(h, self.train)
     h = self.res4(h, self.train)
     h = self.res5(h, self.train)
     h = average_pooling_2d.average_pooling_2d(h,
                                               7,
                                               stride=1,
                                               use_cudnn=self.use_cudnn)
     h = self.fc(h)
     return h
コード例 #19
0
    def __call__(self, x, test=None):
        """Computes the output of the InceptionBN module.

        Args:
            x (Variable): An input variable.
            test (bool): If ``True``, batch normalization layers run in testing
                mode; if ``test`` is omitted, ``not self.train`` is used as
                ``test``.

        """
        if test is None:
            test = not self.train
        outs = []

        if self.out1 > 0:
            h1 = self.conv1(x)
            h1 = self.conv1n(h1, test=test)
            h1 = relu.relu(h1)
            outs.append(h1)

        h3 = relu.relu(self.proj3n(self.proj3(x), test=test))
        h3 = relu.relu(self.conv3n(self.conv3(h3), test=test))
        outs.append(h3)

        h33 = relu.relu(self.proj33n(self.proj33(x), test=test))
        h33 = relu.relu(self.conv33an(self.conv33a(h33), test=test))
        h33 = relu.relu(self.conv33bn(self.conv33b(h33), test=test))
        outs.append(h33)

        if self.pooltype == 'max':
            p = max_pooling_2d.max_pooling_2d(x,
                                              3,
                                              stride=self.stride,
                                              pad=1,
                                              cover_all=False)
        else:
            p = average_pooling_2d.average_pooling_2d(x,
                                                      3,
                                                      stride=self.stride,
                                                      pad=1)
        if self.proj_pool is not None:
            p = relu.relu(self.poolpn(self.poolp(p), test=test))
        outs.append(p)

        y = concat.concat(outs, axis=1)
        return y
コード例 #20
0
ファイル: resnet.py プロジェクト: zachmayer/chainer
    def __init__(self, pretrained_model, n_layers):
        super(ResNetLayers, self).__init__()

        if pretrained_model:
            # As a sampling process is time-consuming,
            # we employ a zero initializer for faster computation.
            kwargs = {'initialW': constant.Zero()}
        else:
            # employ default initializers used in the original paper
            kwargs = {'initialW': normal.HeNormal(scale=1.0)}

        if n_layers == 50:
            block = [3, 4, 6, 3]
        elif n_layers == 101:
            block = [3, 4, 23, 3]
        elif n_layers == 152:
            block = [3, 8, 36, 3]
        else:
            raise ValueError('The n_layers argument should be either 50, 101,'
                             ' or 152, but {} was given.'.format(n_layers))

        with self.init_scope():
            self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs)
            self.bn1 = BatchNormalization(64)
            self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs)
            self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs)
            self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs)
            self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs)
            self.fc6 = Linear(2048, 1000)

        if pretrained_model and pretrained_model.endswith('.caffemodel'):
            _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers),
                      pretrained_model, self)
        elif pretrained_model:
            npz.load_npz(pretrained_model, self)
        self.functions = collections.OrderedDict([
            ('conv1', [self.conv1, self.bn1, relu]),
            ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
            ('res2', [self.res2]),
            ('res3', [self.res3]),
            ('res4', [self.res4]),
            ('res5', [self.res5]),
            ('pool5', [_global_average_pooling_2d]),
            ('fc6', [self.fc6]),
            ('prob', [softmax]),
        ])
コード例 #21
0
ファイル: resnet.py プロジェクト: jekbradbury/chainer
    def __init__(self, pretrained_model, n_layers):
        if pretrained_model:
            # As a sampling process is time-consuming,
            # we employ a zero initializer for faster computation.
            kwargs = {'initialW': constant.Zero()}
        else:
            # employ default initializers used in the original paper
            kwargs = {'initialW': normal.HeNormal(scale=1.0)}

        if n_layers == 50:
            block = [3, 4, 6, 3]
        elif n_layers == 101:
            block = [3, 4, 23, 3]
        elif n_layers == 152:
            block = [3, 8, 36, 3]
        else:
            raise ValueError('The n_layers argument should be either 50, 101,'
                             ' or 152, but {} was given.'.format(n_layers))

        super(ResNetLayers, self).__init__(
            conv1=Convolution2D(3, 64, 7, 2, 3, **kwargs),
            bn1=BatchNormalization(64),
            res2=BuildingBlock(block[0], 64, 64, 256, 1, **kwargs),
            res3=BuildingBlock(block[1], 256, 128, 512, 2, **kwargs),
            res4=BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs),
            res5=BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs),
            fc6=Linear(2048, 1000),
        )
        if pretrained_model and pretrained_model.endswith('.caffemodel'):
            _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers),
                      pretrained_model, self)
        elif pretrained_model:
            npz.load_npz(pretrained_model, self)
        self.functions = collections.OrderedDict([
            ('conv1', [self.conv1, self.bn1, relu]),
            ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
            ('res2', [self.res2]),
            ('res3', [self.res3]),
            ('res4', [self.res4]),
            ('res5', [self.res5]),
            ('pool5', [_global_average_pooling_2d]),
            ('fc6', [self.fc6]),
            ('prob', [softmax]),
        ])
コード例 #22
0
ファイル: inception.py プロジェクト: 2php/chainer
    def __call__(self, x):
        """Computes the output of the Inception module.

        Args:
            x (~chainer.Variable): Input variable.

        Returns:
            Variable: Output variable. Its array has the same spatial size and
            the same minibatch size as the input array. The channel dimension
            has size ``out1 + out3 + out5 + proj_pool``.

        """
        out1 = self.conv1(x)
        out3 = self.conv3(relu.relu(self.proj3(x)))
        out5 = self.conv5(relu.relu(self.proj5(x)))
        pool = self.projp(max_pooling_2d.max_pooling_2d(
            x, 3, stride=1, pad=1))
        y = relu.relu(concat.concat((out1, out3, out5, pool), axis=1))
        return y
コード例 #23
0
ファイル: inceptionbn.py プロジェクト: KotaroSetoyama/chainer
    def __call__(self, x, test=None):
        """Computes the output of the InceptionBN module.

        Args:
            x (Variable): An input variable.
            test (bool): If ``True``, batch normalization layers run in testing
                mode; if ``test`` is omitted, ``not self.train`` is used as
                ``test``.

        """
        if test is None:
            test = not self.train
        outs = []

        if self.out1 > 0:
            h1 = self.conv1(x)
            h1 = self.conv1n(h1, test=test)
            h1 = relu.relu(h1)
            outs.append(h1)

        h3 = relu.relu(self.proj3n(self.proj3(x), test=test))
        h3 = relu.relu(self.conv3n(self.conv3(h3), test=test))
        outs.append(h3)

        h33 = relu.relu(self.proj33n(self.proj33(x), test=test))
        h33 = relu.relu(self.conv33an(self.conv33a(h33), test=test))
        h33 = relu.relu(self.conv33bn(self.conv33b(h33), test=test))
        outs.append(h33)

        if self.pooltype == 'max':
            p = max_pooling_2d.max_pooling_2d(x, 3, stride=self.stride, pad=1,
                                              cover_all=False)
        else:
            p = average_pooling_2d.average_pooling_2d(x, 3, stride=self.stride,
                                                      pad=1)
        if self.proj_pool is not None:
            p = relu.relu(self.poolpn(self.poolp(p), test=test))
        outs.append(p)

        y = concat.concat(outs, axis=1)
        return y
コード例 #24
0
ファイル: vgg.py プロジェクト: km-t/dcpython
def _max_pooling_2d(x):
    return max_pooling_2d(x, ksize=2)
コード例 #25
0
ファイル: vgg.py プロジェクト: delta2323/chainer
def _max_pooling_2d(x):
    return max_pooling_2d(x, ksize=2)