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)
