def forward(self, x, train=True):
h, = Convolution2DFunction().forward(
(x, self.conv1.W.data, self.conv1.b.data))
bn = self.bn1
h, = BatchNormalizationFunction(bn.eps, None, None, False,
0.0).forward(
(h, bn.gamma.data, bn.beta.data,
bn.avg_mean, bn.avg_var))
h, = F.ReLU().forward((h, ))
h, = F.MaxPooling2D(2).forward((h, ))
h, = Convolution2DFunction(pad=1).forward(
(h, self.conv2.W.data, self.conv2.b.data))
bn = self.bn2
h, = BatchNormalizationFunction(bn.eps, None, None, False,
0.0).forward(
(h, bn.gamma.data, bn.beta.data,
bn.avg_mean, bn.avg_var))
h, = F.ReLU().forward((h, ))
h, = F.MaxPooling2D(2).forward((h, ))
h, = Convolution2DFunction(pad=1).forward(
(h, self.conv3.W.data, self.conv3.b.data))
bn = self.bn3
h, = BatchNormalizationFunction(bn.eps, None, None, False,
0.0).forward(
(h, bn.gamma.data, bn.beta.data,
bn.avg_mean, bn.avg_var))
h, = F.ReLU().forward((h, ))
h, = F.MaxPooling2D(2).forward((h, ))
h, = LinearFunction().forward((h, self.fc4.W.data, self.fc4.b.data))
h, = F.ReLU().forward((h, ))
h, = LinearFunction().forward((h, self.fc5.W.data, self.fc5.b.data))
return h
def check_relu(self):
mkld.enable_relu = True
f_relu = F.ReLU(False)
res = f_relu.forward(self.x)
gy = self.x
res_b = f_relu.backward(self.x, gy)
mkld.enable_relu = False
f_relu = F.ReLU(False)
gy = self.x
res_expect = f_relu.forward(self.x)
res_b_expect = f_relu.backward(self.x, gy)
testing.assert_allclose(np.asarray(res), np.asarray(res_expect))
testing.assert_allclose(np.asarray(res_b), np.asarray(res_b_expect))
def test_mixed():
try:
instance_1 = NG_Mixed(Variable(np.array([0])), F.ReLU(), Parameter(np.array([0])), L.BatchNormalization(1))
chainer.serializers.save_npz("tmp.npz", instance_1)
instance_2 = NG_Mixed(Variable(np.array([1])), F.ReLU(), Parameter(np.array([1])), L.BatchNormalization(1))
chainer.serializers.load_npz("tmp.npz", instance_2)
assert (instance_1.p.data == instance_2.p.data).all()
assert (instance_1.v.data == instance_2.v.data).all()
print("Succeeded")
except Exception as e:
print("Failed")
raise e
finally:
if exists("tmp.npz"):
remove("tmp.npz")
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, 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 get_network(percentTrainKeeps=1, n_class=10):
network = [
L.Convolution2D(None, 64, 3, stride=1, pad=1),
L.BatchNormalization(64),
FL(F.ReLU()),
L.Convolution2D(64, 64, 3, stride=1, pad=1),
L.BatchNormalization(64),
FL(F.ReLU()),
FL(F.max_pooling_2d, 2, 2),
SL(FL(F.dropout, 0.25, train=True)),
L.Convolution2D(64, 128, 3, stride=1, pad=1),
L.BatchNormalization(128),
FL(F.ReLU()),
L.Convolution2D(128, 128, 3, stride=1, pad=1),
L.BatchNormalization(128),
FL(F.ReLU()),
Branch([L.Linear(None, n_class)]), # 1
FL(F.max_pooling_2d, 2, 2),
SL(FL(F.dropout, 0.25, train=True)),
L.Convolution2D(128, 256, 3, stride=1, pad=1),
L.BatchNormalization(256),
FL(F.ReLU()),
L.Convolution2D(256, 256, 3, stride=1, pad=1),
L.BatchNormalization(256),
FL(F.ReLU()),
L.Convolution2D(256, 256, 3, stride=1, pad=1),
L.BatchNormalization(256),
FL(F.ReLU()),
L.Convolution2D(256, 256, 3, stride=1, pad=1),
L.BatchNormalization(256),
FL(F.ReLU()),
FL(F.max_pooling_2d, 2, 2),
SL(FL(F.dropout, 0.25, train=True)),
L.Linear(None, 4096),
FL(F.ReLU()),
SL(FL(F.dropout, 0.5, train=True)),
L.Linear(4096, 4096),
FL(F.ReLU()),
SL(FL(F.dropout, 0.5, train=True)),
#L.Linear(4096, 1000),
Branch([L.Linear(None, n_class)])
]
net = BranchyNet(network, percentTrainKeeps=percentTrainKeeps)
return net
def get_network(percentTrainKeeps=1):
network = [
L.Convolution2D(1, 5, 5,stride=1, pad=3),
Branch([FL(F.max_pooling_2d, 2, 2), FL(F.ReLU()), L.Convolution2D(5, 10, 3, pad=1, stride=1),
FL(F.max_pooling_2d, 2, 2), FL(F.ReLU()), L.Linear(640, 10)]),
FL(F.max_pooling_2d, 2, 2),
FL(F.ReLU()),
L.Convolution2D(5, 10, 5,stride=1, pad=3),
FL(F.max_pooling_2d, 2, 2),
FL(F.ReLU()),
L.Convolution2D(10, 20, 5,stride=1, pad=3),
FL(F.max_pooling_2d, 2, 2),
FL(F.ReLU()),
L.Linear(720, 84),
Branch([L.Linear(84, 10)])
]
net = BranchyNet(network, percentTrainKeeps=percentTrainKeeps)
return net
def setUp(self):
cuda.memory_pool.free_all_blocks()
self.h = function_hooks.CupyMemoryProfileHook()
self.f1 = functions.Exp()
self.f2 = functions.ReLU()
self.x = numpy.random.uniform(-0.1, 0.1, (3, 5)).astype(numpy.float32)
x = cuda.to_gpu(self.x)
with self.h:
self.f1.apply((chainer.Variable(x), ))
self.f1.apply((chainer.Variable(x), ))
self.f2.apply((chainer.Variable(x), ))
self.f2.apply((chainer.Variable(x), ))
def get_network(percentTrainKeeps=1, n_class=10):
network = [
L.Convolution2D(1, 5, 5, stride=1, pad=3),
Branch([L.Linear(None, n_class)]), # 1
FL(F.max_pooling_2d, 2, 2),
FL(F.ReLU()),
Branch([L.Linear(None, n_class)]), # 2
L.Convolution2D(5, 10, 5, stride=1, pad=3),
Branch([L.Linear(None, n_class)]), # 3
FL(F.max_pooling_2d, 2, 2),
FL(F.ReLU()),
Branch([L.Linear(None, n_class)]), # 4
L.Convolution2D(10, 20, 5, stride=1, pad=3),
Branch([L.Linear(None, n_class)]), # 5
FL(F.max_pooling_2d, 2, 2),
FL(F.ReLU()),
Branch([L.Linear(None, n_class)]), # 6
L.Linear(None, 84), # 720, 84
Branch([L.Linear(None, n_class)]) # 84, 10
]
net = BranchyNet(network, percentTrainKeeps=percentTrainKeeps)
return net
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):
super(AgentNet, self).__init__()
net = [('conv1', L.Convolution2D(1, FILTERS_NUM, 3, 1, 1,
nobias=True))]
net += [('bn1', L.BatchNormalization(FILTERS_NUM))]
net += [('_relu1', F.ReLU())]
for i in range(HIDDEN_LAYER_NUM - 2):
net += [('conv{}'.format(i + 2),
L.Convolution2D(FILTERS_NUM,
FILTERS_NUM,
3,
1,
1,
nobias=True))]
net += [('bn{}'.format(i + 2), L.BatchNormalization(FILTERS_NUM))]
net += [('_relu{}'.format(i + 2), F.ReLU())]
net += [('conv{}'.format(HIDDEN_LAYER_NUM),
L.Convolution2D(FILTERS_NUM, 1, 1, 1, 0, nobias=False))]
with self.init_scope():
for n in net:
if not n[0].startswith('_'):
setattr(self, n[0], n[1])
self.forward = net
def __init__(self, ksize, n_out, initializer):
super(ResBlock, self).__init__()
pad_size = ksize // 2
links = [('conv1',
L.Convolution2D(None,
n_out,
ksize,
pad=pad_size,
initialW=initializer))]
links += [('bn1', L.BatchNormalization(n_out))]
links += [('_act1', F.ReLU())]
links += [('conv2',
L.Convolution2D(n_out,
n_out,
ksize,
pad=pad_size,
initialW=initializer))]
links += [('bn2', L.BatchNormalization(n_out))]
for link in links:
if not link[0].startswith('_'):
self.add_link(*link)
self.forward = links
def check_backward(self, x_data, y_grad, use_cudnn=True):
gradient_check.check_backward(functions.ReLU(use_cudnn), x_data,
y_grad)
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 __init__(self, train=False):
super(VGG16Prev, self).__init__()
self.trunk = [
('conv1_1', L.Convolution2D(3, 64, 3, 1, 1)),
('_relu1_1', F.ReLU()),
('conv1_2', L.Convolution2D(64, 64, 3, 1, 1)),
('_relu1_2', F.ReLU()),
('_pool1', F.MaxPooling2D(2, 2)),
('conv2_1', L.Convolution2D(64, 128, 3, 1, 1)),
('_relu2_1', F.ReLU()),
('conv2_2', L.Convolution2D(128, 128, 3, 1, 1)),
('_relu2_2', F.ReLU()),
('_pool2', F.MaxPooling2D(2, 2)),
('conv3_1', L.Convolution2D(128, 256, 3, 1, 1)),
('_relu3_1', F.ReLU()),
('conv3_2', L.Convolution2D(256, 256, 3, 1, 1)),
('_relu3_2', F.ReLU()),
('conv3_3', L.Convolution2D(256, 256, 3, 1, 1)),
('_relu3_3', F.ReLU()),
('_pool3', F.MaxPooling2D(2, 2)),
('conv4_1', L.Convolution2D(256, 512, 3, 1, 1)),
('_relu4_1', F.ReLU()),
('conv4_2', L.Convolution2D(512, 512, 3, 1, 1)),
('_relu4_2', F.ReLU()),
('conv4_3', L.Convolution2D(512, 512, 3, 1, 1)),
('_relu4_3', F.ReLU()),
('_pool4', F.MaxPooling2D(2, 2)),
('conv5_1', L.Convolution2D(512, 512, 3, 1, 1)),
('_relu5_1', F.ReLU()),
('conv5_2', L.Convolution2D(512, 512, 3, 1, 1)),
('_relu5_2', F.ReLU()),
('conv5_3', L.Convolution2D(512, 512, 3, 1, 1)),
('_relu5_3', F.ReLU()),
]
for name, link in self.trunk:
if not name.startswith('_'):
self.add_link(name, link)
def check_backward(self, x_data, y_grad, use_cudnn='always'):
with chainer.using_config('use_cudnn', use_cudnn):
gradient_check.check_backward(functions.ReLU(), x_data, y_grad,
**self.check_backward_options)
data.fill(333.33)
datay = np.ndarray((10, 3, 2240, 2240), dtype=np.float32)
datay.fill(333.33)
total_forward = 0
count = 0
niter = 15
n_dry = 3
for i in range(niter):
x = np.asarray(data),
gy = np.asarray(datay),
start = time.time()
# model.forward(x)
f_relu = F.ReLU(False)
f_relu.forward_cpu(x)
f_relu.backward_cpu(x, gy)
end = time.time()
if i > n_dry - 1:
count += 1
total_forward += (end-start)*1000
print("Average Forward: ", total_forward/count, "ms")
data = np.ndarray((2240, 2240), dtype=np.float32)
data.fill(333.33)
datay = np.ndarray((2240, 2240), dtype=np.float32)
datay.fill(333.33)
def __init__(self, train=False):
super(VGG16, self).__init__()
self.trunk = [
('conv1_1', L.Convolution2D(3, 64, 3, 1, 1)),
('relu1_1', F.ReLU()),
('conv1_2', L.Convolution2D(64, 64, 3, 1, 1)),
('relu1_2', F.ReLU()),
('pool1', F.MaxPooling2D(2, 2)),
('conv2_1', L.Convolution2D(64, 128, 3, 1, 1)),
('relu2_1', F.ReLU()),
('conv2_2', L.Convolution2D(128, 128, 3, 1, 1)),
('relu2_2', F.ReLU()),
('pool2', F.MaxPooling2D(2, 2)),
('conv3_1', L.Convolution2D(128, 256, 3, 1, 1)),
('relu3_1', F.ReLU()),
('conv3_2', L.Convolution2D(256, 256, 3, 1, 1)),
('relu3_2', F.ReLU()),
('conv3_3', L.Convolution2D(256, 256, 3, 1, 1)),
('relu3_3', F.ReLU()),
('pool3', F.MaxPooling2D(2, 2)),
('conv4_1', L.Convolution2D(256, 512, 3, 1, 1)),
('relu4_1', F.ReLU()),
('conv4_2', L.Convolution2D(512, 512, 3, 1, 1)),
('relu4_2', F.ReLU()),
('conv4_3', L.Convolution2D(512, 512, 3, 1, 1)),
('relu4_3', F.ReLU()),
('pool4', F.MaxPooling2D(2, 2)),
('conv5_1', L.Convolution2D(512, 512, 3, 1, 1)),
('relu5_1', F.ReLU()),
('conv5_2', L.Convolution2D(512, 512, 3, 1, 1)),
('relu5_2', F.ReLU()),
('conv5_3', L.Convolution2D(512, 512, 3, 1, 1)),
('relu5_3', F.ReLU()),
('rpn_conv_3x3', L.Convolution2D(512, 512, 3, 1, 1)),
('rpn_relu_3x3', F.ReLU()),
]
for name, link in self.trunk:
if 'conv' in name:
self.add_link(name, link)
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):
super().__init__()
with self.init_scope():
self.f = F.ReLU()
