def __init__(self, in_ch, ch_multi, sample):
super().__init__()
with self.init_scope():
if sample == 'down':
self.dc = L.DepthwiseConvolution2D(in_ch,
ch_multi,
ksize=4,
stride=2,
pad=1)
self.ac = F.leaky_relu
elif sample == 'up':
self.dc = L.Deconvolution2D(in_ch,
in_ch * ch_multi,
ksize=4,
stride=2,
pad=1)
self.ac = F.relu
else:
self.dc = L.DepthwiseConvolution2D(in_ch,
ch_multi,
ksize=3,
stride=1,
pad=1)
self.ac = None
self.bn = L.BatchNormalization(in_ch * ch_multi)
def __init__(self,
in_channels,
out_channels,
ksize=None,
xception=False,
down_sample=False):
super(ShuffleUnit, self).__init__()
self.xception = xception
self.down_sample = down_sample
mid_channels = out_channels // 2
with self.init_scope():
if down_sample:
self.downsize_depthwise = L.DepthwiseConvolution2D(
in_channels,
channel_multiplier=1,
ksize=ksize,
stride=2,
pad=ksize // 2)
self.downsize_depthwise_bn = L.BatchNormalization(
size=in_channels)
self.downsize_pointwise = Conv2DBNActiv(mid_channels, 1)
if xception:
self.separable_conv1 = SeparableConv2DBNActiv(
in_channels=(in_channels if down_sample else mid_channels),
out_channels=mid_channels,
ksize=ksize,
pad=ksize // 2,
stride=(2 if self.down_sample else 1))
self.separable_conv2 = SeparableConv2DBNActiv(
in_channels=mid_channels,
out_channels=mid_channels,
ksize=ksize,
pad=ksize // 2)
self.separable_conv3 = SeparableConv2DBNActiv(
in_channels=mid_channels,
out_channels=mid_channels,
ksize=ksize,
pad=ksize // 2)
else:
self.compress = Conv2DBNActiv(mid_channels, 1)
self.depthwise = L.DepthwiseConvolution2D(
mid_channels,
channel_multiplier=1,
ksize=ksize,
pad=ksize // 2,
stride=(2 if self.down_sample else 1))
self.depthwise_bn = L.BatchNormalization(size=mid_channels)
self.expand = Conv2DBNActiv(mid_channels, 1)
def __init__(self,
in_channels,
out_channels,
ksize=3,
stride=1,
relu=True):
super(SeparableConv, self).__init__()
self.relu = relu
self.ksize = ksize
self.stride = stride
with self.init_scope():
self.depthwise_conv = L.DepthwiseConvolution2D(
in_channels=in_channels,
channel_multiplier=1,
ksize=ksize,
pad=ksize // 2,
stride=stride,
nobias=True)
self.pointwise_conv = L.Convolution2D(in_channels,
out_channels,
ksize=1,
nobias=True)
self.pointwise_bn = L.BatchNormalization(out_channels,
eps=0.001,
use_gamma=False)
def __init__(self, inp, oup, stride):
super(ConvDW, self).__init__()
with self.init_scope():
self.conv_dw=L.DepthwiseConvolution2D(inp, 1, 3, stride=stride, pad=1, nobias=True)
self.bn_dw=L.BatchNormalization(inp)
self.conv_sep=L.Convolution2D(inp, oup, 1, stride=1, pad=0, nobias=True)
self.bn_sep=L.BatchNormalization(oup)
def __init__(self, in_channels, out_channels, num_groups):
bottleneck_channels = int((out_channels) / 4)
super().__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(in_channels,
bottleneck_channels,
ksize=1,
stride=1,
pad=0,
groups=num_groups)
self.bn1 = L.BatchNormalization(bottleneck_channels)
self.conv2 = L.DepthwiseConvolution2D(bottleneck_channels,
1,
ksize=3,
stride=2,
pad=1)
self.bn2 = L.BatchNormalization(bottleneck_channels)
self.conv3 = L.Convolution2D(bottleneck_channels,
out_channels - in_channels,
ksize=1,
stride=1,
pad=0,
groups=num_groups)
self.bn3 = L.BatchNormalization(out_channels - in_channels)
self.num_groups = num_groups
def __init__(self, expand_input, in_ch, out_ch, stride):
super(ExpandedConv, self).__init__()
if expand_input == 1:
expander = expand_input_by_factor(expand_input, 1)
else:
expander = expand_input_by_factor(expand_input, 8)
self.in_ch, self.out_ch = in_ch, out_ch
expanded_ch = expander(in_ch)
self.stride = stride
with self.init_scope():
self.expand_conv = L.Convolution2D(in_ch,
expanded_ch,
ksize=1,
nobias=True)
self.expand_bn = L.BatchNormalization(expanded_ch)
self.depthwise_conv = L.DepthwiseConvolution2D(
expanded_ch,
channel_multiplier=1,
ksize=3,
stride=self.stride,
pad=1,
nobias=True)
self.depthwise_bn = L.BatchNormalization(expanded_ch)
self.project_conv = L.Convolution2D(expanded_ch,
out_ch,
ksize=1,
nobias=True)
self.project_bn = L.BatchNormalization(out_ch)
def __init__(self, n_units=128):
super(MobileNetsModule, self).__init__()
with self.init_scope():
self.dw = L.DepthwiseConvolution2D(None, 1, ksize=3, pad=1)
self.bn1 = L.BatchNormalization(n_units)
self.pw = L.Convolution2D(None, n_units, ksize=1)
self.bn2 = L.BatchNormalization(n_units)
def __init__(self,
in_channels,
channel_multiplier,
ksize=None,
stride=1,
pad=0,
nobias=True,
initialW=None,
initial_bias=None,
activ=relu,
bn_kwargs={}):
self.activ = activ
#print(bn_kwargs)
super(DepthwiseConv2DBNActiv, self).__init__()
with self.init_scope():
self.conv = L.DepthwiseConvolution2D(in_channels,
channel_multiplier, ksize,
stride, pad, nobias, initialW,
initial_bias)
if 'comm' in bn_kwargs:
self.bn = MultiNodeBatchNormalization(
int(in_channels * channel_multiplier), **bn_kwargs)
else:
self.bn = BatchNormalization(
int(in_channels * channel_multiplier), **bn_kwargs)
def _3x3_dwconv_bn(stride):
"""3x3 DWConv (depthwise convolution) + BN.
"""
return Seq(dwconv=L.DepthwiseConvolution2D(None,
channel_multiplier=1,
ksize=3,
stride=stride,
pad=1,
nobias=True),
bn=BatchNormalization(axis=(0, 2, 3)))
def __init__(self, in_channels, out_channels,
stride=1, splits_left=2, initialW=None):
super(ShuffleNetV2Block, self).__init__()
with self.init_scope():
if stride == 2:
self.conv1 = L.Convolution2D(
in_channels, in_channels, 1, 1, 0, initialW=initialW,
nobias=True)
self.bn1 = L.BatchNormalization(in_channels)
self.conv2 = L.DepthwiseConvolution2D(
in_channels, 1, 3, 1, 1,
initialW=initialW, nobias=True)
self.bn2 = L.BatchNormalization(in_channels)
self.conv3 = L.Convolution2D(
in_channels, out_channels // 2, 1, 1, 0, initialW=initialW,
nobias=True)
self.bn3 = L.BatchNormalization(out_channels // 2)
self.conv4 = L.DepthwiseConvolution2D(
in_channels, 1, 3, 1, 1,
initialW=initialW, nobias=True)
self.bn4 = L.BatchNormalization(in_channels)
self.conv5 = L.Convolution2D(
in_channels, out_channels // 2, 1, 1, 0, initialW=initialW,
nobias=True)
self.bn5 = L.BatchNormalization(out_channels // 2)
elif stride == 1:
self.in_channels = in_channels - in_channels // splits_left
self.conv1 = L.Convolution2D(
self.in_channels, self.in_channels, 1, 1, 0,
initialW=initialW, nobias=True)
self.bn1 = L.BatchNormalization(self.in_channels)
self.conv2 = L.DepthwiseConvolution2D(
self.in_channels, 1, 3, stride, 1,
initialW=initialW, nobias=True)
self.bn2 = L.BatchNormalization(self.in_channels)
self.conv3 = L.Convolution2D(
self.in_channels, self.in_channels, 1, 1, 0,
initialW=initialW, nobias=True)
self.bn3 = L.BatchNormalization(self.in_channels)
self.stride = stride
self.splits_left = splits_left
def setUp(self):
in_channels = None
self.link = links.DepthwiseConvolution2D(in_channels, 2, 3,
stride=2, pad=1)
self.x = numpy.random.uniform(-1, 1,
(2, 3, 4, 3)).astype(numpy.float32)
self.link(chainer.Variable(self.x))
b = self.link.b.data
b[...] = numpy.random.uniform(-1, 1, b.shape)
self.link.cleargrads()
self.gy = numpy.random.uniform(-1, 1,
(2, 6, 2, 2)).astype(numpy.float32)
def __init__(self, in_channels, out_channels, ksize=3, stride=1, initialW=None):
""" CTOR. """
super(DepthwiseSeparableConv2D, self).__init__()
with self.init_scope():
self.conv1 = L.DepthwiseConvolution2D(
in_channels, 1, ksize, stride=stride, pad=1, nobias=True, initialW=initialW)
self.bn1 = L.BatchNormalization(in_channels)
self.relu1 = lambda x: F.relu(x)
self.conv2 = L.Convolution2D(
in_channels, out_channels, ksize=1, stride=1, pad=0, nobias=True, initialW=initialW)
self.bn2 = L.BatchNormalization(out_channels)
self.relu2 = lambda x: F.relu(x)
def setUp(self):
self.link = links.DepthwiseConvolution2D(
3, 2, 3, stride=2, pad=1,
initialW=chainer.initializers.Normal(1, self.W_dtype),
initial_bias=chainer.initializers.Normal(1, self.x_dtype))
self.link.cleargrads()
self.x = numpy.random.uniform(-1, 1,
(2, 3, 4, 3)).astype(self.x_dtype)
self.gy = numpy.random.uniform(-1, 1,
(2, 6, 2, 2)).astype(self.x_dtype)
self.check_backward_options = {}
if self.x_dtype == numpy.float16 or self.W_dtype == numpy.float16:
self.check_backward_options = {'atol': 3e-2, 'rtol': 5e-2}
def __init__(self, in_channels, out_channels, ksize, **kwargs):
if 'pad' in kwargs:
pad = kwargs.pop('pad')
else:
pad = 0
super(SeparableConvolution2D,
self).__init__(depthwise=L.DepthwiseConvolution2D(in_channels,
1,
ksize,
pad=pad,
**kwargs),
pointwise=L.Convolution2D(in_channels,
out_channels, 1,
**kwargs))
def __init__(self, in_channels, out_channels, expansion_factor=6):
super().__init__()
with self.init_scope():
self.conv1 = ConvBN(in_channels, in_channels * expansion_factor)
self.dconv = L.DepthwiseConvolution2D(in_channels *
expansion_factor,
1,
ksize=3,
stride=2,
pad=1)
self.bn = L.BatchNormalization(in_channels * expansion_factor)
self.conv2 = L.Convolution2D(in_channels * expansion_factor,
out_channels,
ksize=1,
stride=1,
pad=0)
def __init__(self, in_dim, out_dim):
super(ConvBlock, self).__init__()
initialW = chainer.initializers.HeNormal(3)
with self.init_scope():
self.c1 = L.Convolution2D(in_dim,
out_dim,
3,
1,
1,
initialW=initialW)
self.c2 = L.DepthwiseConvolution2D(out_dim,
1,
3,
2,
1,
initialW=initialW)
def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0,
nobias=True, initialW=None, initial_bias=None,
activation_fn=F.relu, **kwargs):
self.activation_fn = activation_fn
self.ksize = ksize
self.stride = stride
super(TFDWSeparableConvBlock, self).__init__()
with self.init_scope():
self.dw = L.DepthwiseConvolution2D(in_channels, 1, ksize, stride, 0,
nobias, initialW, initial_bias)
self.dw_bn = L.BatchNormalization(in_channels, decay=0.9997,
eps=0.001)
self.pw = L.Convolution2D(in_channels, out_channels, 1, 1, 0,
nobias, initialW, initial_bias)
self.pw_bn = L.BatchNormalization(out_channels, decay=0.9997,
eps=0.001)
def __init__(self, in_c, out_c, stride):
super(dw_sep_conv, self).__init__()
with self.init_scope():
self.conv_dw = L.DepthwiseConvolution2D(in_c,
1,
3,
stride=stride,
pad=1,
nobias=True)
self.bn_dw = L.BatchNormalization(in_c)
self.conv_pw = L.Convolution2D(in_c,
out_c,
1,
stride=1,
pad=0,
nobias=True)
self.bn_pw = L.BatchNormalization(out_c)
def __init__(self, expand_ratio, in_channels, out_channels, stride):
super(ExpandedConv, self).__init__()
ksize = 3
self.dtype = np.float32
self.expand_ratio = expand_ratio
expanded_channels = int(in_channels * expand_ratio)
initialW = initializers.HeNormal(1 / np.sqrt(2), self.dtype)
with self.init_scope():
if expand_ratio != 1:
self.expand_conv = L.Convolution2D(in_channels,
expanded_channels,
ksize=1,
initialW=initialW,
nobias=True)
self.expand_bn = L.BatchNormalization(expanded_channels,
eps=0.001,
decay=0.997)
self.depthwise_conv = L.DepthwiseConvolution2D(
expanded_channels,
channel_multiplier=1,
ksize=ksize,
stride=stride,
pad=ksize // 2,
initialW=initialW,
nobias=True)
self.depthwise_bn = L.BatchNormalization(expanded_channels,
eps=0.001,
decay=0.9997)
self.project_conv = L.Convolution2D(expanded_channels,
out_channels,
ksize=1,
initialW=initialW,
nobias=True)
self.project_bn = L.BatchNormalization(out_channels,
eps=0.001,
decay=0.9997)
def __init__(self, inp, oup, stride, restype=None, activation=F.relu):
super(ConvDW, self).__init__()
self.restype = restype
self.stride = stride
self.activation = activation
if self.restype == 'concat':
self.oup = oup - inp
else:
self.oup = oup
with self.init_scope():
self.conv_dw = L.DepthwiseConvolution2D(inp,
1,
3,
stride=stride,
pad=1,
nobias=True)
self.bn_dw = L.BatchNormalization(inp)
self.conv_sep = L.Convolution2D(inp,
self.oup,
1,
stride=1,
pad=0,
nobias=True)
self.bn_sep = L.BatchNormalization(self.oup)
def __init__(self, in_channels, n_class, ksize):
super().__init__()
with self.init_scope():
self.dfg = FilterDictConv2d(in_channels, n_class,
ksize) # out:N_i*E*M
self.weight_target_node = \
L.DepthwiseConvolution2D(in_channels, ksize, 1) # out: D*M
# self.out_adjacent_node = \
# L.ConvolutionND(ksize, in_channels, in_channels, 1)
self.in_channels = in_channels
self.n_class = n_class
self.img_h, self.img_w = 28, 28
adjacent_matrix = {}
for r, c in itertools.product(range(28), range(28)):
if r == 0 and c == 0:
adjacent_matrix[r * self.img_w + c] = [
r * self.img_w + c + 1, (r + 1) * self.img_w + c + 1,
(r + 1) * self.img_w + c
]
elif r == 0 and c == 27:
adjacent_matrix[r * self.img_w + c] = [
r * self.img_w + c - 1, (r + 1)**self.img_w + c - 1,
(r + 1) * self.img_w + c
]
elif r == 0 and 0 < c < 27:
adjacent_matrix[r * self.img_w + c] = [
r * self.img_w + c - 1, r * self.img_w + c + 1,
(r + 1) * self.img_w + c - 1, (r + 1) * self.img_w + c,
(r + 1) * self.img_w + c + 1
]
elif r == 27 and c == 0:
adjacent_matrix[r * self.img_w + c] = [
r * self.img_w + c + 1, (r - 1) * self.img_w + c + 1,
(r - 1) * self.img_w + c
]
elif r == 27 and c == 27:
adjacent_matrix[r * self.img_w + c] = [
r * self.img_w + c - 1, (r - 1) * self.img_w + c - 1,
(r - 1) * self.img_w + c
]
elif r == 27 and 0 < c < 27:
adjacent_matrix[r * self.img_w + c] = [
r * self.img_w + c - 1, r * self.img_w + c + 1,
(r - 1) * self.img_w + c - 1, (r - 1) * self.img_w + c,
(r - 1) * self.img_w + c + 1
]
elif 0 < r < 27 and c == 0:
adjacent_matrix[r * self.img_w + c] = [
(r - 1) * self.img_w + c,
(r - 1) * self.img_w + c + 1, r * self.img_w + c + 1,
(r + 1) * self.img_w + c, (r + 1) * self.img_w + c + 1
]
elif 0 < r < 27 and c == 27:
adjacent_matrix[r * self.img_w + c] = [
(r - 1) * self.img_w + c,
(r - 1) * self.img_w + c - 1, r * self.img_w + c - 1,
(r + 1) * self.img_w + c, (r + 1) * self.img_w + c - 1
]
elif 0 < r < 27 and 0 < c < 27:
adjacent_matrix[r * self.img_w + c] = [
(r - 1) * self.img_w + c - 1, (r - 1) * self.img_w + c,
(r - 1) * self.img_w + c + 1, r * self.img_w + c - 1,
r * self.img_w + c + 1, (r + 1) * self.img_w + c - 1,
(r + 1) * self.img_w + c, (r + 1) * self.img_w + c + 1
]
self.adjacent_matrix = adjacent_matrix
def __init__(self, final_endpoint='Conv2d_13_pointwise_batchnorm', min_depth=8, depth_multiplier=1.0,
output_stride=None, use_explicit_padding=False):
super(MobileNet_v1_Base, self).__init__()
initialW = initializers.HeNormal()
self.depth = lambda d: max(int(d * depth_multiplier), min_depth)
if depth_multiplier <= 0:
raise ValueError('depth_multiplier is not greater than zero.')
if output_stride is not None and output_stride not in [8, 16, 32]:
raise ValueError('Only allowed output_stride values are 8, 16, 32.')
Conv = namedtuple('Conv', ['kernel', 'stride','inchannel', 'depth'])
DepthSepConv = namedtuple('DepthSepConv', ['kernel', 'inchannel', 'stride', 'depth'])
self.conv_defs = [
Conv(kernel=[3, 3], stride=2, inchannel=3, depth=32),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=32, depth=64),
DepthSepConv(kernel=[3, 3], stride=2, inchannel=64, depth=128),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=128,depth=128),
DepthSepConv(kernel=[3, 3], stride=2, inchannel=128, depth=256),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=256,depth=256),
DepthSepConv(kernel=[3, 3], stride=2, inchannel=256,depth=512),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=512,depth=512),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=512,depth=512),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=512,depth=512),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=512,depth=512),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=512,depth=512),
DepthSepConv(kernel=[3, 3], stride=2, inchannel=512, depth=1024),
DepthSepConv(kernel=[3, 3], stride=1, inchannel=1024, depth=1024),
]
self.scale_dict = {"Conv2d_11_pointwise_batchnorm" : "16_scale", "Conv2d_13_pointwise_batchnorm": "32_scale"}
self.padding = 'SAME'
pad = 1 # 3 x 3 conv kernal, with 1x1 padding
if use_explicit_padding:
self.padding = 'VALID'
pad = 0
with self.init_scope():
# The current_stride variable keeps track of the output stride of the
# activations, i.e., the running product of convolution strides up to the
# current network layer. This allows us to invoke atrous convolution
# whenever applying the next convolution would result in the activations
# having output stride larger than the target output_stride.
self.layer_names = []
current_stride = 1
rate = 1
for i, conv_def in enumerate(self.conv_defs):
end_point_base = 'Conv2d_{}'.format(i)
if output_stride is not None and current_stride == output_stride:
# If we have reached the target output_stride, then we need to employ
# atrous convolution with stride=1 and multiply the atrous rate by the
# current unit's stride for use in subsequent layers.
# FIXME chainer的depthwise conv 不支持atrous rate or dilated rate
layer_stride = 1
layer_rate = rate
rate *= conv_def.stride
else:
layer_stride = conv_def.stride
layer_rate = 1
current_stride *= conv_def.stride
if isinstance(conv_def, Conv):
end_point = end_point_base
if use_explicit_padding:
self.layer_names.append(("use_explicit_padding", conv_def.kernel))
setattr(self, end_point, L.Convolution2D(in_channels=conv_def.inchannel, out_channels=self.depth(conv_def.depth),
ksize=conv_def.kernel, stride=conv_def.stride,pad=pad, nobias=False,
initialW=initialW))
self.layer_names.append(end_point)
bn_end_point = end_point + "_batchnorm"
setattr(self, bn_end_point, L.BatchNormalization(size=self.depth(conv_def.depth)))
self.layer_names.append(bn_end_point)
if end_point == final_endpoint:
return
elif isinstance(conv_def, DepthSepConv):
end_point = end_point_base + '_depthwise'
if use_explicit_padding:
self.layer_names.append(("use_explicit_padding", conv_def.kernel, layer_rate))
setattr(self, end_point, L.DepthwiseConvolution2D(in_channels=self.depth(conv_def.inchannel), channel_multiplier=1,
ksize=conv_def.kernel, stride=layer_stride, pad=pad,nobias=False,
initialW=initialW))
self.layer_names.append(end_point)
bn_end_point = end_point + "_batchnorm"
setattr(self, bn_end_point, L.BatchNormalization(size=self.depth(conv_def.inchannel)))
self.layer_names.append(bn_end_point)
if end_point == final_endpoint:
return
end_point = end_point_base + '_pointwise'
setattr(self, end_point, L.Convolution2D(in_channels=self.depth(conv_def.inchannel), out_channels=self.depth(conv_def.depth),
ksize=[1,1], stride=1, pad=0, nobias=False, initialW=initialW))
self.layer_names.append(end_point)
bn_end_point = end_point + "_batchnorm"
setattr(self, bn_end_point, L.BatchNormalization(size=self.depth(conv_def.depth)))
self.layer_names.append(bn_end_point)
if end_point == final_endpoint:
return
else:
raise ValueError('Unknown convolution type %s for layer %d'
% (conv_def.ltype, i))
def __init__(self,
ch_in,
ch_out,
ksize=(3, 1),
stride=(1, 1),
pad=(1, 0),
wscale=0.02,
normalize=None,
use_wscale=False,
n_class=2,
padding_mode=None):
assert normalize in [
'batch', 'cbatch', 'spectrum+batch', 'instance',
'conditional_instance', None
]
if use_wscale:
w = chainer.initializers.Normal(1.0)
else:
if type(ksize) == 'int':
w = chainer.initializers.Uniform(scale=math.sqrt(1 / ksize /
ksize))
else:
w = chainer.initializers.Uniform(scale=math.sqrt(1 / ksize[0] /
ksize[1]))
super(dw_conv_Layer, self).__init__()
pad_conv = 0 if padding_mode else pad
with self.init_scope():
if normalize == 'spectrum' or normalize == 'spectrum+batch':
self.conv = SNDepthwiseConvolution2D(ch_in,
ch_out // ch_in,
ksize=ksize,
stride=stride,
pad=pad_conv,
initialW=w)
else:
self.conv = L.DepthwiseConvolution2D(ch_in,
ch_out // ch_in,
ksize=ksize,
stride=stride,
pad=pad_conv,
initialW=w)
if normalize == 'batch' or normalize == 'spectrum+batch':
self.batch_norm = L.BatchNormalization(ch_out)
elif normalize == 'cbatch':
self.batch_norm = CategoricalConditionalBatchNormalization(
ch_out, n_class)
elif normalize == 'instance':
#self.batch_norm = L.BatchNormalization(axis=(0,3,4))
self.batch_norm = InstanceNormalization(ch_out)
elif normalize == 'conditional_instance':
#self.batch_norm = ConditionalInstanceNormalization(ch_out)
self.norm0 = InstanceNormalization(ch_out)
self.norm1 = InstanceNormalization(ch_out)
self.c = np.sqrt(2 / (ksize[0] * ksize[1]))
self.normalize = normalize
self.use_wscale = use_wscale
self.padding_mode = padding_mode
self.padding_width = [[0, 0], [0, 0], [pad[0], pad[0]],
[pad[1], pad[1]]]
def D(_self):
return L.DepthwiseConvolution2D(None, 1, 3, _self.stride, 1, _self.nobias,
_self.initialW)
def ChooseWhichFilters(conv_pw1, bn_pw, conv_dw, bn_dw, conv_pw2, numfilter):
# new conv_dw
param = conv_dw.W.data
shape = param.shape
param = param.reshape(shape[1], shape[0] * shape[2] * shape[3])
param = cuda.to_cpu(param)
norms = np.linalg.norm(param, axis=1)
order = np.argsort(norms)[::-1]
param = np.delete(param, order[numfilter:], axis=0)
param = param.reshape((shape[0], numfilter, shape[2], shape[3]))
param = cuda.to_gpu(param)
new_conv_dw = L.DepthwiseConvolution2D(in_channels=numfilter,
channel_multiplier=1,
ksize=3,
stride=conv_dw.stride,
pad=1,
nobias=True)
new_conv_dw.W.data = param
# new bn_dw
new_bn_dw = L.BatchNormalization(numfilter)
param = bn_dw.beta.data
param = cuda.to_cpu(param)
param = np.delete(param, order[numfilter:])
param = cuda.to_gpu(param)
new_bn_dw.beta.data = param
param = bn_dw.gamma.data
param = cuda.to_cpu(param)
param = np.delete(param, order[numfilter:])
param = cuda.to_gpu(param)
new_bn_dw.gamma.data = param
new_bn_dw.to_gpu(0)
# new conv_pw1
param = conv_pw1.W.data
param = cuda.to_cpu(param)
param = np.delete(param, order[numfilter:], axis=0)
param = cuda.to_gpu(param)
new_conv_pw1 = L.Convolution2D(in_channels=conv_pw1.W.data.shape[1],
out_channels=numfilter,
ksize=1,
stride=conv_pw1.stride,
pad=0,
nobias=True)
new_conv_pw1.W.data = param
# new bn_pw
new_bn_pw = L.BatchNormalization(numfilter)
param = bn_pw.beta.data
param = cuda.to_cpu(param)
param = np.delete(param, order[numfilter:])
param = cuda.to_gpu(param, 0)
new_bn_pw.beta.data = param
param = bn_pw.gamma.data
param = cuda.to_cpu(param)
param = np.delete(param, order[numfilter:])
param = cuda.to_gpu(param, 0)
new_bn_pw.gamma.data = param
new_bn_pw.to_gpu(0)
# new conv_pw2
param = conv_pw2.W.data
param = cuda.to_cpu(param)
param = np.delete(param, order[numfilter:], axis=1)
param = cuda.to_gpu(param)
new_conv_pw2 = L.Convolution2D(in_channels=numfilter,
out_channels=conv_pw2.W.data.shape[0],
ksize=1,
stride=conv_pw1.stride,
pad=0,
nobias=True)
new_conv_pw2.W.data = param
return (new_conv_pw1, new_bn_pw, new_conv_dw, new_bn_dw, new_conv_pw2)
