def setUp(self): if self.activ == 'relu': activ = relu elif self.activ == 'add_one': activ = _add_one elif self.activ is None: activ = None self.x = np.random.uniform( -1, 1, (5, self.in_channels, 5, 5)).astype(np.float32) self.gy = np.random.uniform( -1, 1, (5, self.out_channels, 5, 5)).astype(np.float32) # Convolution is the identity function. initialW = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=np.float32).reshape((1, 1, 3, 3)) bn_kwargs = {'decay': 0.8} initial_bias = 0 if self.args_style == 'explicit': self.l = Conv2DBNActiv( self.in_channels, self.out_channels, self.ksize, self.stride, self.pad, self.dilate, initialW=initialW, initial_bias=initial_bias, activ=activ, bn_kwargs=bn_kwargs) elif self.args_style == 'None': self.l = Conv2DBNActiv( None, self.out_channels, self.ksize, self.stride, self.pad, self.dilate, initialW=initialW, initial_bias=initial_bias, activ=activ, bn_kwargs=bn_kwargs) elif self.args_style == 'omit': self.l = Conv2DBNActiv( self.out_channels, self.ksize, stride=self.stride, pad=self.pad, dilate=self.dilate, initialW=initialW, initial_bias=initial_bias, activ=activ, bn_kwargs=bn_kwargs)
def __init__(self, in_channels, mid_channels, out_channels, stride=1, dilate=1, groups=1, initialW=None, bn_kwargs={}, residual_conv=False, stride_first=False, add_seblock=False): if stride_first: first_stride = stride second_stride = 1 else: first_stride = 1 second_stride = stride super(Bottleneck, self).__init__() with self.init_scope(): self.conv1 = Conv2DBNActiv(in_channels, mid_channels, 1, first_stride, 0, nobias=True, initialW=initialW, bn_kwargs=bn_kwargs) # pad = dilate self.conv2 = Conv2DBNActiv(mid_channels, mid_channels, 3, second_stride, dilate, dilate, groups, nobias=True, initialW=initialW, bn_kwargs=bn_kwargs) self.conv3 = Conv2DBNActiv(mid_channels, out_channels, 1, 1, 0, nobias=True, initialW=initialW, activ=None, bn_kwargs=bn_kwargs) if add_seblock: self.se = SEBlock(out_channels) if residual_conv: self.residual_conv = Conv2DBNActiv(in_channels, out_channels, 1, stride, 0, nobias=True, initialW=initialW, activ=None, bn_kwargs=bn_kwargs)
def __init__(self, in_channels, mid_channels, out_channels, ksize=3, hidden_ksize=5): bn_kwargs = {'eps': 1e-5} super(DepthwiseXCorr, self).__init__() with self.init_scope(): self.conv_kernel = Conv2DBNActiv(in_channels, mid_channels, ksize=ksize, bn_kwargs=bn_kwargs) self.conv_search = Conv2DBNActiv(in_channels, mid_channels, ksize=ksize, bn_kwargs=bn_kwargs) self.conv_head1 = Conv2DBNActiv(mid_channels, mid_channels, ksize=1, bn_kwargs=bn_kwargs) self.conv_head2 = L.Convolution2D(mid_channels, out_channels, ksize=1, nobias=False)
def __init__(self, n_layer, pretrained_model=None, initialW=None): n_block = self._blocks[n_layer] _, path = utils.prepare_pretrained_model({}, pretrained_model, self._models[n_layer]) super(DilatedResNet, self).__init__() with self.init_scope(): self.conv1_1 = Conv2DBNActiv(None, 64, 3, 2, 1, 1, initialW=initialW) self.conv1_2 = Conv2DBNActiv(64, 64, 3, 1, 1, 1, initialW=initialW) self.conv1_3 = Conv2DBNActiv(64, 128, 3, 1, 1, 1, initialW=initialW) self.pool1 = lambda x: F.max_pooling_2d( x, ksize=3, stride=2, pad=1) self.res2 = ResBlock(n_block[0], 128, 64, 256, 1, 1, initialW=initialW, stride_first=False) self.res3 = ResBlock(n_block[1], 256, 128, 512, 2, 1, initialW=initialW, stride_first=False) self.res4 = ResBlock(n_block[2], 512, 256, 1024, 1, 2, initialW=initialW, stride_first=False) self.res5 = ResBlock(n_block[3], 1024, 512, 2048, 1, 4, initialW=initialW, stride_first=False) if path: chainer.serializers.load_npz(path, self, ignore_names=None)
def __init__(self, in_channels, feat_size, pyramids, initialW=None): out_channels = in_channels // len(pyramids) super(PyramidPoolingModule, self).__init__( Conv2DBNActiv(in_channels, out_channels, 1, 1, 0, 1, initialW=initialW), Conv2DBNActiv(in_channels, out_channels, 1, 1, 0, 1, initialW=initialW), Conv2DBNActiv(in_channels, out_channels, 1, 1, 0, 1, initialW=initialW), Conv2DBNActiv(in_channels, out_channels, 1, 1, 0, 1, initialW=initialW), ) kh = feat_size[0] // np.array(pyramids) kw = feat_size[1] // np.array(pyramids) self.ksizes = list(zip(kh, kw))
def __init__(self): super(Darknet53Extractor, self).__init__() # Darknet53 self.append(Conv2DBNActiv(32, 3, pad=1, activ=_leaky_relu)) for k, n_block in enumerate((1, 2, 8, 8, 4)): self.append( Conv2DBNActiv(32 << (k + 1), 3, stride=2, pad=1, activ=_leaky_relu)) for _ in range(n_block): self.append( ResidualBlock( Conv2DBNActiv(32 << k, 1, activ=_leaky_relu), Conv2DBNActiv(32 << (k + 1), 3, pad=1, activ=_leaky_relu))) # additional links for i, n in enumerate((512, 256, 128)): if i > 0: self.append(Conv2DBNActiv(n, 1, activ=_leaky_relu)) self.append(Conv2DBNActiv(n, 1, activ=_leaky_relu)) self.append(Conv2DBNActiv(n * 2, 3, pad=1, activ=_leaky_relu)) self.append(Conv2DBNActiv(n, 1, activ=_leaky_relu)) self.append(Conv2DBNActiv(n * 2, 3, pad=1, activ=_leaky_relu)) self.append(Conv2DBNActiv(n, 1, activ=_leaky_relu))
def __init__(self): super(DarknetExtractor, self).__init__() # Darknet for k in range(7): self.append(Conv2DBNActiv(16 << k, 3, pad=1, activ=_leaky_relu)) # additional link self.append(Conv2DBNActiv(1024, 3, pad=1, activ=_leaky_relu))
def __init__(self, bn_kwargs={}): super(Xception65, self).__init__() with self.init_scope(): self.entryflow_conv1 = Conv2DBNActiv(3, 32, 3, 2, 1, bn_kwargs=bn_kwargs) self.entryflow_conv2 = Conv2DBNActiv(32, 64, 3, 1, 1, bn_kwargs=bn_kwargs) self.entryflow_block1 = XceptionBlock(64, [128, 128, 128], stride=2, skip_type='conv', bn_kwargs=bn_kwargs) self.entryflow_block2 = XceptionBlock(128, [256, 256, 256], stride=2, skip_type='conv', bn_kwargs=bn_kwargs) self.entryflow_block3 = XceptionBlock(256, [728, 728, 728], stride=1, skip_type='conv', bn_kwargs=bn_kwargs) for i in range(1, 17): block = XceptionBlock(728, [728, 728, 728], stride=1, dilate=2, skip_type='sum', bn_kwargs=bn_kwargs) self.__setattr__('middleflow_block{}'.format(i), block) self.exitflow_block1 = XceptionBlock(728, [728, 1024, 1024], stride=1, dilate=2, skip_type='conv', bn_kwargs=bn_kwargs) self.exitflow_block2 = XceptionBlock( 1024, [1536, 1536, 2048], stride=1, dilate=4, skip_type='none', bn_kwargs=bn_kwargs, activ_first=False, dw_activ_list=[F.relu, F.relu, F.relu], pw_activ_list=[F.relu, F.relu, F.relu])
def __init__(self, n_classes, bc_learning=True, nobias=False, dr_ratio=0.5): super(ConvNet, self).__init__() self.dr_ratio = dr_ratio self.bc_learning = bc_learning if self.bc_learning: self.loss = kl_divergence else: self.loss = F.softmax_cross_entropy # architecture kwargs = {'ksize': 3, 'stride': 1, 'pad': 1, 'nobias': nobias} with self.init_scope(): self.conv1_1 = Conv2DBNActiv(3, 64, **kwargs) self.conv1_2 = Conv2DBNActiv(64, 64, **kwargs) self.conv2_1 = Conv2DBNActiv(64, 128, **kwargs) self.conv2_2 = Conv2DBNActiv(128, 128, **kwargs) self.conv3_1 = Conv2DBNActiv(128, 256, **kwargs) self.conv3_2 = Conv2DBNActiv(256, 256, **kwargs) self.conv3_3 = Conv2DBNActiv(256, 256, **kwargs) self.conv3_4 = Conv2DBNActiv(256, 256, **kwargs) self.fc4 = L.Linear(1024, initialW=Uniform(1. / math.sqrt(256 * 4 * 4))) self.fc5 = L.Linear(1024, initialW=Uniform(1. / math.sqrt(1024))) self.fc6 = L.Linear(n_classes, initialW=Uniform(1. / math.sqrt(1024)))
def __init__(self, in_channels, out_channels, dilate_list=(12, 24, 36), bn_kwargs={}): super(SeparableASPP, self).__init__() with self.init_scope(): self.image_pooling_conv = Conv2DBNActiv(in_channels, out_channels, 1, bn_kwargs=bn_kwargs) self.conv1x1 = Conv2DBNActiv(in_channels, out_channels, 1, bn_kwargs=bn_kwargs) self.atrous1 = SeparableConv2DBNActiv(in_channels, out_channels, 3, 1, dilate_list[0], dilate_list[0], nobias=True, dw_activ=F.relu, pw_activ=F.relu, bn_kwargs=bn_kwargs) self.atrous2 = SeparableConv2DBNActiv(in_channels, out_channels, 3, 1, dilate_list[1], dilate_list[1], nobias=True, dw_activ=F.relu, pw_activ=F.relu, bn_kwargs=bn_kwargs) self.atrous3 = SeparableConv2DBNActiv(in_channels, out_channels, 3, 1, dilate_list[2], dilate_list[2], nobias=True, dw_activ=F.relu, pw_activ=F.relu, bn_kwargs=bn_kwargs) self.proj = Conv2DBNActiv(out_channels * 5, out_channels, 1, bn_kwargs=bn_kwargs)
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, 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)
def __init__(self, n_layer, n_class=None, pretrained_model=None, mean=None, initialW=None, fc_kwargs={}): blocks = self._blocks[n_layer] self.mean = 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) kwargs = { 'groups': 32, 'initialW': initialW, 'stride_first': False, 'add_seblock': True} super(SEResNeXt, self).__init__() with self.init_scope(): self.conv1 = Conv2DBNActiv(None, 64, 3, 1, 1, nobias=True, initialW=initialW) self.res2 = ResBlock(blocks[0], None, 128, 256, 2, **kwargs) self.res3 = ResBlock(blocks[1], None, 256, 512, 1, **kwargs) self.res4 = ResBlock(blocks[2], None, 512, 1024, 2, **kwargs) self.res5 = ResBlock(blocks[3], None, 1024, 2048, 1, **kwargs) self.pool5 = lambda x: F.average(x, axis=(2, 3)) self.fc6 = L.Linear(None, n_class, **fc_kwargs)
def __init__(self, extractor, n_class, input_size, initialW=None, bn_kwargs=None): super(PSPNet, self).__init__() pyramids = [6, 3, 2, 1] if not isinstance(input_size, (list, tuple)): input_size = (int(input_size), int(input_size)) self.scales = None self.mean = np.array([123.68, 116.779, 103.939], dtype=np.float32)[:, None, None] self.input_size = input_size feat_size = (input_size[0] // 8, input_size[1] // 8) with self.init_scope(): self.extractor = extractor self.ppm = PyramidPoolingModule(2048, feat_size, pyramids, initialW=initialW, bn_kwargs=bn_kwargs) self.head_conv1 = Conv2DBNActiv(4096, 512, 3, 1, 1, initialW=initialW) self.head_conv2 = L.Convolution2D(512, n_class, 1, 1, 0, False, initialW)
def __init__(self, initialW=None): super(ResNet101Extractor, self).__init__() if initialW is None: initialW = chainer.initializers.HeNormal() kwargs = { 'initialW': initialW, 'bn_kwargs': { 'eps': 1e-5 }, 'stride_first': True } with self.init_scope(): # ResNet self.conv1 = Conv2DBNActiv(3, 64, 7, 2, 3, nobias=True, initialW=initialW) self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2) self.res2 = ResBlock(3, 64, 64, 256, 1, **kwargs) self.res3 = ResBlock(4, 256, 128, 512, 2, **kwargs) self.res4 = ResBlock(23, 512, 256, 1024, 2, **kwargs) self.res5 = ResBlock(3, 1024, 512, 2048, 1, 2, **kwargs)
def __init__(self, n_fg_class=None, pretrained_model=None): super(YOLOv3, self).__init__() param, path = utils.prepare_pretrained_model( {'n_fg_class': n_fg_class}, pretrained_model, self._models) self.n_fg_class = param['n_fg_class'] self.use_preset('visualize') with self.init_scope(): self.extractor = Darknet53Extractor() self.subnet = chainer.ChainList() for i, n in enumerate((512, 256, 128)): self.subnet.append(chainer.Sequential( Conv2DBNActiv(n * 2, 3, pad=1, activ=_leaky_relu), Convolution2D( len(self._anchors[i]) * (4 + 1 + self.n_fg_class), 1))) default_bbox = [] step = [] for k, grid in enumerate(self.extractor.grids): for v, u in itertools.product(range(grid), repeat=2): for h, w in self._anchors[k]: default_bbox.append((v, u, h, w)) step.append(self.insize / grid) self._default_bbox = np.array(default_bbox, dtype=np.float32) self._step = np.array(step, dtype=np.float32) if path: chainer.serializers.load_npz(path, self, strict=False)
def __init__(self, in_channels, mid_channels, out_channels, stride=1, initialW=None, residual_conv=False, stride_first=False): if stride_first: first_stride = stride second_stride = 1 else: first_stride = 1 second_stride = stride super(Bottleneck, self).__init__() with self.init_scope(): self.conv1 = Conv2DBNActiv(in_channels, mid_channels, 1, first_stride, 0, initialW=initialW, nobias=True) self.conv2 = Conv2DBNActiv(mid_channels, mid_channels, 3, second_stride, 1, initialW=initialW, nobias=True) self.conv3 = Conv2DBNActiv(mid_channels, out_channels, 1, 1, 0, initialW=initialW, nobias=True, activ=None) if residual_conv: self.residual_conv = Conv2DBNActiv(in_channels, out_channels, 1, stride, 0, nobias=True, initialW=initialW, activ=None)
def __init__(self, in_channels, out_channels): super(AdjustLayer, self).__init__() with self.init_scope(): self.conv = Conv2DBNActiv(in_channels, out_channels, ksize=1, bn_kwargs={'eps': 1e-5}, activ=None)
def __init__(self, model): initialW = chainer.initializers.HeNormal() super(TrainChain, self).__init__() with self.init_scope(): self.model = model self.aux_conv1 = Conv2DBNActiv( None, 512, 3, 1, 1, initialW=initialW) self.aux_conv2 = L.Convolution2D( None, model.n_class, 3, 1, 1, False, initialW=initialW)
def get_dilated_cbr(prev): new = Conv2DBNActiv(prev.conv.W.shape[1], prev.conv.W.shape[0], 3, 1, 2, 2, nobias=True) new.conv.W.data[:] = prev.conv.W.data[:] return new
def __init__(self, n_layer, n_class=None, pretrained_model=None, mean=None, initialW=None, fc_kwargs={}): blocks = self._blocks[n_layer] param, path = utils.prepare_pretrained_model( { 'n_class': n_class, 'mean': mean }, pretrained_model, self._models[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 = { 'groups': 32, 'initialW': initialW, 'stride_first': False, 'add_seblock': True } super(SEResNeXt, self).__init__() with self.init_scope(): self.conv1 = Conv2DBNActiv(None, 64, 7, 2, 3, nobias=True, initialW=initialW) self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2) self.res2 = ResBlock(blocks[0], None, 128, 256, 1, **kwargs) self.res3 = ResBlock(blocks[1], None, 256, 512, 2, **kwargs) self.res4 = ResBlock(blocks[2], None, 512, 1024, 2, **kwargs) self.res5 = ResBlock(blocks[3], None, 1024, 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)
def __init__(self, in_channels, depthlist, stride=1, dilate=1, skip_type='conv', activ_first=True, bn_kwargs={}, dw_activ_list=[None, None, None], pw_activ_list=[F.relu, F.relu, None]): super(XceptionBlock, self).__init__() self.skip_type = skip_type self.activ_first = activ_first self.separable2_activ = pw_activ_list[1] with self.init_scope(): self.separable1 = SeparableConv2DBNActiv(in_channels, depthlist[0], 3, 1, dilate, dilate, nobias=True, bn_kwargs=bn_kwargs, dw_activ=dw_activ_list[0], pw_activ=pw_activ_list[0]) self.separable2 = SeparableConv2DBNActiv(depthlist[0], depthlist[1], 3, 1, dilate, dilate, nobias=True, bn_kwargs=bn_kwargs, dw_activ=dw_activ_list[1], pw_activ=F.identity) self.separable3 = SeparableConv2DBNActiv(depthlist[1], depthlist[2], 3, stride, dilate, dilate, nobias=True, bn_kwargs=bn_kwargs, dw_activ=dw_activ_list[2], pw_activ=pw_activ_list[2]) if skip_type == 'conv': self.conv = Conv2DBNActiv(in_channels, depthlist[2], 1, activ=F.identity, nobias=True, stride=stride, bn_kwargs=bn_kwargs)
def __init__(self, in_channels, mid_channels, out_channels, stride=1, dilate=1, groups=1, initialW=None, bn_kwargs={}, residual_conv=False, stride_first=False, add_seblock=False): if stride_first: first_stride = stride second_stride = 1 else: first_stride = 1 second_stride = stride pad = 2 - stride # ? if residual_conv and dilate > 1: dilate = dilate // 2 pad = dilate if dilate > 1: pad = dilate super(Bottleneck, self).__init__() with self.init_scope(): self.conv1 = Conv2DBNActiv(in_channels, mid_channels, 1, first_stride, 0, nobias=True, initialW=initialW, bn_kwargs=bn_kwargs) self.conv2 = Conv2DBNActiv(mid_channels, mid_channels, 3, second_stride, pad, dilate, groups, nobias=True, initialW=initialW, bn_kwargs=bn_kwargs) self.conv3 = Conv2DBNActiv(mid_channels, out_channels, 1, 1, 0, nobias=True, initialW=initialW, bn_kwargs=bn_kwargs, activ=None) if add_seblock: self.se = SEBlock(out_channels) if residual_conv: if isinstance(residual_conv, chainer.Link): self.residual_conv = residual_conv else: self.residual_conv = Conv2DBNActiv( in_channels, out_channels, 1, stride, 0, nobias=True, initialW=initialW, activ=None, bn_kwargs=bn_kwargs)
def __init__(self, inplanes, scales=6, mingrid=1): super(TUM, self).__init__() self.scales = scales with self.init_scope(): ecs = [] for s in range(scales-1): if s == 0: conv = Conv2DBNActiv(inplanes, 256, 3, 2, pad=1, nobias=True) elif s == scales-2 and mingrid == 1: conv = Conv2DBNActiv(256, 256, 3, 2, nobias=True) else: conv = Conv2DBNActiv(256, 256, 3, 2, pad=1, nobias=True) ecs.append(conv) self.ecs = ChainList(*ecs) dcs = [] for s in range(scales): if s == scales-1: conv = Conv2DBNActiv(inplanes, 256, 3, pad=1, nobias=True) else: conv = Conv2DBNActiv(256, 256, 3, pad=1, nobias=True) dcs.append(conv) self.dcs = ChainList(*dcs) self.scs = ChainList(*[Conv2DBNActiv(256, 128, 1, nobias=True) for _ in range(scales)])
def __init__(self, genotype, init_C=36, n_class=10, n_layer=20, use_auxiliary=True, drop_path_prob=0.2): super(NetworkCIFAR, self).__init__() self._n_layer = n_layer self._use_auxiliary = use_auxiliary self.drop_path_prob = drop_path_prob bn_kwargs = {'eps': 1e-05} stem_multiplier = 3 curr_C = stem_multiplier * init_C with self.init_scope(): self.stem = Conv2DBNActiv(3, curr_C, 3, pad=1, activ=None, bn_kwargs=bn_kwargs) prev_prev_C, prev_C, curr_C = curr_C, curr_C, init_C self.cells = chainer.ChainList() is_prev_reduction = False with self.cells.init_scope(): for i in range(n_layer): if i in [n_layer // 3, 2 * n_layer // 3]: curr_C *= 2 is_reduction = True else: is_reduction = False cell = Cell(genotype, prev_prev_C, prev_C, curr_C, is_reduction, is_prev_reduction) is_prev_reduction = is_reduction self.cells.append(cell) prev_prev_C, prev_C = prev_C, cell.multiplier * curr_C if i == 2 * n_layer // 3: auxiliary_in_C = prev_C if use_auxiliary: self.auxiliary_head = AuxiliaryHeadCIFAR( auxiliary_in_C, n_class) self.classifier = L.Linear(prev_C, n_class)
def setUp(self): self.x = np.random.uniform( -1, 1, (5, self.in_channels, 5, 5)).astype(np.float32) self.gy = np.random.uniform( -1, 1, (5, self.out_channels, 5, 5)).astype(np.float32) # Convolution is the identity function. initialW = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=np.float32).reshape((1, 1, 3, 3)) bn_kwargs = {'decay': 0.8, 'comm': create_communicator('naive')} initial_bias = 0 activ = relu self.l = Conv2DBNActiv( self.in_channels, self.out_channels, self.ksize, self.stride, self.pad, self.dilate, initialW=initialW, initial_bias=initial_bias, activ=activ, bn_kwargs=bn_kwargs)
def test_transform(self): """ """ with chainer.using_config('dtype', chainer.mixed16): link = Conv2DBNActiv(3, 4, ksize=3, stride=2, pad=1) x = chainer.Variable( np.random.normal(size=(1, 3, 4, 4)).astype('float16')) y1 = link(x) link_ = AdaLossTransformConv2DBNActiv()(link, CFG) y2 = loss_scaling(link_(x), 16.) self.assertTrue(np.allclose(y1.array, y2.array)) y2.grad = np.ones_like(y2.array, dtype='float16') y2.backward() self.assertTrue('loss_scale' in x.grad_var.__dict__) self.assertEqual(x.grad_var.__dict__['loss_scale'], 16 * 2)
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): super(Darknet19Extractor, self).__init__() # Darknet19 for k, n_conv in enumerate((1, 1, 3, 3, 5, 5)): for i in range(n_conv): if i % 2 == 0: self.append( Conv2DBNActiv(32 << k, 3, pad=1, activ=_leaky_relu)) else: self.append( Conv2DBNActiv(32 << (k - 1), 1, activ=_leaky_relu)) # additional links self.append(Conv2DBNActiv(1024, 3, pad=1, activ=_leaky_relu)) self.append(Conv2DBNActiv(1024, 3, pad=1, activ=_leaky_relu)) self.append(Conv2DBNActiv(64, 1, activ=_leaky_relu)) self.append(Conv2DBNActiv(1024, 3, pad=1, activ=_leaky_relu))
def __init__(self, n_layer, in_channels, mid_channels, out_channels, stride, dilate=1, groups=1, initialW=None, bn_kwargs={}, stride_first=False, add_seblock=False): if stride == 1 and dilate == 1: residual_conv = None else: ksize = 3 if dilate > 1: dd = dilate // 2 pad = dd else: dd = 1 pad = 0 residual_conv = Conv2DBNActiv(in_channels, out_channels, ksize, stride, pad, dilate=dd, nobias=True, initialW=initialW, activ=None, bn_kwargs=bn_kwargs) super(DilatedResBlock, self).__init__(n_layer, in_channels, mid_channels, out_channels, stride, dilate, groups, initialW, bn_kwargs, stride_first, residual_conv, add_seblock)