def create_initializer(init_type, scale=None, fillvalue=None):
if init_type == 'identity':
return initializers.Identity() if scale is None else initializers.Identity(scale=scale)
if init_type == 'constant':
return initializers.Constant(fillvalue)
if init_type == 'zero':
return initializers.Zero()
if init_type == 'one':
return initializers.One()
if init_type == 'normal':
return initializers.Normal() if scale is None else initializers.Normal(scale)
if init_type == 'glorotNormal':
return initializers.GlorotNormal() if scale is None else initializers.GlorotNormal(scale)
if init_type == 'heNormal':
return initializers.HeNormal() if scale is None else initializers.HeNormal(scale)
if init_type == 'orthogonal':
return initializers.Orthogonal(
scale) if scale is None else initializers.Orthogonal(scale)
if init_type == 'uniform':
return initializers.Uniform(
scale) if scale is None else initializers.Uniform(scale)
if init_type == 'leCunUniform':
return initializers.LeCunUniform(
scale) if scale is None else initializers.LeCunUniform(scale)
if init_type == 'glorotUniform':
return initializers.GlorotUniform(
scale) if scale is None else initializers.GlorotUniform(scale)
if init_type == 'heUniform':
return initializers.HeUniform(
scale) if scale is None else initializers.HeUniform(scale)
raise ValueError("Unknown initializer type: {0}".format(init_type))
def __init__(self,
n_class,
aspect_ratios,
initialW=None,
initial_bias=None):
super(Multibox, self).__init__()
self.n_class = n_class
self.aspect_ratios = aspect_ratios
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
with self.init_scope():
# with chainer.using_config('dtype', 'float32'):
for i, ar in enumerate(aspect_ratios):
n = (len(ar) + 1) * 2
loc_name = 'loc_{}'.format(i)
conf_name = 'conf_{}'.format(i)
setattr(self, loc_name, L.Convolution2D(n * 4,
3,
pad=1,
**init))
setattr(self, conf_name,
L.Convolution2D(n * self.n_class, 3, pad=1, **init))
self.concat_locs = lambda xs: F.concat(xs, axis=1)
self.concat_confs = lambda xs: F.concat(xs, axis=1)
self.post_loc = lambda x: post_loc(x)
self.post_conf = lambda x: post_conf(x, self.n_class)
def __init__(self,
n_class,
aspect_ratios,
initialW=None,
initial_bias=None):
self.n_class = n_class
self.aspect_ratios = aspect_ratios
super(MultiboxWithTCB, self).__init__()
with self.init_scope():
self.arm_loc = chainer.ChainList()
self.arm_conf = chainer.ChainList()
self.tcb = chainer.ChainList()
self.odm_loc = chainer.ChainList()
self.odm_conf = chainer.ChainList()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for i in range(3):
self.tcb.add_link(TransferConnection(**init))
self.tcb.add_link(TransferConnectionEnd(**init))
for ar in aspect_ratios:
n = (len(ar) + 1) * 2 - 1
self.arm_loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.arm_conf.add_link(L.Convolution2D(n, 3, pad=1, **init))
self.odm_loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.odm_conf.add_link(
L.Convolution2D(n * self.n_class, 3, pad=1, **init))
def __init__(self,
n_class,
aspect_ratios,
initialW=None,
initial_bias=None):
self.n_class = n_class
self.aspect_ratios = aspect_ratios
super(ExtendedMultibox, self).__init__()
with self.init_scope():
self.extconv = chainer.ChainList()
self.loc = chainer.ChainList()
self.conf = chainer.ChainList()
self.ext = chainer.ChainList()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for i in range(3):
self.ext.add_link(ExtensionModule(i == 1, **init))
for ar in aspect_ratios:
n = (len(ar) + 1) * 2
self.extconv.add_link(ExtendedConv(**init))
self.loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.conf.add_link(
L.Convolution2D(n * self.n_class, 3, pad=1, **init))
def __init__(self,
n_class,
aspect_ratios,
initialW=None,
initial_bias=None):
self.n_class = n_class
self.aspect_ratios = aspect_ratios
super(ResidualMultibox, self).__init__()
with self.init_scope():
self.res = chainer.ChainList()
self.loc = chainer.ChainList()
self.conf = chainer.ChainList()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for ar in aspect_ratios:
n = (len(ar) + 1) * 2
self.res.add_link(Residual(**init))
self.loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.conf.add_link(
L.Convolution2D(n * self.n_class, 3, pad=1, **init))
def __init__(self,
n_class,
aspect_ratios,
feature_channel,
initialW=None,
initial_bias=None):
self.n_class = n_class
self.aspect_ratios = aspect_ratios
self.feature_map_channel = feature_channel
super(Multibox, self).__init__()
with self.init_scope():
self.loc = chainer.ChainList()
self.conf = chainer.ChainList()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for ar, f_channel in zip(aspect_ratios, feature_channel):
#n = (len(ar) + 1) * 2
n = len(ar) + 1
self.loc.add_link(MB_module(f_channel, n * 4, 3))
self.conf.add_link(MB_module(f_channel, n * self.n_class, 3))
def __init__(self,
n_class,
aspect_ratios,
initialW=None,
initial_bias=None):
self.n_class = n_class
self.aspect_ratios = aspect_ratios
self._input_multiplier = 128
super().__init__()
with self.init_scope():
self.loc = chainer.ChainList()
self.features = chainer.ChainList()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for ar in aspect_ratios:
n = (len(ar) + 1) * 2
self.loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.features.add_link(
L.Convolution2D(n * self._input_multiplier, 3, pad=1, **init))
def __init__(self):
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
super(VGG16Extractor320, self).__init__()
with self.init_scope():
self.conv6_1 = L.Convolution2D(256, 1, **init)
self.conv6_2 = L.Convolution2D(512, 3, stride=2, pad=1, **init)
def __init__(self,
in_size,
out_size=None,
nobias=False,
initial_mu=None,
initial_sigma=None,
factorized=False):
super().__init__()
if out_size is None:
in_size, out_size = None, in_size
self.out_size = out_size
self.factorized = factorized
if initial_mu is None:
if self.factorized:
initial_mu = initializers.LeCunUniform(scale=np.sqrt(1 / 3))
else:
initial_mu = initializers.LeCunUniform(scale=1.0)
if initial_sigma is None:
if self.factorized:
initial_sigma = FanConstant(scale=0.5)
else:
initial_sigma = 0.017
with self.init_scope():
mu_initializer = initializers._get_initializer(initial_mu)
sigma_initializer = initializers._get_initializer(initial_sigma)
self.mu_w = variable.Parameter(mu_initializer)
self.sigma_w = variable.Parameter(sigma_initializer)
if nobias:
self.mu_b = None
self.sigma_b = None
else:
# `LeCunUniform` does not allow one-dim size initialization
self.mu_b = variable.Parameter(mu_initializer, (1, out_size))
self.sigma_b = variable.Parameter(sigma_initializer, out_size)
if in_size is not None:
self._initialize_params(in_size)
def __init__(self, obs_size, num_actions, nhidden):
"""Initialize weights"""
# use LeCunUniform weight initialization for weights
self.initializer = initializers.LeCunUniform()
self.bias_initializer = initializers.Uniform(1e-4)
super(QNetwork, self).__init__(
feature_layer = L.Linear(obs_size, nhidden,
initialW = self.initializer,
initial_bias = self.bias_initializer),
action_values = L.Linear(nhidden, num_actions,
initialW=self.initializer,
initial_bias = self.bias_initializer)
)
def __init__(self, n_channel):
super(Extractor, self).__init__()
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
with self.init_scope():
self.conv1_1 = L.Convolution2D(n_channel, 3, pad=1, **init)
self.conv1_2 = L.Convolution2D(n_channel, 3, pad=1, **init)
self.conv2_1 = L.Convolution2D(n_channel*2, 3, pad=1, **init)
self.conv2_2 = L.Convolution2D(n_channel*2, 3, pad=1, **init)
self.conv3_1 = L.DilatedConvolution2D(n_channel*4, 3, pad=1, dilate=2, **init)
self.conv3_2 = L.DilatedConvolution2D(n_channel*4, 3, pad=1, dilate=2, **init)
self.conv4_1 = L.Convolution2D(n_channel*8, 3, pad=1, **init)
self.conv4_2 = L.Convolution2D(n_channel*8, 3, pad=1, **init)
def __init__(self,
n_class,
aspect_ratios,
initialW=initializers.LeCunUniform(),
initial_bias=initializers.Zero()):
self.n_class = n_class
super(Multibox, self).__init__()
with self.init_scope():
self.loc = chainer.ChainList()
self.conf = chainer.ChainList()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for ar in aspect_ratios:
n = len(ar) * 2 + 1
self.loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.conf.add_link(
L.Convolution2D(n * self.n_class, 3, pad=1, **init))
def __init__(self,
n_class,
aspect_ratios,
initialW=None,
initial_bias=None):
self.n_class = n_class
self.aspect_ratios = aspect_ratios
super(DeconvolutionalResidualMultibox, self).__init__()
with self.init_scope():
self.res = chainer.ChainList()
self.loc = chainer.ChainList()
self.conf = chainer.ChainList()
self.dec = chainer.ChainList()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
for ar in reversed(aspect_ratios):
n = (len(ar) + 1) * 2
self.res.add_link(Residual(**init))
self.loc.add_link(L.Convolution2D(n * 4, 3, pad=1, **init))
self.conf.add_link(
L.Convolution2D(n * self.n_class, 3, pad=1, **init))
for i in range(len(aspect_ratios) - 1):
if i == 0:
dec_ksize, con_ksize, dec_stride = 2, 2, 2
elif i == 1:
dec_ksize, con_ksize, dec_stride = 2, 2, 1
elif i == 2:
dec_ksize, con_ksize, dec_stride = 2, 3, 2
elif i == 3:
dec_ksize, con_ksize, dec_stride = 1, 3, 2
else:
dec_ksize, con_ksize, dec_stride = 2, 3, 2
out_channel = 512
self.dec.add_link(
DeconvolutionModule(out_channel, dec_ksize, con_ksize,
dec_stride, **init))
def __init__(self):
super().__init__()
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
with self.init_scope():
self.conv8_1 = L.Convolution2D(256, 1, **init)
self.relu8_1 = lambda x: F.relu(x)
self.conv8_2 = L.Convolution2D(512, 3, stride=2, pad=1, **init)
self.relu8_2 = lambda x: F.relu(x)
self.conv9_1 = L.Convolution2D(128, 1, **init)
self.relu9_1 = lambda x: F.relu(x)
self.conv9_2 = L.Convolution2D(256, 3, stride=2, pad=1, **init)
self.relu9_2 = lambda x: F.relu(x)
self.conv10_1 = L.Convolution2D(128, 1, **init)
self.relu10_1 = lambda x: F.relu(x)
self.conv10_2 = L.Convolution2D(256, 3, stride=2, pad=1, **init)
self.relu10_2 = lambda x: F.relu(x)
self.conv11_1 = L.Convolution2D(128, 1, **init)
self.relu11_1 = lambda x: F.relu(x)
self.conv11_2 = L.Convolution2D(256, 3, stride=2, pad=1, **init)
self.relu11_2 = lambda x: F.relu(x)
self.conv12_1 = L.Convolution2D(128, 1, **init)
self.relu12_1 = lambda x: F.relu(x)
self.conv12_2 = L.Convolution2D(256, 4, pad=1, **init)
self.relu12_2 = lambda x: F.relu(x)
self.pick = (
'relu4_3',
'relu7',
'relu8_2',
'relu9_2',
'relu10_2',
'relu11_2',
'relu12_2',
)
def __init__(self,
in_channels,
out_channels,
ksize,
stride=1,
pad=0,
wscale=1,
bias=0,
nobias=False,
use_cudnn=False,
initialW=None,
initial_bias=None):
super(Convolution2D, self).__init__()
self.ksize = ksize
self.stride = _pair(stride)
self.pad = _pair(pad)
self.use_cudnn = use_cudnn
self.out_channels = out_channels
self.initialW = initializers.LeCunUniform()
self.wscale = wscale
if in_channels is None:
self.add_uninitialized_param('W')
else:
self._initialize_params(in_channels)
kh, kw = _pair(self.ksize)
W_shape = (self.out_channels, in_channels, kh, kw)
#self.add_param('W', W_shape)
# For backward compatibility, the scale of weights is proportional to
# the square root of wscale.
initializers.init_weight(self.W.data,
self.initialW,
scale=math.sqrt(self.wscale))
if nobias:
self.b = None
else:
self.add_param('b', out_channels)
if initial_bias is None:
initial_bias = bias
initializers.init_weight(self.b.data, initial_bias)
def __init__(self):
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
super(VGG16Extractor512, self).__init__()
with self.init_scope():
self.conv8_1 = L.Convolution2D(256, 1, **init)
self.conv8_2 = L.Convolution2D(512, 3, stride=2, pad=1, **init)
self.conv9_1 = L.Convolution2D(128, 1, **init)
self.conv9_2 = L.Convolution2D(256, 3, stride=2, pad=1, **init)
self.conv10_1 = L.Convolution2D(128, 1, **init)
self.conv10_2 = L.Convolution2D(256, 3, stride=2, pad=1, **init)
self.conv11_1 = L.Convolution2D(128, 1, **init)
self.conv11_2 = L.Convolution2D(256, 3, stride=2, pad=1, **init)
self.conv12_1 = L.Convolution2D(128, 1, **init)
self.conv12_2 = L.Convolution2D(256, 4, pad=1, **init)
def __init__(self, in_channels, out_channels):
super(ResidualModule, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
out_channels_half = out_channels // 2
gamma_init = UniformRange()
conv_init = initializers.LeCunUniform(scale=1 / math.sqrt(3))
with self.init_scope():
# for skip layer
if in_channels != out_channels:
self.conv0 = L.Convolution2D(in_channels,
out_channels, (1, 1),
initialW=conv_init)
self.bn0 = L.BatchNormalization(out_channels,
eps=1e-5,
initial_gamma=gamma_init)
self.conv1 = L.Convolution2D(in_channels,
out_channels_half, (1, 1),
initialW=conv_init)
self.bn1 = L.BatchNormalization(out_channels_half,
eps=1e-5,
initial_gamma=gamma_init)
self.conv2 = L.Convolution2D(out_channels_half,
out_channels_half, (3, 3),
pad=1,
initialW=conv_init)
self.bn2 = L.BatchNormalization(out_channels_half,
eps=1e-5,
initial_gamma=gamma_init)
self.conv3 = L.Convolution2D(out_channels_half,
out_channels, (1, 1),
initialW=conv_init)
self.bn3 = L.BatchNormalization(out_channels,
eps=1e-5,
initial_gamma=gamma_init)
def __init__(self, detection=False, segmentation=False, attention=False):
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
super(Multi_task_VGG16Extractor512, self).__init__()
self.detection = detection
self.segmentation = segmentation
if segmentation and detection:
self.attention = attention
else:
self.attention = False
with self.init_scope():
if self.detection:
self.deconv_det_1 = L.Deconvolution2D(256,
256,
ksize=2,
stride=2,
pad=0,
outsize=(2, 2),
**init) ##
self.deconv_conv_det_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_2 = L.Deconvolution2D(256,
256,
ksize=3,
stride=1,
pad=0,
outsize=(4, 4),
**init) ##
self.deconv_conv_det_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_3 = L.Deconvolution2D(256,
256,
ksize=2,
stride=2,
pad=0,
outsize=(8, 8),
**init) ##
self.deconv_conv_det_3 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_3 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_4 = L.Deconvolution2D(256,
512,
ksize=1,
stride=2,
pad=0,
outsize=(16, 16),
**init) ##
self.deconv_conv_det_4 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_4 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_5 = L.Deconvolution2D(512,
1024,
ksize=2,
stride=2,
pad=0,
outsize=(32, 32),
**init)
self.deconv_conv_det_5 = L.Convolution2D(1024,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_5 = L.Convolution2D(1024,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_6 = L.Deconvolution2D(1024,
512,
ksize=2,
stride=2,
pad=0,
outsize=(64, 64),
**init)
self.deconv_conv_det_6 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init)
self.skip_conv_det_6 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init)
# conv after skip connection
if self.segmentation:
self.deconv_seg_1 = L.Deconvolution2D(256,
256,
ksize=2,
stride=2,
pad=0,
outsize=(2, 2),
**init) ##
self.deconv_conv_seg_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_2 = L.Deconvolution2D(256,
256,
ksize=3,
stride=1,
pad=0,
outsize=(4, 4),
**init) ##
self.deconv_conv_seg_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_3 = L.Deconvolution2D(256,
256,
ksize=2,
stride=2,
pad=0,
outsize=(8, 8),
**init) ##
self.deconv_conv_seg_3 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_3 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_4 = L.Deconvolution2D(256,
512,
ksize=1,
stride=2,
pad=0,
outsize=(16, 16),
**init) ##
self.deconv_conv_seg_4 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_4 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_5 = L.Deconvolution2D(512,
1024,
ksize=2,
stride=2,
pad=0,
outsize=(32, 32),
**init)
self.deconv_conv_seg_5 = L.Convolution2D(1024,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_5 = L.Convolution2D(1024,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_6 = L.Deconvolution2D(1024,
512,
ksize=2,
stride=2,
pad=0,
outsize=(64, 64),
**init)
self.deconv_conv_seg_6 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init)
self.skip_conv_seg_6 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init)
if self.attention:
# TODO: implementation of attention
self.attention_1 = AttentionModule(256)
self.attention_2 = AttentionModule(256)
self.attention_3 = AttentionModule(256)
self.attention_4 = AttentionModule(512)
self.attention_5 = AttentionModule(1024)
import unittest
from chainer import cuda
from chainer import initializers
from chainer import testing
from chainer.testing import attr
import numpy
@testing.parameterize({'initializer': initializers.Uniform(scale=0.1)},
{'initializer': initializers.LeCunUniform(scale=0.1)},
{'initializer': initializers.GlorotUniform(scale=0.1)},
{'initializer': initializers.HeUniform(scale=0.1)})
class TestUniform(unittest.TestCase):
shape = (2, 3, 4)
def check_initializer(self, w):
self.initializer(w)
self.assertTupleEqual(w.shape, self.shape)
self.assertEqual(w.dtype, numpy.float32)
xp = cuda.get_array_module(w)
self.assertIsInstance(w, xp.ndarray)
def test_initializer_cpu(self):
w = numpy.empty(self.shape, dtype=numpy.float32)
self.check_initializer(w)
@attr.gpu
def test_initializer_gpu(self):
w = cuda.cupy.empty(self.shape, dtype=numpy.float32)
def __init__(self, detection=False, segmentation=False, attention=False):
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
super(Multi_task_VGG16Extractor300, self).__init__()
self.detection = detection
self.segmentation = segmentation
if segmentation and detection:
self.attention = attention
else:
self.attention = False
with self.init_scope():
if self.detection:
self.deconv_det_1 = L.Deconvolution2D(256,
256,
ksize=3,
stride=1,
pad=0,
**init) ##
self.deconv_conv_det_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_2 = L.Deconvolution2D(256,
256,
ksize=3,
stride=1,
pad=0,
**init) ##
self.deconv_conv_det_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_3 = L.Deconvolution2D(256,
256,
ksize=4,
stride=2,
pad=1,
**init) ##
self.deconv_conv_det_3 = L.Convolution2D(256,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_3 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_4 = L.Deconvolution2D(512,
256,
ksize=3,
stride=2,
pad=1,
**init) ##
self.deconv_conv_det_4 = L.Convolution2D(256,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_4 = L.Convolution2D(1024,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_det_5 = L.Deconvolution2D(1024,
256,
ksize=4,
stride=2,
pad=1,
**init)
self.deconv_conv_det_5 = L.Convolution2D(256,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_det_5 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
# conv after skip connection
if self.segmentation:
self.deconv_seg_1 = L.Deconvolution2D(256,
256,
ksize=3,
stride=1,
pad=0,
**init) ## 3*3
self.deconv_conv_seg_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_1 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_2 = L.Deconvolution2D(256,
256,
ksize=3,
stride=1,
pad=0,
**init) ## 5*5
self.deconv_conv_seg_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_2 = L.Convolution2D(256,
256,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_3 = L.Deconvolution2D(256,
256,
ksize=4,
stride=2,
pad=1,
**init) ## 10*10
self.deconv_conv_seg_3 = L.Convolution2D(256,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_3 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_4 = L.Deconvolution2D(512,
256,
ksize=3,
stride=2,
pad=1,
**init) ## 19*19
self.deconv_conv_seg_4 = L.Convolution2D(256,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_4 = L.Convolution2D(1024,
1024,
ksize=3,
stride=1,
pad=1,
**init) #
self.deconv_seg_5 = L.Deconvolution2D(1024,
256,
ksize=4,
stride=2,
pad=1,
**init) ## 38*38
self.deconv_conv_seg_5 = L.Convolution2D(256,
512,
ksize=3,
stride=1,
pad=1,
**init) #
self.skip_conv_seg_5 = L.Convolution2D(512,
512,
ksize=3,
stride=1,
pad=1,
**init) #
if self.attention:
# TODO: implementation of attention
self.attention_1 = AttentionModule(256)
self.attention_2 = AttentionModule(256)
self.attention_3 = AttentionModule(512)
self.attention_4 = AttentionModule(1024)
def __init__(self, out_channels):
super(StackedHG, self).__init__()
gamma_init = UniformRange()
conv_init = initializers.LeCunUniform(scale=1 / math.sqrt(3))
with self.init_scope():
self.conv0 = L.Convolution2D(3,
64,
ksize=(7, 7),
stride=2,
pad=3,
initialW=conv_init)
self.bn0 = L.BatchNormalization(64,
eps=1e-5,
initial_gamma=gamma_init)
self.res0 = ResidualModule(64, 128)
self.res1_1 = ResidualModule(128, 128)
self.res1_2 = ResidualModule(128, 128)
self.res1_3 = ResidualModule(128, 256)
self.hg1 = HGBlock(256, 512)
self.conv1_1 = L.Convolution2D(512,
512, (1, 1),
initialW=conv_init)
self.bn1_1 = L.BatchNormalization(512,
eps=1e-5,
initial_gamma=gamma_init)
self.conv1_2 = L.Convolution2D(512,
256, (1, 1),
initialW=conv_init)
self.bn1_2 = L.BatchNormalization(256,
eps=1e-5,
initial_gamma=gamma_init)
self.conv1_3a = L.Convolution2D(256,
out_channels, (1, 1),
initialW=conv_init)
self.conv1_4a = L.Convolution2D(out_channels,
256 + 128, (1, 1),
initialW=conv_init)
self.conv1_3b = L.Convolution2D(256 + 128,
256 + 128, (1, 1),
initialW=conv_init)
self.hg2 = HGBlock(256 + 128, 512)
self.conv2_1 = L.Convolution2D(512,
512, (1, 1),
initialW=conv_init)
self.bn2_1 = L.BatchNormalization(512,
eps=1e-5,
initial_gamma=gamma_init)
self.conv2_2 = L.Convolution2D(512,
512, (1, 1),
initialW=conv_init)
self.bn2_2 = L.BatchNormalization(512,
eps=1e-5,
initial_gamma=gamma_init)
self.conv2_3a = L.Convolution2D(512,
out_channels, (1, 1),
initialW=conv_init)
def __init__(self, n_class, scale_num, initialW=None, initial_bias=None):
self.n_class = n_class
self.scale_num = scale_num
super(Multimask, self).__init__()
if initialW is None:
initialW = initializers.LeCunUniform()
if initial_bias is None:
initial_bias = initializers.Zero()
init = {'initialW': initialW, 'initial_bias': initial_bias}
with self.init_scope():
self.score = chainer.ChainList()
self.upscore = chainer.ChainList()
# self.final_score = L.Deconvolution2D(n_class, 4, stride=8, pad=0, nobias=True)
self.final_mask = L.Convolution2D(n_class,
3,
pad=1,
stride=1,
**init)
for i in range(scale_num):
self.score.add_link(L.Convolution2D(n_class, 3, pad=1))
# self.batch_norms.add_link(L.BatchNormalization(axis=0))
if scale_num == 6:
self.upscore.add_link(
L.Deconvolution2D(n_class,
3,
stride=1,
pad=0,
nobias=True,
initialW=initialW))
self.upscore.add_link(
L.Deconvolution2D(n_class,
3,
stride=1,
pad=0,
nobias=True,
initialW=initialW))
self.upscore.add_link(
L.Deconvolution2D(n_class,
2,
stride=2,
pad=0,
nobias=True,
initialW=initialW))
self.upscore.add_link(
L.Deconvolution2D(n_class,
1,
stride=2,
pad=0,
nobias=True,
initialW=initialW))
self.upscore.add_link(
L.Deconvolution2D(n_class,
2,
stride=2,
pad=0,
nobias=True,
initialW=initialW))
elif scale_num == 7:
for i in range(scale_num - 1):
self.upscore.add_link(
L.Deconvolution2D(n_class,
2,
stride=2,
pad=0,
nobias=True,
initialW=initialW))
