def check_backward_consistency_regression(self, x_data, gy_data,
use_cudnn='always'):
# Regression test to two-dimensional average pooling layer.
if len(self.dims) != 2:
return
ksize = self.ksize
stride = self.stride
pad = self.pad
xp = cuda.get_array_module(x_data)
# Backward computation for N-dimensional average pooling layer.
x_nd = chainer.Variable(xp.array(x_data))
with chainer.using_config('use_cudnn', use_cudnn):
func_nd = functions.AveragePoolingND(self.ndim, ksize,
stride=stride, pad=pad)
y_nd = func_nd.apply((x_nd,))[0]
y_nd.grad = gy_data
y_nd.backward()
# Backward computation for two-dimensional average pooling layer.
x_2d = chainer.Variable(xp.array(x_data))
with chainer.using_config('use_cudnn', use_cudnn):
func_2d = functions.AveragePooling2D(ksize, stride=stride, pad=pad,
cover_all=False)
y_2d = func_2d.apply((x_2d,))[0]
y_2d.grad = gy_data
y_2d.backward()
# Test that the two result gradients are close enough.
testing.assert_allclose(x_nd.grad, x_2d.grad)
def __init__(self, depth=18, swapout=False, skip=False):
super(IdentityMapping, self).__init__()
links = [('bconv1', BatchConv2D(3, 16, 3, 1, 1), True)]
skip_size = depth * 3 - 3
for i in six.moves.range(depth):
if skip:
skip_ratio = float(i) / skip_size * 0.5
else:
skip_ratio = 0
links.append(('res{}'.format(len(links)), IdentityMappingBlock(16, 16, swapout=swapout, skip_ratio=skip_ratio, activation1=F.relu, activation2=F.relu), True))
links.append(('res{}'.format(len(links)), IdentityMappingBlock(16, 32, stride=2, swapout=swapout, activation1=F.relu, activation2=F.relu), True))
for i in six.moves.range(depth - 1):
if skip:
skip_ratio = float(i + depth) / skip_size * 0.5
else:
skip_ratio = 0
links.append(('res{}'.format(len(links)), IdentityMappingBlock(32, 32, swapout=swapout, skip_ratio=skip_ratio, activation1=F.relu, activation2=F.relu), True))
links.append(('res{}'.format(len(links)), IdentityMappingBlock(32, 64, stride=2, swapout=swapout, activation1=F.relu, activation2=F.relu), True))
for i in six.moves.range(depth - 1):
if skip:
skip_ratio = float(i + depth * 2 - 1) / skip_size * 0.5
else:
skip_ratio = 0
links.append(('res{}'.format(len(links)), IdentityMappingBlock(64, 64, swapout=swapout, skip_ratio=skip_ratio, activation1=F.relu, activation2=F.relu), True))
links.append(('_apool{}'.format(len(links)), F.AveragePooling2D(8, 1, 0, False, True), False))
links.append(('fc{}'.format(len(links)), L.Linear(64, 10), False))
for name, f, _with_train in links:
if not name.startswith('_'):
self.add_link(*(name, f))
self.layers = links
def __init__(self, depth=4, width=2):
super(ShakeShakeResidualNet, self).__init__()
channel_size = 16 * width
links = [('bconv1', BatchConv2D(3, channel_size, 3, 1, 1))]
for i in six.moves.range(depth):
links.append(('res{}'.format(len(links)),
ShakeShakeResidualBlock(channel_size, channel_size)))
links.append(('res{}'.format(len(links)),
ShakeShakeResidualBlock(channel_size,
channel_size * 2,
stride=2)))
channel_size *= 2
for i in six.moves.range(depth - 1):
links.append(('res{}'.format(len(links)),
ShakeShakeResidualBlock(channel_size, channel_size)))
links.append(('res{}'.format(len(links)),
ShakeShakeResidualBlock(channel_size,
channel_size * 2,
stride=2)))
channel_size *= 2
for i in six.moves.range(depth - 1):
links.append(('res{}'.format(len(links)),
ShakeShakeResidualBlock(channel_size, channel_size)))
links.append(
('_apool{}'.format(len(links)), F.AveragePooling2D(8, 1, 0,
False)))
links.append(('fc{}'.format(len(links)), L.Linear(channel_size, 10)))
for name, f in links:
if not name.startswith('_'):
self.add_link(*(name, f))
self.layers = links
def __init__(self, depth=18, alpha=16, start_channel=16):
super(PyramidNet, self).__init__()
channel_diff = float(alpha) / depth
channel = start_channel
links = [('bconv1', BatchConv2D(3, channel, 3, 1, 1), True, False)]
for i in six.moves.range(depth):
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)), PyramidBlock(int(round(in_channel)), int(round(channel))), True, False))
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)), PyramidBlock(int(round(in_channel)), int(round(channel)), stride=2), True, False))
for i in six.moves.range(depth - 1):
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)), PyramidBlock(int(round(in_channel)), int(round(channel))), True, False))
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)), PyramidBlock(int(round(in_channel)), int(round(channel)), stride=2), True, False))
for i in six.moves.range(depth - 1):
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)), PyramidBlock(int(round(in_channel)), int(round(channel))), True, False))
links.append(('bn{}'.format(len(links)), L.BatchNormalization(int(round(channel))), False, True))
links.append(('_relu{}'.format(len(links)), F.ReLU(), False, False))
links.append(('_apool{}'.format(len(links)), F.AveragePooling2D(8, 1, 0, False, True), False, False))
links.append(('fc{}'.format(len(links)), L.Linear(int(round(channel)), 10), False, False))
for name, f, _with_train, _with_test in links:
if not name.startswith('_'):
self.add_link(*(name, f))
self.layers = links
def __init__(self,
train,
recipe_size,
ingredient,
output_size,
pooling_type='max',
features=1024):
self.pooling_type = pooling_type
self.features = features
self.recipe_size = recipe_size
self.output_size = output_size
ouf = ingredient.out_feature * (2 if pooling_type == 'both' else 1)
super(MultiTaskPoolFive,
self).__init__(train=train,
recipe_size=recipe_size,
ingredient=ingredient,
fc_A_0=L.Linear(ouf, self.features),
fc_A_1=L.Linear(self.features, self.features),
fc_A_2=L.Linear(self.features, self.output_size),
fc_B_0=L.Linear(ouf, self.features),
fc_B_1=L.Linear(self.features, self.features),
fc_B_2=L.Linear(self.features, self.output_size),
fc_C_0=L.Linear(ouf, self.features),
fc_C_1=L.Linear(self.features, self.features),
fc_C_2=L.Linear(self.features, self.output_size),
fc_D_0=L.Linear(ouf, self.features),
fc_D_1=L.Linear(self.features, self.features),
fc_D_2=L.Linear(self.features, self.output_size),
fc_E_0=L.Linear(ouf, self.features),
fc_E_1=L.Linear(self.features, self.features),
fc_E_2=L.Linear(self.features, self.output_size))
self.max = F.MaxPooling2D((recipe_size, 1))
self.avg = F.AveragePooling2D((recipe_size, 1))
def __init__(self, n=5):
super(ResNet, self).__init__()
self.dtype = np.float32
w = 1 / np.sqrt(2)
initW = initializers.HeNormal(scale=w)
initbias = initializers.Zero()
links = [('conv1',
L.Convolution2D(3,
16,
3,
1,
1,
initialW=initW,
initial_bias=initbias)),
('bn2', L.BatchNormalization(16, dtype=self.dtype)),
('_relu3', F.ReLU()), ('res4', Block(16, 16, n)),
('res5', Block(16, 32, n, 2)), ('res6', Block(32, 64, n, 2)),
('_apool7', F.AveragePooling2D(8, 1, 0, False, True)),
('fc8', L.Linear(64,
10,
initialW=initW,
initial_bias=initbias))]
for i, link in enumerate(links):
if 'res' in link[0] and os.path.isfile(link[0] + '.hdf5'):
self.add_link(*link)
serializers.load_hdf5(link[0] + '.hdf5',
getattr(self, link[0]))
elif not link[0].startswith('_'):
self.add_link(*link)
self.forward = links
self.train = True
def __init__(self, block_class, n=18):
super(ResNet, self).__init__()
w = math.sqrt(2)
links = [('conv1', L.Convolution2D(3, 16, 3, 1, 0, w))]
links += [('bn1', L.BatchNormalization(16))]
for i in range(n):
links += [('res{}'.format(len(links)), block_class(16, 16))]
for i in range(n):
links += [('res{}'.format(len(links)),
block_class(32 if i > 0 else 16, 32,
1 if i > 0 else 2))]
for i in range(n):
links += [('res{}'.format(len(links)),
block_class(64 if i > 0 else 32, 64,
1 if i > 0 else 2))]
links += [('_apool{}'.format(len(links)),
F.AveragePooling2D(6, 1, 0, False, True))]
links += [('fc{}'.format(len(links)),
L.Linear(64, 10))]
for link in links:
if not link[0].startswith('_'):
self.add_link(*link)
self.forward = links
self.train = True
def __init__(self, channels, num_classes):
"""assuming input size 14x14"""
super(AuxiliaryHeadImageNet, self).__init__()
self.features = Sequential(
func.relu,
func.AveragePooling2D(ksize=5, stride=2, pad=0, cover_all=False).apply,
links.Convolution2D(channels, 128, 1, nobias=True),
links.BatchNormalization(128),
func.relu,
links.Convolution2D(128, 768, 2, nobias=True),
links.BatchNormalization(768),
func.relu
)
self.classifier = links.Linear(768, num_classes)
def __init__(self, n=18):
super(ResNet, self).__init__()
w = math.sqrt(2)
links = [('conv1', L.Convolution2D(3, 16, 3, 1, 0, w)),
('bn2', L.BatchNormalization(16)), ('_relu3', F.ReLU()),
('res4', Block(16, 32, n)), ('res5', Block(32, 64, n, 2)),
('res6', Block(64, 64, n, 2)),
('_apool7', F.AveragePooling2D(6, 1, 0, False, True)),
('fc8', L.Linear(64, 10))]
for link in links:
if not link[0].startswith('_'):
self.add_link(*link)
self.forward = links
self.train = True
def __init__(self, depth=18, swapout=False, skip=False):
super(ResidualNet, self).__init__()
links = [('bconv1', BatchConv2D(3, 16, 3, 1, 1))]
skip_size = depth * 3 - 3
for i in six.moves.range(depth):
if skip:
skip_ratio = float(i) / skip_size * 0.5
else:
skip_ratio = 0
links.append(('res{}'.format(len(links)),
ResidualBlock(
16,
16,
swapout=swapout,
skip_ratio=skip_ratio,
)))
links.append(('res{}'.format(len(links)),
ResidualBlock(16, 32, stride=2, swapout=swapout)))
for i in six.moves.range(depth - 1):
if skip:
skip_ratio = float(i + depth) / skip_size * 0.5
else:
skip_ratio = 0
links.append(('res{}'.format(len(links)),
ResidualBlock(32,
32,
swapout=swapout,
skip_ratio=skip_ratio)))
links.append(('res{}'.format(len(links)),
ResidualBlock(32, 64, stride=2, swapout=swapout)))
for i in six.moves.range(depth - 1):
if skip:
skip_ratio = float(i + depth * 2 - 1) / skip_size * 0.5
else:
skip_ratio = 0
links.append(('res{}'.format(len(links)),
ResidualBlock(64,
64,
swapout=swapout,
skip_ratio=skip_ratio)))
links.append(
('_apool{}'.format(len(links)), F.AveragePooling2D(8, 1, 0,
False)))
links.append(('fc{}'.format(len(links)), L.Linear(64, 10)))
for name, f in links:
if not name.startswith('_'):
self.add_link(*(name, f))
self.layers = links
def __init__(self, block_class=ResBlock, n=18, class_labels=10):
super(ResNet, self).__init__()
w = math.sqrt(2)
links = [('conv1', L.Convolution2D(3, 96, 3, 1, 0, w))]
links += [('bn1', L.BatchNormalization(96))]
for i in range(n):
links += [('res{}'.format(len(links)), block_class(96, 96))]
for i in range(n):
links += [('res{}'.format(len(links)),
block_class(128 if i > 0 else 96, 128,
1 if i > 0 else 2))]
for i in range(n):
links += [('res{}'.format(len(links)),
block_class(192 if i > 0 else 128, 192,
1 if i > 0 else 2))]
links += [('_apool{}'.format(len(links)), F.AveragePooling2D(8, 1, 0))]
links += [('fc{}'.format(len(links)), L.Linear(192, class_labels))]
for link in links:
if not link[0].startswith('_'):
self.add_link(*link)
self.forward = links
self.train = True
print(links)
def check_backward(self, x_data, y_grad, use_cudnn='always'):
with chainer.using_config('use_cudnn', use_cudnn):
gradient_check.check_backward(
functions.AveragePooling2D(3, 2, 1, False), x_data, y_grad,
**self.check_backward_options)
def __init__(self, depth=18, alpha=16, start_channel=16, skip=False):
super(PyramidNet, self).__init__()
channel_diff = float(alpha) / depth
channel = start_channel
links = [('bconv1', BatchConv2D(3, channel, 3, 1, 1))]
skip_size = depth * 3 - 3
for i in six.moves.range(depth):
if skip:
skip_ratio = float(i) / skip_size * 0.5
else:
skip_ratio = 0
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)),
PyramidBlock(int(round(in_channel)),
int(round(channel)),
skip_ratio=skip_ratio)))
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)),
PyramidBlock(int(round(in_channel)),
int(round(channel)),
stride=2)))
for i in six.moves.range(depth - 1):
if skip:
skip_ratio = float(i + depth) / skip_size * 0.5
else:
skip_ratio = 0
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)),
PyramidBlock(int(round(in_channel)),
int(round(channel)),
skip_ratio=skip_ratio)))
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)),
PyramidBlock(int(round(in_channel)),
int(round(channel)),
stride=2)))
for i in six.moves.range(depth - 1):
if skip:
skip_ratio = float(i + depth * 2 - 1) / skip_size * 0.5
else:
skip_ratio = 0
in_channel = channel
channel += channel_diff
links.append(('py{}'.format(len(links)),
PyramidBlock(int(round(in_channel)),
int(round(channel)),
skip_ratio=skip_ratio)))
links.append(('bn{}'.format(len(links)),
L.BatchNormalization(int(round(channel)))))
links.append(('_relu{}'.format(len(links)), F.ReLU()))
links.append(
('_apool{}'.format(len(links)), F.AveragePooling2D(8, 1, 0,
False)))
links.append(
('fc{}'.format(len(links)), L.Linear(int(round(channel)), 10)))
for name, f in links:
if not name.startswith('_'):
self.add_link(*(name, f))
self.layers = links
def backward(self, inputs, grad_outputs):
gap = self.size * f.AveragePooling2D(self.size).forward(grad_outputs)[0]
return gap,
def check_backward(self, x_data, y_grad, use_cudnn=True):
gradient_check.check_backward(
functions.AveragePooling2D(3, 2, 1, False, use_cudnn), x_data,
y_grad, **self.check_backward_options)
def __init__(self):
super(WavenetAutoencoder, self).__init__()
self.d = 256
self.residual_cnl = 32
self.dilation_cnl = 16
self.skip_cnl = 64
self.z_cnl = 16
self.pitch_cnl = 7
self.dilation = [2**(i + 1) for i in range(10)] * 3
self.pooling = F.AveragePooling2D(ksize=(512, 1))
self.add_link('embedid', L.EmbedID(self.d, self.residual_cnl))
for i, d in enumerate(self.dilation):
self.add_link('ecd_bfr_bn%d' % i,
L.BatchNormalization(self.residual_cnl))
self.add_link(
'ecd_conv%d' % i,
L.DilatedConvolution2D(self.residual_cnl,
self.dilation_cnl,
ksize=(3, 1),
pad=(d, 0),
dilate=d))
self.add_link('ecd_afr_bn%d' % i,
L.BatchNormalization(self.dilation_cnl))
self.add_link(
'ecd_afr_conv%d' % i,
L.Convolution2D(self.dilation_cnl,
self.residual_cnl,
ksize=(1, 1)))
self.add_link(
'ecd_fnl_conv',
L.Convolution2D(self.residual_cnl, self.z_cnl, ksize=(1, 1)))
self.add_link(
'dcd_bias_conv',
L.Convolution2D(self.z_cnl + self.pitch_cnl,
self.dilation_cnl,
ksize=(1, 1)))
for i, d in enumerate(self.dilation):
self.add_link('dcd_bfr_bn%d' % i,
L.BatchNormalization(self.residual_cnl))
self.add_link(
'dcd_conv%d' % i,
L.DilatedConvolution2D(self.residual_cnl,
self.dilation_cnl,
ksize=(2, 1),
pad=(0, 0),
dilate=d,
nobias=True))
self.add_link('dcd_afr_bn%d' % i,
L.BatchNormalization(self.dilation_cnl))
self.add_link(
'dcd_afr_conv%d' % i,
L.Convolution2D(self.dilation_cnl,
self.residual_cnl,
ksize=(1, 1)))
self.add_link(
'dcd_fnl_conv1',
L.Convolution2D(self.residual_cnl, self.residual_cnl,
ksize=(1, 1)))
self.add_link('dcd_fnl_conv2',
L.Convolution2D(self.residual_cnl, self.d, ksize=(1, 1)))
import chainer.functions as F
import numpy as np
import time
repeat = 1
(n, c, h, w) = (128, 256, 64, 64)
x = np.ones((n, c, h, w), dtype=np.float32)
f = F.AveragePooling2D(3, stride=2, pad=0, use_cudnn=False)
x = x,
y = f.forward_cpu(x)
start = time.time()
for i in range(repeat):
y = f.forward_cpu(x)
print("average forward %f seconds" % ((time.time() - start) / repeat))
gy = np.ndarray(y[0].shape, dtype=np.float32)
gy.fill(0.001)
gy = gy,
gx = f.backward_cpu(x, gy)
start = time.time()
for i in range(repeat):
gx = f.backward_cpu(x, gy)
print("average backward %f seconds" % ((time.time() - start) / repeat))
def __init__(self):
super().__init__(
conv=L.Convolution2D(3, 32, 3, stride=2, pad=0),
conv_1=L.Convolution2D(32, 32, 3, stride=1, pad=0),
conv_2=L.Convolution2D(32, 64, 3, stride=1, pad=1),
conv_3=L.Convolution2D(64, 80, 1, stride=1, pad=0),
conv_4=L.Convolution2D(80, 192, 3, stride=1, pad=0),
bn_conv=L.BatchNormalization(32),
bn_conv_1=L.BatchNormalization(32),
bn_conv_2=L.BatchNormalization(64),
bn_conv_3=L.BatchNormalization(80),
bn_conv_4=L.BatchNormalization(192),
mixed=Mixed([
('conv',
Tower([('conv', L.Convolution2D(192, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(192, 48, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(48)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(48, 64, 5, stride=1,
pad=2)),
('bn_conv_1', L.BatchNormalization(64)),
('_relu_1', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(192, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(64, 96, 3, stride=1,
pad=1)),
('bn_conv_1', L.BatchNormalization(96)),
('_relu_1', F.ReLU()),
('conv_2', L.Convolution2D(96, 96, 3, stride=1,
pad=1)),
('bn_conv_2', L.BatchNormalization(96)),
('_relu_2', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(192, 32, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(32)),
('_relu', F.ReLU())]))
]),
mixed_1=Mixed([
('conv',
Tower([('conv', L.Convolution2D(256, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(256, 48, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(48)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(48, 64, 5, stride=1,
pad=2)),
('bn_conv_1', L.BatchNormalization(64)),
('_relu_1', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(256, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(64, 96, 3, stride=1,
pad=1)),
('bn_conv_1', L.BatchNormalization(96)),
('_relu_1', F.ReLU()),
('conv_2', L.Convolution2D(96, 96, 3, stride=1,
pad=1)),
('bn_conv_2', L.BatchNormalization(96)),
('_relu_2', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(256, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU())]))
]),
mixed_2=Mixed([
('conv',
Tower([('conv', L.Convolution2D(288, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(288, 48, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(48)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(48, 64, 5, stride=1,
pad=2)),
('bn_conv_1', L.BatchNormalization(64)),
('_relu_1', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(288, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(64, 96, 3, stride=1,
pad=1)),
('bn_conv_1', L.BatchNormalization(96)),
('_relu_1', F.ReLU()),
('conv_2', L.Convolution2D(96, 96, 3, stride=1,
pad=1)),
('bn_conv_2', L.BatchNormalization(96)),
('_relu_2', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(288, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU())]))
]),
mixed_3=Mixed([
('conv',
Tower([('conv', L.Convolution2D(288, 384, 3, stride=2,
pad=0)),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(288, 64, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(64)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(64, 96, 3, stride=1,
pad=1)),
('bn_conv_1', L.BatchNormalization(96)),
('_relu_1', F.ReLU()),
('conv_2', L.Convolution2D(96, 96, 3, stride=2,
pad=0)),
('bn_conv_2', L.BatchNormalization(96)),
('_relu_2', F.ReLU())])),
('pool', Tower([('_pooling', F.MaxPooling2D(3, 2, pad=0))]))
]),
mixed_4=Mixed([
('conv',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(768, 128, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(128)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(128,
128, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_1', L.BatchNormalization(128)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(128,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_2', L.BatchNormalization(192)),
('_relu_2', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(768, 128, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(128)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(128,
128, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_1', L.BatchNormalization(128)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(128,
128, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_2', L.BatchNormalization(128)),
('_relu_2', F.ReLU()),
('conv_3',
L.Convolution2D(128,
128, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_3', L.BatchNormalization(128)),
('_relu_3', F.ReLU()),
('conv_4',
L.Convolution2D(128,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_4', L.BatchNormalization(192)),
('_relu_4', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())]))
]),
mixed_5=Mixed([
('conv',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(768, 160, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(160)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(160,
160, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_1', L.BatchNormalization(160)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(160,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_2', L.BatchNormalization(192)),
('_relu_2', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(768, 160, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(160)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(160,
160, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_1', L.BatchNormalization(160)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(160,
160, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_2', L.BatchNormalization(160)),
('_relu_2', F.ReLU()),
('conv_3',
L.Convolution2D(160,
160, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_3', L.BatchNormalization(160)),
('_relu_3', F.ReLU()),
('conv_4',
L.Convolution2D(160,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_4', L.BatchNormalization(192)),
('_relu_4', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())]))
]),
mixed_6=Mixed([
('conv',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(768, 160, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(160)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(160,
160, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_1', L.BatchNormalization(160)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(160,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_2', L.BatchNormalization(192)),
('_relu_2', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(768, 160, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(160)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(160,
160, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_1', L.BatchNormalization(160)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(160,
160, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_2', L.BatchNormalization(160)),
('_relu_2', F.ReLU()),
('conv_3',
L.Convolution2D(160,
160, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_3', L.BatchNormalization(160)),
('_relu_3', F.ReLU()),
('conv_4',
L.Convolution2D(160,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_4', L.BatchNormalization(192)),
('_relu_4', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())]))
]),
mixed_7=Mixed([
('conv',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())])),
('tower',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(192,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_1', L.BatchNormalization(192)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(192,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_2', L.BatchNormalization(192)),
('_relu_2', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(192,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_1', L.BatchNormalization(192)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(192,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_2', L.BatchNormalization(192)),
('_relu_2', F.ReLU()),
('conv_3',
L.Convolution2D(192,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_3', L.BatchNormalization(192)),
('_relu_3', F.ReLU()),
('conv_4',
L.Convolution2D(192,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_4', L.BatchNormalization(192)),
('_relu_4', F.ReLU())])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())]))
]),
mixed_8=Mixed([
('tower',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(192,
320,
3,
stride=2,
pad=0)),
('bn_conv_1', L.BatchNormalization(320)),
('_relu_1', F.ReLU())])),
('tower_1',
Tower([('conv', L.Convolution2D(768, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU()),
('conv_1',
L.Convolution2D(192,
192, (1, 7),
stride=1,
pad=(0, 3))),
('bn_conv_1', L.BatchNormalization(192)),
('_relu_1', F.ReLU()),
('conv_2',
L.Convolution2D(192,
192, (7, 1),
stride=1,
pad=(3, 0))),
('bn_conv_2', L.BatchNormalization(192)),
('_relu_2', F.ReLU()),
('conv_3', L.Convolution2D(192,
192,
3,
stride=2,
pad=0)),
('bn_conv_3', L.BatchNormalization(192)),
('_relu_3', F.ReLU())])),
('pool', Tower([('_pooling', F.MaxPooling2D(3, 2, pad=0))]))
]),
mixed_9=Mixed([
('conv',
Tower([
('conv', L.Convolution2D(1280, 320, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(320)),
('_relu', F.ReLU()),
])),
('tower',
Tower([('conv', L.Convolution2D(1280, 384, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU()),
('mixed',
Mixed([('conv',
Tower([
('conv',
L.Convolution2D(384,
384, (1, 3),
stride=1,
pad=(0, 1))),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU()),
])),
('conv_1',
Tower([
('conv_1',
L.Convolution2D(384,
384, (3, 1),
stride=1,
pad=(1, 0))),
('bn_conv_1', L.BatchNormalization(384)),
('_relu_1', F.ReLU()),
]))]))])),
('tower_1',
Tower([('conv', L.Convolution2D(1280, 448, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(448)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(448,
384,
3,
stride=1,
pad=1)),
('bn_conv_1', L.BatchNormalization(384)),
('_relu_1', F.ReLU()),
('mixed',
Mixed([('conv',
Tower([
('conv',
L.Convolution2D(384,
384, (1, 3),
stride=1,
pad=(0, 1))),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU()),
])),
('conv_1',
Tower([
('conv_1',
L.Convolution2D(384,
384, (3, 1),
stride=1,
pad=(1, 0))),
('bn_conv_1', L.BatchNormalization(384)),
('_relu_1', F.ReLU()),
]))]))])),
('tower_2',
Tower([('_pooling', F.AveragePooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(1280, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())]))
]),
mixed_10=Mixed([
('conv',
Tower([
('conv', L.Convolution2D(2048, 320, 1, stride=1, pad=0)),
('bn_conv', L.BatchNormalization(320)),
('_relu', F.ReLU()),
])),
('tower',
Tower([('conv', L.Convolution2D(2048, 384, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU()),
('mixed',
Mixed([('conv',
Tower([
('conv',
L.Convolution2D(384,
384, (1, 3),
stride=1,
pad=(0, 1))),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU()),
])),
('conv_1',
Tower([
('conv_1',
L.Convolution2D(384,
384, (3, 1),
stride=1,
pad=(1, 0))),
('bn_conv_1', L.BatchNormalization(384)),
('_relu_1', F.ReLU()),
]))]))])),
('tower_1',
Tower([('conv', L.Convolution2D(2048, 448, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(448)),
('_relu', F.ReLU()),
('conv_1', L.Convolution2D(448,
384,
3,
stride=1,
pad=1)),
('bn_conv_1', L.BatchNormalization(384)),
('_relu_1', F.ReLU()),
('mixed',
Mixed([('conv',
Tower([('conv',
L.Convolution2D(384,
384, (1, 3),
stride=1,
pad=(0, 1))),
('bn_conv', L.BatchNormalization(384)),
('_relu', F.ReLU())])),
('conv_1',
Tower([('conv_1',
L.Convolution2D(384,
384, (3, 1),
stride=1,
pad=(1, 0))),
('bn_conv_1',
L.BatchNormalization(384)),
('_relu_1', F.ReLU())]))]))])),
('tower_2',
Tower([('_pooling', F.MaxPooling2D(3, 1, pad=1)),
('conv', L.Convolution2D(2048, 192, 1, stride=1,
pad=0)),
('bn_conv', L.BatchNormalization(192)),
('_relu', F.ReLU())]))
]),
logit=L.Linear(2048, 1008))
def __init__(self,
cgp,
n_class,
lossfun=softmax_cross_entropy.softmax_cross_entropy,
accfun=accuracy.accuracy):
super(CGP2CNN, self).__init__()
self.cgp = cgp
self.pool_size = 2
initializer = chainer.initializers.HeNormal()
links = []
i = 1
for name, in1, in2 in self.cgp:
if name == 'pool_max':
links += [('_' + name + '_' + str(i),
F.MaxPooling2D(self.pool_size, self.pool_size, 0,
False))]
elif name == 'pool_ave':
links += [('_' + name + '_' + str(i),
F.AveragePooling2D(self.pool_size, self.pool_size,
0, False))]
elif name == 'concat':
links += [('_' + name + '_' + str(i), F.Concat())]
elif name == 'sum':
links += [('_' + name + '_' + str(i), F.Concat())
] # the F.Concat() is dummy
elif name == 'ConvBlock32_3':
links += [(name + '_' + str(i), ConvBlock(3, 32, initializer))]
elif name == 'ConvBlock32_5':
links += [(name + '_' + str(i), ConvBlock(5, 32, initializer))]
elif name == 'ConvBlock32_7':
links += [(name + '_' + str(i), ConvBlock(7, 32, initializer))]
elif name == 'ConvBlock64_3':
links += [(name + '_' + str(i), ConvBlock(3, 64, initializer))]
elif name == 'ConvBlock64_5':
links += [(name + '_' + str(i), ConvBlock(5, 64, initializer))]
elif name == 'ConvBlock64_7':
links += [(name + '_' + str(i), ConvBlock(7, 64, initializer))]
elif name == 'ConvBlock128_3':
links += [(name + '_' + str(i), ConvBlock(3, 128,
initializer))]
elif name == 'ConvBlock128_5':
links += [(name + '_' + str(i), ConvBlock(5, 128,
initializer))]
elif name == 'ConvBlock128_7':
links += [(name + '_' + str(i), ConvBlock(7, 128,
initializer))]
elif name == 'ResBlock32_3':
links += [(name + '_' + str(i), ResBlock(3, 32, initializer))]
elif name == 'ResBlock32_5':
links += [(name + '_' + str(i), ResBlock(5, 32, initializer))]
elif name == 'ResBlock32_7':
links += [(name + '_' + str(i), ResBlock(7, 32, initializer))]
elif name == 'ResBlock64_3':
links += [(name + '_' + str(i), ResBlock(3, 64, initializer))]
elif name == 'ResBlock64_5':
links += [(name + '_' + str(i), ResBlock(5, 64, initializer))]
elif name == 'ResBlock64_7':
links += [(name + '_' + str(i), ResBlock(7, 64, initializer))]
elif name == 'ResBlock128_3':
links += [(name + '_' + str(i), ResBlock(3, 128, initializer))]
elif name == 'ResBlock128_5':
links += [(name + '_' + str(i), ResBlock(5, 128, initializer))]
elif name == 'ResBlock128_7':
links += [(name + '_' + str(i), ResBlock(7, 128, initializer))]
elif name == 'full':
links += [(name + '_' + str(i),
L.Linear(None, n_class, initialW=initializer))]
i += 1
for link in links:
if not link[0].startswith('_'):
self.add_link(*link)
self.forward = links
self.train = True
self.lossfun = lossfun
self.accfun = accfun
self.loss = None
self.accuracy = None
self.outputs = [None for _ in range(len(self.cgp))]
self.param_num = 0
