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)
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]), ])
def __init__(self, out_ch: int) -> None: super().__init__() kw = {'initialW': normal.HeNormal(scale=1.0)} with self.init_scope(): self.conv1 = L.Convolution2D(None, 64, ksize=7, stride=2, pad=3, **kw) self.bn1 = L.BatchNormalization(64) self.block2 = Block(64, stride=2) self.block3 = Block(64) self.block4 = Block(64) self.block5 = Block(128, stride=2) self.block6 = Block(128) self.block7 = Block(128) self.block8 = Block(128) self.block9 = Block(256, stride=2) self.block10 = Block(256) self.block11 = Block(256) self.block12 = Block(256) self.block13 = Block(256) self.block14 = Block(256) self.block15 = Block(512, stride=2) self.block16 = Block(512) self.block17 = Block(512) self.fc18 = L.Linear(512, out_ch)
def __init__(self, out_ch: int, stride: int = 1) -> None: super().__init__() kw = {'initialW': normal.HeNormal(scale=1.0)} with self.init_scope(): self.conv1 = L.Convolution2D(None, out_ch, ksize=3, stride=stride, pad=1, nobias=True, **kw) self.bn1 = L.BatchNormalization(out_ch) self.conv2 = L.Convolution2D(out_ch, out_ch, ksize=3, pad=1, nobias=True, **kw) self.bn2 = L.BatchNormalization(out_ch) if stride != 1: self.conv_skip = L.Convolution2D(None, out_ch, ksize=1, stride=stride, nobias=True, **kw) self.bn_skip = L.BatchNormalization(out_ch) self.stride = stride
def __init__(self, n_out=10, n_layer=26, base_width=64): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if (n_layer - 2) % 6 == 0: n_block = (n_layer - 2) // 6 # n_layer = n_stage(=3) * n_block * n_conv(=2) + 2(conv1 + fc5) else: raise ValueError( 'The n_layer argument should be mod({} - 2, 6) == 0, \ but {} was given.'.format(n_layer, n_layer)) with self.init_scope(): self.conv1 = L.Convolution2D(3, 16, ksize=3, stride=1, pad=1, nobias=True, **kwargs) self.bn1 = L.BatchNormalization(16) k = base_width self.stage2 = BuildingShakeBlocks(n_block, 16, k, 1, **kwargs) self.stage3 = BuildingShakeBlocks(n_block, k, 2 * k, 2, **kwargs) self.stage4 = BuildingShakeBlocks(n_block, 2 * k, 4 * k, 2, **kwargs) self.fc5 = L.Linear(4 * k, n_out)
def __init__(self, n_layers, n_out, n_kernel=4, grid=2, seed_value=0, random=False, lattice=False, width=tuple(), layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if n_layers == 47: block = [5, 5, 5] elif n_layers == 74: block = [8, 8, 8] elif n_layers == 110: block = [12, 12, 12] elif n_layers == 164: block = [18, 18, 18] else: raise ValueError( 'The n_layers argument should be mod({} - 2, 3) == 0, \ but {} was given.'.format(n_layers, n_layers)) with self.init_scope(): self.conv1 = L.Convolution2D(3, 16, 3, 1, 1, **kwargs) self.res2 = PreBuildingBlock(block[0], 16, 16, 64, 1, **kwargs) self.expand3 = Expand(n_kernel, 32, grid=grid, seed_value=seed_value, random=random, lattice=lattice, width=width) self.res3 = PreBuildingBlock_shareBN(block[1], 64, 32, 128, 1, 2, n_kernel, **kwargs) self.expand4 = Expand(n_kernel, 16, grid=grid, seed_value=seed_value, random=random, lattice=lattice, width=width) self.res4 = PreBuildingBlock_shareBN(block[2], 128, 64, 256, 1, 4, n_kernel, **kwargs) self.bn4 = L.BatchNormalization(256) self.fc5 = L.Linear(256, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1]), ('res2', [self.res2]), ('expand3', [self.expand3]), ('res3', [self.res3]), ('expand4', [self.expand4]), ('res4', [self.res4]), ('squeeze4', [lambda x: batch_squeeze(x, 4, n_kernel)]), ('pool4', [self.bn4, F.relu, lambda x: F.split_axis(x, (n_kernel // 4) ** 2, axis=0), lambda x: F.concat(x, axis=2), R._global_average_pooling_2d]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, pretrained_model, n_layers, n_class, class_weight=None): super(ResNetLayersFCN32, self).__init__() self.n_class = n_class if class_weight is not None: assert class_weight.shape == (self.n_class,) self.class_weight = class_weight else: self.class_weight = None 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)} kwargs2 = { 'initialW': chainer.initializers.Zero(), 'initial_bias': chainer.initializers.Zero(), } 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(): #in the comments are the sizes (of default images of 224x224) AFTER the cooresponding layer self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs) #112x112 self.bn1 = BatchNormalization(64) self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs) #56x56 self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs) #28x28 self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs) #14x14 self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs) #7x7 #self.fc6 = Linear(2048, 1000) self.score_fr = L.Convolution2D(2048, n_class, 1, 1, 0, **kwargs2) self.upscore = L.Deconvolution2D(n_class, n_class, 64, 32, 0, nobias=True, initialW=initializers.UpsamplingDeconvWeight()) #224x224 if pretrained_model and pretrained_model.endswith('.caffemodel'): #default resnet model originalresnet = ResNetLayers(pretrained_model, n_layers) if n_layers == 50: _transfer_resnet50(originalresnet, self) elif n_layers == 101: _transfer_resnet101(originalresnet, self) elif n_layers == 152: _transfer_resnet152(originalresnet, self) else: raise ValueError('The n_layers argument should be either 50, 101,' ' or 152, but {} was given.'.format(n_layers)) elif pretrained_model: npz.load_npz(pretrained_model, self)
def __init__(self, n_layers, n_out, alpha=48, stride=(1, 2, 2), layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} in_ch = 16 if (n_layers - 2) % 9 == 0: n = (n_layers - 2) // 9 else: raise ValueError( 'The n_layers argument should be mod({} - 2, 9) == 0, \ but {} was given.'.format(n_layers, n_layers)) add_ch = alpha / (3 * n) temp_ch = in_ch with self.init_scope(): self.conv1 = L.Convolution2D(3, in_ch, 3, 1, 1, nobias=True, **kwargs) self.bn1 = L.BatchNormalization(in_ch) for i in range(3): name = 'pyramid{}'.format(i + 1) pyramid = BuildingPyramidBlock(n, in_ch, temp_ch, add_ch, stride[i], **kwargs) setattr(self, name, pyramid) temp_ch += n * add_ch # temp channel sum in_ch = 4 * round(temp_ch) # next in_ch self.bn4 = L.BatchNormalization(in_ch) self.fc5 = L.Linear(in_ch, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1]), ('pyramid2', [self.pyramid1]), ('pyramid3', [self.pyramid2]), ('pyramid4', [self.pyramid3]), ('pool4', [self.bn4, F.relu, lambda x: F.average(x, axis=(2, 3))]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, n_out, grid1=(1,), grid2=(1,), grid_shuffle=False, weights1=None, weights2=None, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if grid_shuffle: n_kernel1 = 4 n_kernel2 = 4 n_grid1 = 1 n_grid2 = 1 else: n_kernel1 = len(grid1) * 4 n_kernel2 = len(grid2) * 4 n_grid1 = len(grid1) n_grid2 = len(grid2) with self.init_scope(): self.conv1_1 = Conv2DBNActiv(None, 96, 3, 1, 1, nobias=True, **kwargs) self.conv1_2 = Conv2DBNActiv(None, 96, 3, 1, 1, nobias=True, **kwargs) self.expand1 = Expand(n_kernel1, 32, grid=grid1, grid_shuffle=grid_shuffle, weights=weights1) self.conv1_3 = Conv2DBNActiv(None, 96, 3, 1, 1, nobias=True, **kwargs) self.conv2_1 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv2_2 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.expand2 = Expand(n_kernel2, 16, grid=grid2, grid_shuffle=grid_shuffle, weights=weights2) self.conv2_3 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv3_1 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv3_2 = Conv2DBNActiv(None, 192, 1, 1, 0, nobias=True, **kwargs) self.conv3_3 = Conv2DBNActiv(None, 192, 1, 1, 0, nobias=True, **kwargs) self.fc = L.Linear(None, n_out) self.functions = collections.OrderedDict([ ('conv1', [lambda x: F.dropout(x, 0.2), self.conv1_1, self.conv1_2, self.expand1, self.conv1_3, F.dropout]), ('conv2', [self.conv2_1, self.conv2_2, self.expand2, self.conv2_3, F.dropout]), ('conv3', [self.conv3_1, self.conv3_2, self.conv3_3]), ('squeeze3', [lambda x: batch_squeeze(x, 4, n_kernel2)]), ('pool3', [lambda x: F.split_axis(x, n_grid1 * n_grid2, axis=0), lambda x: F.concat(x, axis=2), R._global_average_pooling_2d]), ('fc', [self.fc]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} with self.init_scope(): self.deconv1 = L.Deconvolution2D(512, 256, **kwargs, ksize=5) self.bn1 = L.BatchNormalization(256, eps=1e-5) self.deconv2 = L.Deconvolution2D(256, 128, **kwargs, ksize=5) self.bn2 = L.BatchNormalization(128, eps=1e-5) self.deconv3 = L.Deconvolution2D(128, 64, **kwargs, ksize=5) self.bn3 = L.BatchNormalization(64, eps=1e-5) self.deconv4 = L.Deconvolution2D(64, 1, **kwargs, ksize=5)
def __init__(self, n_layers, n_out, cardinality=8, base_width=64, widen_factor=4, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if (n_layers - 2) % 9 == 0: block = [(n_layers - 2) // 9] * 3 else: raise ValueError( 'The n_layers argument should be mod({} - 2, 9) == 0, \ but {} was given.'.format(n_layers, n_layers)) with self.init_scope(): self.conv1 = L.Convolution2D(None, 64, 3, 1, 1, **kwargs) self.bn1 = L.BatchNormalization(64) self.res2 = BuildingBlock(block[0], 64, 64 * widen_factor, cardinality, base_width, widen_factor, 1, **kwargs) self.res3 = BuildingBlock(block[1], 64 * widen_factor, 128 * widen_factor, cardinality, base_width, widen_factor, 1, **kwargs) self.res4 = BuildingBlock(block[2], 128 * widen_factor, 256 * widen_factor, cardinality, base_width, widen_factor, 1, **kwargs) self.fc5 = L.Linear(256 * widen_factor, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1, self.bn1, F.relu]), ('res2', [self.res2]), ('expand3', [lambda x: pgp(x, 2)]), ('res3', [self.res3]), ('expand4', [lambda x: pgp(x, 2)]), ('res4', [self.res4]), ('squeeze4', [lambda x: pgp_inv(x, 4)]), ('pool4', [lambda x: F.average(x, axis=(2, 3))]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} with self.init_scope(): self.conv1 = L.Convolution2D(1, 64, **kwargs, ksize=5) self.conv2 = L.Convolution2D(64, 128, **kwargs, ksize=5) self.bn2 = L.BatchNormalization(128, eps=1e-5) self.conv3 = L.Convolution2D(128, 256, **kwargs, ksize=5) self.bn3 = L.BatchNormalization(256, eps=1e-5) self.conv4 = L.Convolution2D(256, 512, **kwargs, ksize=5) self.bn4 = L.BatchNormalization(512, eps=1e-5) self.fc = L.Linear(512, 1)
def __init__(self, pretrained_model): initialW = normal.HeNormal(scale=1.0) super(Xception, self).__init__() with self.init_scope(): self.conv1 = L.Convolution2D(3, 32, 3, 2, 0, nobias=True, initialW=initialW) self.bn1 = L.BatchNormalization(32) self.conv2 = L.Convolution2D(32, 64, 3, nobias=True, initialW=initialW) self.bn2 = L.BatchNormalization(64) self.block1 = BuildingBlock( 64, 128, 2, 2, initialW, start_with_relu=False, grow_first=True) self.block2 = BuildingBlock( 128, 256, 2, 2, initialW, start_with_relu=True, grow_first=True) self.block3 = BuildingBlock( 256, 728, 2, 2, initialW, start_with_relu=True, grow_first=True) self.block4 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block5 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block6 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block7 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block8 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block9 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block10 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block11 = BuildingBlock( 728, 728, 3, 1, initialW, start_with_relu=True, grow_first=True) self.block12 = BuildingBlock( 728, 1024, 2, 2, initialW, start_with_relu=True, grow_first=False) self.conv3 = SeparableConv2D(1024, 1536, 3, 1, 1, initialW=initialW) self.bn3 = L.BatchNormalization(1536) self.conv4 = SeparableConv2D(1536, 2048, 3, 1, 1, initialW=initialW) self.bn4 = L.BatchNormalization(2048) self.fc = L.Linear(2048, 1000) if pretrained_model and pretrained_model.endswith('.caffemodel'): _retrieve('xception.npz', pretrained_model, self) elif pretrained_model: chainer.serializers.load_npz(pretrained_model, self)
def __init__(self, n_class=36, pretrained_model=None, output_scale=1.0): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: print "train resblock : True" # employ default initializers used in the original paper kwargs = {'initialW': normal.HeNormal(scale=1.0)} self.n_class = n_class self.output_scale = output_scale super(DualCenterProposalNetworkRes50FCN, self).__init__( # resnet50 conv1=L.Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=L.BatchNormalization(64), res2=R.BuildingBlock(3, 64, 64, 256, 1, **kwargs), res3=R.BuildingBlock(4, 256, 128, 512, 2, **kwargs), res4=R.BuildingBlock(6, 512, 256, 1024, 2, **kwargs), res5=R.BuildingBlock(3, 1024, 512, 2048, 2, **kwargs), upscore32=L.Deconvolution2D(2048, 512, 8, stride=4, pad=2), bn_up32=L.BatchNormalization(512), upscore16=L.Deconvolution2D(1024, 512, 4, stride=2, pad=1), bn_up16=L.BatchNormalization(512), concat_conv=L.Convolution2D(512 * 3, 512 * 3, 3, stride=1, pad=1), bn_concat=L.BatchNormalization(512 * 3), score_pool=L.Convolution2D(512 * 3, n_class, 1, stride=1, pad=0), upscore_final=L.Deconvolution2D(self.n_class, self.n_class, 16, stride=8, pad=4), conv_cp1=L.Convolution2D(512 * 3, 1024, 3, stride=1, pad=1), bn_cp1=L.BatchNormalization(1024), # center pose network conv_cp2=L.Convolution2D(1024, 512, 3, stride=1, pad=1), bn_cp2=L.BatchNormalization(512), upscore_cp1=L.Deconvolution2D(512, 16, 8, stride=4, pad=2), bn_cp3=L.BatchNormalization(16), upscore_cp2=L.Deconvolution2D(16, 3, 4, stride=2, pad=1), # origin center pose network conv_ocp2=L.Convolution2D(1024, 512, 3, stride=1, pad=1), bn_ocp2=L.BatchNormalization(512), upscore_ocp1=L.Deconvolution2D(512, 16, 8, stride=4, pad=2), bn_ocp3=L.BatchNormalization(16), upscore_ocp2=L.Deconvolution2D(16, 3, 4, stride=2, pad=1), )
def __init__(self, n_layers, n_out, layer_names=None): super().__init__() 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 = L.Convolution2D(3, 64, 7, 2, 3, nobias=True, **kwargs) self.bn1 = L.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_alter(block[2], 512, 256, 1024, 2, **kwargs) self.res5 = BuildingBlock_alter(block[3], 1024, 512, 2048, 2, **kwargs) self.fc6 = L.Linear(2048, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1, self.bn1, F.relu]), ('pool1', [lambda x: F.max_pooling_2d(x, ksize=3, stride=2)]), ('res2', [self.res2]), ('res3', [self.res3]), # ('expand4', [lambda x: _expand(x, 2)]), ('res4', [self.res4]), # ('expand5', [lambda x: _expand(x, 2)]), ('res5', [self.res5]), ('pool5', [R._global_average_pooling_2d]), ('fc6', [self.fc6]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, pretrained_model, n_layers, n_class=3): super(ResNetLayersFCN, self).__init__() self.n_class = n_class 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(): #in the comments are the sizes (of default images of 224x224) AFTER the cooresponding layer self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs) #112x112 self.bn1 = BatchNormalization(64) self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs) #56x56 self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs) #28x28 self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs) #14x14 self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs) #7x7 #self.fc6 = Linear(2048, 1000) self.score_fr = L.Convolution2D(2048, n_class, 1, 1, 0, **kwargs) self.upscore = L.Deconvolution2D( n_class, n_class, 64, 32, 0, nobias=True, initialW=initializers.UpsamplingDeconvWeight()) #224x224 #if pretrained_model and pretrained_model.endswith('.caffemodel'): # _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers), # pretrained_model, self) if pretrained_model and pretrained_model is in ['ResNet-101-model.caffemodel']: #later maybe and 50 and 152 here # open default resnet and extract weigths form it # pretrained_model, self) resnet101 = ResNetLayers(pretrained_model, 101) init_from_resnet101(resnet101) elif pretrained_model: npz.load_npz(pretrained_model, self)
def __init__(self, pretrained_model, n_layers): super(ResNet, 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 = L.Convolution2D(3, 64, 7, 2, 3, **kwargs) self.bn1 = L.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 = L.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, F.relu]), ('pool1', [lambda x: F.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', [F.softmax]), ])
def __init__(self, n_layers, n_out, k=1, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if (n_layers - 4) % 6 == 0: block = [(n_layers - 4) // 6] * 3 else: raise ValueError( 'The n_layers argument should be mod({} - 4, 6) == 0, \ but {} was given.'.format(n_layers, n_layers)) with self.init_scope(): self.conv1 = L.Convolution2D(3, 16, 3, 1, 1, **kwargs) self.res2 = PreBuildingBasicBlock(block[0], 16, 16 * k, 1, **kwargs) self.res3 = PreBuildingBasicBlock(block[1], 16 * k, 32 * k, 1, **kwargs) self.res4 = PreBuildingBasicBlock(block[2], 32 * k, 64 * k, 1, **kwargs) self.bn4 = L.BatchNormalization(64 * k) self.fc5 = L.Linear(64 * k, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1]), ('res2', [self.res2]), ('expand3', [lambda x: pgp(x, 2)]), ('res3', [self.res3]), ('expand4', [lambda x: pgp(x, 2)]), ('res4', [self.res4]), ('squeeze4', [lambda x: pgp_inv(x, 4)]), ('pool4', [self.bn4, F.relu, R._global_average_pooling_2d]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} block = [5, 5, 5] filters = [32, 32, 64, 128] with self.init_scope(): self.conv1 = L.Convolution2D(None, filters[0], 3, 1, 1, **kwargs, nobias=True) self.res2 = BuildingBlock(block[0], filters[0], filters[1], 1, **kwargs) self.res3 = BuildingBlock(block[1], filters[1], filters[2], 2, **kwargs) self.res4 = BuildingBlock(block[2], filters[2], filters[3], 2, **kwargs) self.bn4 = L.BatchNormalization(filters[3]) self.fc5 = L.Linear(filters[3], 10) self.functions = collections.OrderedDict([ ('conv1', [self.conv1]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4, self.bn4, F.relu]), ('pool4', [R._global_average_pooling_2d]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, n_layers, n_out, k=32, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if (n_layers - 2) % 6 == 0: block = [(n_layers - 2) // 6] * 3 else: raise ValueError( 'The n_layers argument should be mod({} - 4, 6) == 0, \ but {} was given.'.format(n_layers, n_layers)) with self.init_scope(): self.conv1 = L.Convolution2D(3, 16, 3, 1, 1, nobias=True, **kwargs) self.bn1 = L.BatchNormalization(16) self.res2 = BuildingShakeBlock( block[0], 16, k, 1, **kwargs) self.res3 = BuildingShakeBlock( block[1], k, 2 * k, 2, **kwargs) self.res4 = BuildingShakeBlock( block[2], 2 * k, 4 * k, 2, **kwargs) self.fc5 = L.Linear(4 * k, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1, self.bn1]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4]), ('pool4', [F.relu, R._global_average_pooling_2d]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, n_layers, n_out, stride=(1, 2, 2), layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if (n_layers - 2) % 3 == 0: block = [(n_layers - 2) // 9] * 3 else: raise ValueError( 'The n_layers argument should be mod({} - 2, 3) == 0, \ but {} was given.'.format(n_layers, n_layers)) with self.init_scope(): self.conv1 = L.Convolution2D(3, 16, 3, 1, 1, **kwargs) self.res2 = PreBuildingBlock(block[0], 16, 16, 64, stride[0], **kwargs) self.res3 = PreBuildingBlock(block[1], 64, 32, 128, stride[1], **kwargs) self.res4 = PreBuildingBlock(block[2], 128, 64, 256, stride[2], **kwargs) self.bn4 = L.BatchNormalization(256) self.fc5 = L.Linear(None, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4]), ('pool4', [self.bn4, F.relu, lambda x: F.average_pooling_2d(x, 8, stride=1)]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, n_out, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} with self.init_scope(): self.conv1_1 = Conv2DBNActiv(None, 96, 3, 1, 1, nobias=True, **kwargs) self.conv1_2 = Conv2DBNActiv(None, 96, 3, 1, 1, nobias=True, **kwargs) self.conv1_3 = Conv2DBNActiv(None, 96, 3, 1, 1, nobias=True, **kwargs) self.conv2_1 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv2_2 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv2_3 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv3_1 = Conv2DBNActiv(None, 192, 3, 1, 1, nobias=True, **kwargs) self.conv3_2 = Conv2DBNActiv(None, 192, 1, 1, 0, nobias=True, **kwargs) self.conv3_3 = Conv2DBNActiv(None, 192, 1, 1, 0, nobias=True, **kwargs) self.fc = L.Linear(None, n_out) self.functions = collections.OrderedDict([ ('conv1', [lambda x: F.dropout(x, 0.2), self.conv1_1, self.conv1_2, lambda x: pgp(x, 2), self.conv1_3, F.dropout]), ('conv2', [self.conv2_1, self.conv2_2, lambda x: pgp(x, 2), self.conv2_3, F.dropout]), ('conv3', [self.conv3_1, self.conv3_2, self.conv3_3]), ('squeeze3', [lambda x: pgp_inv(x, 4)]), ('pool3', [lambda x: F.average(x, axis=(2, 3))]), ('fc', [self.fc]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, n_class=36, pretrained_model=None): 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)} self.n_class = n_class super(DepthInvariantNetworkRes50FCN, self).__init__( # resnet50 conv1=L.Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=L.BatchNormalization(64), res2=R.BuildingBlock(3, 64, 64, 256, 1, **kwargs), # resblock 1/2 -> 1/4 res3=R.BuildingBlock(4, 256, 128, 512, 2, **kwargs), # resblock 1/4 ->1/8 res4=R.BuildingBlock(6, 512, 256, 1024, 2, **kwargs), # resblock 1/8 -> 1/16 res5=R.BuildingBlock(3, 1024, 512, 2048, 2, **kwargs), # resblock 1/16 -> 1/32 upscore1=L.Deconvolution2D(2048, 512, 16, stride=8, pad=4), upscore2=L.Deconvolution2D(1024, 512, 8, stride=4, pad=2), upscore3=L.Deconvolution2D(512, 512, 4, stride=2, pad=1), bn_upscore=L.BatchNormalization(512 * 3), concat_conv=L.Convolution2D(512 * 3, 1024, 3, stride=1, pad=1), pool_roi_conv=L.Convolution2D(1024, 1024, 5, stride=5, pad=0), conv_after_croip=L.Convolution2D(1024, 512, 3, stride=1, pad=1), bn_croip1=L.BatchNormalization(1024), bn_croip2=L.BatchNormalization(512), score_pool=L.Convolution2D(512, n_class, 1, stride=1, pad=0), upscore_final=L.Deconvolution2D(self.n_class, self.n_class, 8, stride=4, pad=2), )
def __init__(self, pretrained_model="auto"): if pretrained_model: kwargs = {'initialW': constant.Zero()} else: kwargs = {'initialW': normal.HeNormal(scale=1.0)} super(ResNet, self).__init__( conv1=L.Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=L.BatchNormalization(64), res2=Block(3, 64, 64, 256, 1, **kwargs), res3=Block(4, 256, 128, 512, 2, **kwargs), res4=Block(6, 512, 256, 1024, 2, **kwargs), res5=Block(3, 1024, 512, 2048, 2, **kwargs), fc6=L.Linear(None, 1000), ) if pretrained_model == 'auto': print("[ PREPROCESS ] Use caffe model of ResNet.") _retrieve('ResNet-50-model.npz', 'ResNet-50-model.caffemodel', self) self.fc6 = L.Linear(None, 25) elif pretrained_model: npz.load_npz(pretrained_model, self) self.train = True
def __init__(self, n_layer=12, growth_rate=12, n_class=10, in_ch=16, block=3, bottleneck=False, reduction=1.0, stride=[2, 2], layer_names=None): """DenseNet definition. Args: n_layer: Number of convolution layers in one dense block. If n_layer=12, the network is made out of 40 (12*3+4) layers. If n_layer=32, the network is made out of 100 (32*3+4) layers. growth_rate: Number of output feature maps of each convolution layer in dense blocks, which is difined as k in the paper. n_class: Output class. dropout_ratio: Dropout ratio. in_ch: Number of output feature maps of first convolution layer. block: Number of dense block. """ super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} with self.init_scope(): self.conv = L.Convolution2D(3, in_ch, 3, 1, 1, nobias=True, **kwargs) # self.forward = list() for i in range(block): name = 'dense{}'.format(i + 1) dense = BuildingDenseBlock(in_ch, growth_rate, n_layer, bottleneck=bottleneck, **kwargs) setattr(self, name, dense) # self.forward.append(dense) in_ch = in_ch + n_layer * growth_rate if not i == block - 1: name = 'trans{}'.format(i + 1) trans = Transition(in_ch, reduction=reduction, stride=stride[i], **kwargs) setattr(self, name, trans) # self.forward.append(trans) in_ch = math.floor(in_ch * reduction) self.bn = L.BatchNormalization(in_ch) self.fc = L.Linear(in_ch, n_class) self.functions = collections.OrderedDict([ ('conv1', [self.conv]), ('block2', [self.dense1]), ('trans2', [self.trans1]), ('block3', [self.dense2]), ('trans3', [self.trans2]), ('block4', [self.dense3]), ('pool4', [self.bn, F.relu, lambda x: F.average(x, axis=(2, 3))]), ('fc5', [self.fc]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __init__(self, n_class=36, pretrained_model=None): 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)} self.n_class = n_class super(CenterProposalNetworkRes50FCN, self).__init__( # resnet50 conv1=L.Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=L.BatchNormalization(64), res2=R.BuildingBlock(3, 64, 64, 256, 1, **kwargs), res3=R.BuildingBlock(4, 256, 128, 512, 2, **kwargs), res4=R.BuildingBlock(6, 512, 256, 1024, 2, **kwargs), res5=R.BuildingBlock(3, 1024, 512, 2048, 2, **kwargs), upscore32=L.Deconvolution2D(2048, 512, 8, stride=4, pad=2, use_cudnn=False), upscore16=L.Deconvolution2D(1024, 512, 4, stride=2, pad=1, use_cudnn=False), concat_conv=L.Convolution2D(512 * 3, 512 * 3, 3, stride=1, pad=1), score_pool=L.Convolution2D(512 * 3, n_class, 1, stride=1, pad=0), cls_pool=L.Convolution2D(512 * 3, 128, 1, stride=1, pad=0), upscore_final=L.Deconvolution2D(self.n_class, self.n_class, 16, stride=8, pad=4, use_cudnn=False), # depth network conv_d1_1=L.Convolution2D(1, 64, 3, stride=1, pad=1), bn_d1_1=L.BatchNormalization(64), conv_d1_2=L.Convolution2D(64, 64, 3, stride=1, pad=1), bn_d1_2=L.BatchNormalization(64), conv_d2=L.Convolution2D(64, 128, 3, stride=1, pad=1), bn_d2=L.BatchNormalization(128), conv_d3=L.Convolution2D(128, 256, 3, stride=1, pad=1), bn_d3=L.BatchNormalization(256), # center pose network conv_cp_1=L.Convolution2D(256 + 512 + 128, 1024, 3, stride=1, pad=1), bn_cp_1=L.BatchNormalization(1024), conv_cp_2=L.Convolution2D(1024, 1024, 3, stride=1, pad=1), bn_cp_2=L.BatchNormalization(1024), upscore_cp1=L.Deconvolution2D(1024, 512, 8, stride=4, pad=2, use_cudnn=False), bn_cp_3=L.BatchNormalization(512), upscore_cp2=L.Deconvolution2D(512, 3, 4, stride=2, pad=1, use_cudnn=False), # rotation network conv_rot_1=L.Convolution2D(256 + 512 + 128, 1024, 3, stride=1, pad=1), bn_rot_1=L.BatchNormalization(1024), conv_rot_2=L.Convolution2D(1024, 1024, 3, stride=1, pad=1), bn_rot_2=L.BatchNormalization(1024), upscore_rot1=L.Deconvolution2D(1024, 512, 8, stride=4, pad=2, use_cudnn=False), bn_rot_3=L.BatchNormalization(512), upscore_rot2=L.Deconvolution2D(512, 5, 4, stride=2, pad=1, use_cudnn=False), )
def __init__(self, n_layers, n_out, net_scale=1.0, splits_left=2, layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if n_layers == 50: block = [3, 4, 6, 3] elif n_layers == 164: block = [10, 10, 23, 10] else: raise ValueError('The n_layers argument should be either 50,' ' or 164, but {} was given.'.format(n_layers)) if net_scale == 0.5: out_channels = [24, 48, 96, 192, 1024] elif net_scale == 1.0: out_channels = [24, 116, 232, 464, 1024] elif net_scale == 1.5: out_channels = [24, 176, 352, 704, 1024] elif net_scale == 2.0: out_channels = [24, 244, 488, 976, 2048] else: raise ValueError('net_scale augment should be either 0.5, 1.0,' ' 1.5, or 2.0, but {} was given.'.format( net_scale)) with self.init_scope(): self.conv1 = L.Convolution2D(3, out_channels[0], 3, 2, 1, nobias=True, **kwargs) self.bn1 = L.BatchNormalization(out_channels[0]) self.res2 = BuildingShuffleNetV2Block(block[0], out_channels[0], out_channels[1], 2, splits_left, **kwargs) self.res3 = BuildingShuffleNetV2Block(block[1], out_channels[1], out_channels[2], 2, splits_left, **kwargs) self.res4 = BuildingShuffleNetV2Block(block[2], out_channels[2], out_channels[3], 2, splits_left, **kwargs) self.conv5 = L.Convolution2D(out_channels[3], out_channels[4], 1, 1, 0, nobias=True, **kwargs) self.bn5 = L.BatchNormalization(out_channels[4]) self.fc6 = L.Linear(out_channels[4], n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1, self.bn1, F.relu]), ('pool1', [lambda x: F.max_pooling_2d(x, ksize=3, stride=2)]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4]), ('conv5', [self.conv5, self.bn5, F.relu]), ('pool5', [lambda x: F.average(x, axis=(2, 3))]), ('fc6', [self.fc6]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names