def add_spatial_ds_unit(self, prefix, in_channels, out_channels, stride=2):
right = left = self.prev_blob
out_channels = out_channels // 2
# Enlarge the receptive field for detection task
if self.detection:
left = self.add_detection_unit(left, prefix + '_left_detection',
in_channels, in_channels)
left = self.add_dwconv3x3_bn(left, prefix + 'left_dwconv', in_channels,
stride)
left = self.add_conv1x1_bn(left, prefix + '_left_conv1', in_channels,
out_channels)
if self.detection:
right = self.add_detection_unit(right, prefix + '_right_detection',
in_channels, in_channels)
right = self.add_conv1x1_bn(right, prefix + '_right_conv1',
in_channels, out_channels)
right = self.add_dwconv3x3_bn(right, prefix + '_right_dwconv',
out_channels, stride)
right = self.add_conv1x1_bn(right, prefix + '_right_conv2',
out_channels, out_channels)
self.prev_blob = brew.concat(self.model, [right, left],
prefix + '_concat')
self.prev_blob = self.model.net.ChannelShuffle(self.prev_blob,
prefix + '_ch_shuffle',
group=self.num_groups,
kernel=1)
def test_fast_memonger_unique_outputs(self):
m = model_helper.ModelHelper()
fc = []
for i in range(2):
z = brew.fc(m,
"data{}".format(i),
"fc".format(i),
dim_in=2,
dim_out=2)
fc.append(z)
r = []
# Trick is here to have same input appear twice in a same Sum
for x in fc:
for y in fc:
r.append(brew.sum(m, [x, y], 1))
concated = brew.concat(m, r, "concated")
brew.relu(m, concated, "merged")
static_blobs = \
[o for op in m.param_init_net.Proto().op for o in op.output] + \
["merged"] + ["data{}".format(i) for i in range(len(fc))]
optimized_net = memonger.optimize_inference_fast(
m.Proto(), static_blobs)
for op in optimized_net.op:
self.assertEqual(len(op.output), len(set(op.output)), str(op))
def _InceptionModule(model, input_blob, input_depth, output_name, conv1_depth,
conv3_depths, conv5_depths, pool_depth):
# path 1: 1x1 conv
conv1 = brew.conv(model, input_blob, output_name + ":conv1", input_depth,
conv1_depth, 1, ('XavierFill', {}), ('ConstantFill', {}))
conv1 = brew.relu(model, conv1, conv1)
# path 2: 1x1 conv + 3x3 conv
conv3_reduce = brew.conv(model, input_blob, output_name + ":conv3_reduce",
input_depth, conv3_depths[0], 1,
('XavierFill', {}), ('ConstantFill', {}))
conv3_reduce = brew.relu(model, conv3_reduce, conv3_reduce)
conv3 = brew.conv(
model,
conv3_reduce,
output_name + ":conv3",
conv3_depths[0],
conv3_depths[1],
3,
('XavierFill', {}),
('ConstantFill', {}),
pad=1,
)
conv3 = brew.relu(model, conv3, conv3)
# path 3: 1x1 conv + 5x5 conv
conv5_reduce = brew.conv(model, input_blob, output_name + ":conv5_reduce",
input_depth, conv5_depths[0], 1,
('XavierFill', {}), ('ConstantFill', {}))
conv5_reduce = brew.relu(model, conv5_reduce, conv5_reduce)
conv5 = brew.conv(
model,
conv5_reduce,
output_name + ":conv5",
conv5_depths[0],
conv5_depths[1],
5,
('XavierFill', {}),
('ConstantFill', {}),
pad=2,
)
conv5 = brew.relu(model, conv5, conv5)
# path 4: pool + 1x1 conv
pool = brew.max_pool(
model,
input_blob,
output_name + ":pool",
kernel=3,
stride=1,
pad=1,
)
pool_proj = brew.conv(model, pool, output_name + ":pool_proj", input_depth,
pool_depth, 1, ('XavierFill', {}),
('ConstantFill', {}))
pool_proj = brew.relu(model, pool_proj, pool_proj)
output = brew.concat(model, [conv1, conv3, conv5, pool_proj], output_name)
return output
def inception_factory(model, v, num_in_channels, num_1x1, num_3x3red, num_3x3,
num_d5x5red, num_d5x5, proj, name):
# 1x1
c1x1 = conv_factory(model,
v,
num_in_channels,
num_filter=num_1x1,
kernel=1,
name=('%s_1x1' % name))
# 3x3 reduce + 3x3
c3x3r = conv_factory(model,
v,
num_in_channels,
num_filter=num_3x3red,
kernel=1,
name=('%s_3x3' % name),
suffix='_reduce')
c3x3 = conv_factory(model,
c3x3r,
num_3x3red,
num_filter=num_3x3,
kernel=3,
pad=1,
name=('%s_3x3' % name))
# double 3x3 reduce + double 3x3
cd5x5r = conv_factory(model,
v,
num_in_channels,
num_filter=num_d5x5red,
kernel=1,
name=('%s_5x5' % name),
suffix='_reduce')
cd5x5 = conv_factory(model,
cd5x5r,
num_d5x5red,
num_filter=num_d5x5,
kernel=5,
pad=2,
name=('%s_5x5' % name))
# pool + proj
pooling = brew.max_pool(model,
v,
'max_pool_%s_pool' % name,
kernel=3,
stride=1,
pad=1)
cproj = conv_factory(model,
pooling,
num_in_channels,
num_filter=proj,
kernel=1,
name=('%s_proj' % name))
# concat and return
return brew.concat(model, [c1x1, c3x3, cd5x5, cproj],
'ch_concat_%s_chconcat' % name)
def concat_layers(self, *args, axis=1):
self.prev_blob = brew.concat(
self.model,
args,
'%s_concat_%d' % (self.block_name, self.layer_num),
# add_axis= 0,
axis=axis,
)
self.layer_num += 1
return self.prev_blob
def block_head(self, model, v, towers, num_in_channels, num_out_channels,
scale=1.0, relu=True, name='block_head_node'):
tower_mixed = brew.concat(model, towers, blob_out=name+'_tower_mixed')
tower_out = self.conv_factory(model, tower_mixed, num_in_channels,
num_filters=num_out_channels,
kernel=1, relu=relu, name=name+'tower_out')
#v = v + scale * tower_out
scaled = model.Scale(tower_out, name + '_scale', scale=scale)
v = brew.sum(model, [v, scaled], name+'_sum')
#
if relu is True:
v = brew.relu(model, v, name + '_relu')
return v
def inception_module(self, model, name, inputs, input_depth, branches,
is_inference):
"""Add parallel branches from 'branhes' into current graph"""
self.counts[name] += 1
name = name + str(self.counts[name] - 1)
layers_outputs = [] # Outputs of each layer in each branch
layers_input_depths = [] # Layers input depths
for branch_id, branch in enumerate(branches):
v = inputs # Inputs for a next layer in a branch
last_layer_output_depth = input_depth
layers_outputs.append([]) # Outputs of layers in this branch
layers_input_depths.append([0] * len(branch))
for layer_id, layer in enumerate(branch):
layers_input_depths[-1][layer_id] = last_layer_output_depth
if layer[0] == 'conv':
v = self.conv(model,
name='%s_b%d_l%d_' %
(name, branch_id, layer_id),
inputs=v,
input_depth=last_layer_output_depth,
num_filters=layer[1],
kernel=layer[2],
stride=layer[3],
pad=layer[4],
is_inference=is_inference)
last_layer_output_depth = layer[1]
elif layer[0] == 'avg' or layer[0] == 'max':
pool_func = brew.average_pool if layer[
0] == 'avg' else brew.max_pool
v = pool_func(model,
v,
blob_out='%s_b%d_p%d' %
(name, branch_id, layer_id),
kernel=layer[1],
stride=layer[2],
pad=layer[3])
# last_layer_output_depth does not change here
elif layer[0] == 'share':
v = layers_outputs[-2][layer_id]
last_layer_output_depth = layers_input_depths[-2][layer_id
+ 1]
else:
assert False, 'Unknown later type - ' + layer[0]
layers_outputs[-1].append(v)
# concat
concat = brew.concat(model,
[outputs[-1] for outputs in layers_outputs],
blob_out='%s_concat' % name)
return concat
def fire_module(self, x, inp, fire_id, sq, exp_):
s_id = 'fire' + str(fire_id) + '/'
x = brew.conv(self.model, x, s_id + sq1x1, inp, sq, 1)
x = brew.relu(self.model, x, s_id + relu + sq1x1)
left = brew.conv(self.model, x, s_id + exp1x1, sq, exp_, 1)
left = brew.relu(self.model, left, s_id + relu + exp1x1)
right = brew.conv(self.model,
x,
s_id + exp3x3,
sq,
exp_,
3,
legacy_pad=2)
right = brew.relu(self.model, right, s_id + relu + exp3x3)
return brew.concat(self.model, [left, right],
self.prefix + s_id + 'concat',
axis=self.data_format), exp_ * 2
def add_se_model(model, config, data, is_test=False):
# add back-bone network (resnet-50 with last conv)
bottom_feature = add_resnet50_core(model, data, is_test=is_test)
# add osme attention module with different weight initialization
att1_feature = add_osme_branch(model, config, bottom_feature, 1)
att2_feature = add_osme_branch(model, config, bottom_feature, 2)
combined_feature = brew.concat(
model,
[att1_feature, att2_feature],
'combined_feature',
)
# add prediction for classification
pred = brew.fc(
model,
combined_feature,
'bi_attention_pred',
dim_in=config['model_arch']['attention_dim'] * 2,
dim_out=config['model_arch']['num_classes'],
)
return pred
def test_fast_memonger_unique_outputs(self):
m = model_helper.ModelHelper()
fc = []
for i in range(2):
z = brew.fc(
m, "data{}".format(i), "fc".format(i), dim_in=2, dim_out=2)
fc.append(z)
r = []
# Trick is here to have same input appear twice in a same Sum
for x in fc:
for y in fc:
r.append(brew.sum(m, [x, y], 1))
concated = brew.concat(m, r, "concated")
brew.relu(m, concated, "merged")
static_blobs = \
[o for op in m.param_init_net.Proto().op for o in op.output] + \
["merged"] + ["data{}".format(i) for i in range(len(fc))]
optimized_net = memonger.optimize_inference_fast(
m.Proto(), static_blobs)
for op in optimized_net.op:
self.assertEqual(len(op.output), len(set(op.output)), str(op))
def add_basic_unit(self, prefix, in_channels, stride=1):
in_channels = in_channels // 2
left = prefix + '_left'
right = prefix + '_right'
self.model.net.Split(self.prev_blob, [left, right])
if self.detection:
right = self.add_detection_unit(right, prefix + '_right_detection',
in_channels, in_channels)
right = self.add_conv1x1_bn(right, prefix + '_right_conv1',
in_channels, in_channels)
right = self.add_dwconv3x3_bn(right, prefix + '_right_dwconv',
in_channels, stride)
right = self.add_conv1x1_bn(right, prefix + '_right_conv2',
in_channels, in_channels)
self.prev_blob = brew.concat(self.model, [right, left],
prefix + '_concat')
self.prev_blob = self.model.net.ChannelShuffle(self.prev_blob,
prefix + '_ch_shuffle',
group=self.num_groups,
kernel=1)
def Concat(self, *args, **kwargs):
return brew.concat(self, *args, order=self.order, **kwargs)
def forward_pass_builder(self, model, loss_scale=1.0):
v = 'data' # 3x299x299
#
conv1 = self.conv_factory(model, v, 3, num_filters=32, kernel=3, stride=2, name='conv1') #32x149x149
conv2 = self.conv_factory(model, conv1, 32, 32, kernel=3, name='conv2') #32x147x147
conv3 = self.conv_factory(model, conv2, 32, 64, kernel=3, pad=1, name='conv3') #64x147x147
pool1 = brew.max_pool(model, conv3, 'pool1', kernel=3, stride=2) #64x73x73
#
conv4r = self.conv_factory(model, pool1, 64, 80, kernel=1, name='conv4_reduce') #80x73x73
conv4 = self.conv_factory(model, conv4r, 80, 192, kernel=3, name='conv4') #192x71x71
pool2 = brew.max_pool(model, conv4, 'pool2', kernel=3, stride=2) #192x35x35
#
conv5 = [None, None, None, None]
conv5[0] = self.conv_factory(model, pool2, 192, 96, kernel=1, name='conv5_1_1') #96x35x35
conv5[1] = self.conv_factory(model, pool2, 192, 48, kernel=1, name='conv5_2_1') #48x35x35
conv5[1] = self.conv_factory(model, conv5[1], 48, 64, kernel=5, pad=2, name='conv5_2_2') #64x35x35
conv5[2] = self.conv_factory(model, pool2, 192, 64, kernel=1, name='conv5_3_1') #64x35x35
conv5[2] = self.conv_factory(model, conv5[2], 64, 96, kernel=3, pad=1, name='conv5_3_2') #96x35x35
conv5[2] = self.conv_factory(model, conv5[2], 96, 96, kernel=3, pad=1, name='conv5_3_3') #96x35x35
conv5[3] = brew.average_pool(model, pool2, 'conv5_4_1_pool', kernel=3, stride=1, pad=1) #192x35x35
conv5[3] = self.conv_factory(model, conv5[3], 192, 64, kernel=1, name='conv5_4_2') #64x35x35
conv5 = brew.concat(model, conv5, blob_out='conv5') #320x35x35
#
block35 = conv5
for i in range(10):
block35 = self.block35(model, block35, num_in_channels=320,
scale=0.17, name='inception_resnet_v2_a%d'%(i+1)) #320x35x35
# ra - reduction_a
ra = [None, None, None]
ra[0] = self.conv_factory(model, block35, 320, 384, kernel=3, stride=2, name='ra_1_1') #384x17x17
ra[1] = self.conv_factory(model, block35, 320, 256, kernel=1, name='ra_2_1') #256x35x35
ra[1] = self.conv_factory(model, ra[1], 256, 256, kernel=3, pad=1, name='ra_2_2') #256x35x35
ra[1] = self.conv_factory(model, ra[1], 256, 384, kernel=3, stride=2, name='ra_2_3') #384x17x17
ra[2] = brew.max_pool(model, block35, 'ra_3_1_pool', kernel=3, stride=2) #320x17x17
ra = brew.concat(model, ra, blob_out='ra') #1088x35x35
#
block17 = ra
for i in range(20):
block17 = self.block17(model, block17, num_in_channels=1088,
scale=0.1, name='inception_resnet_v2_b%d'%(i+1)) #1088x35x35
# rb -reduction_b
rb = [None, None, None, None]
rb[0] = self.conv_factory(model, block17, 1088, 256, kernel=1, name='rb_1_1') #256x17x17
rb[0] = self.conv_factory(model, rb[0], 256, 384, kernel=3, stride=2, name='rb_1_2') #384x8x8
rb[1] = self.conv_factory(model, block17, 1088, 256, kernel=1, name='rb_2_1') #256x17x17
rb[1] = self.conv_factory(model, rb[1], 256, 288, kernel=3, stride=2, name='rb_2_2') #288x8x8
rb[2] = self.conv_factory(model, block17, 1088, 256, kernel=1, name='rb_3_1') #256x17x17
rb[2] = self.conv_factory(model, rb[2], 256, 288, kernel=3, pad=1, name='rb_3_2') #288x17x17
rb[2] = self.conv_factory(model, rb[2], 288, 320, kernel=3, stride=2, name='rb_3_3') #320x8x8
rb[3] = brew.max_pool(model, block17, 'rb_4_1_pool', kernel=3, stride=2) #1088x8x8
rb = brew.concat(model, rb, blob_out='rb') #2080x8x8
#
block8 = rb
for i in range(9):
block8 = self.block8(model, block8, num_in_channels=2080,
scale=0.2, name='inception_resnet_v2_c%d'%(i+1)) #2080x8x8
block8 = self.block8(model, block8, num_in_channels=2080, relu=False,
name='inception_resnet_v2_c10') #2080x8x8
#
conv6 = self.conv_factory(model, block8, 2080, 1536, kernel=1, name='conv6') #1536x8x8
pool8 = brew.average_pool(model, conv6, 'pool8', kernel=8, global_pool=True) #1536x1x1
drop8 = brew.dropout(model, pool8, 'dtop8', ratio=0.2, #1536x1x1
is_test=(self.phase == 'inference'))
if not self.__run_with_resnet50_trainer:
return self.add_head_nodes(model, drop8, 1536, 'classifier', loss_scale=loss_scale)
else:
return brew.fc(model, drop8, 'classifier', dim_in=1536, dim_out=self.num_classes)
def create_unet_model(m, device_opts, is_test):
base_n_filters = 16
kernel_size = 3
pad = (kernel_size - 1) / 2
do_dropout = True
num_classes = 3
weight_init = ("MSRAFill", {})
with core.DeviceScope(device_opts):
contr_1_1 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
'data',
'conv_1_1',
dim_in=num_classes,
dim_out=base_n_filters,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_1_1'),
'contr_1_1',
dim_in=base_n_filters,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
contr_1_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
contr_1_1,
'conv_1_2',
dim_in=base_n_filters,
dim_out=base_n_filters,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_1_2'),
'contr_1_2',
dim_in=base_n_filters,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
pool1 = brew.max_pool(m, contr_1_2, 'pool1', kernel=2, stride=2)
contr_2_1 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
pool1,
'conv_2_1',
dim_in=base_n_filters,
dim_out=base_n_filters * 2,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_2_1'),
'contr_2_1',
dim_in=base_n_filters * 2,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
contr_2_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
contr_2_1,
'conv_2_2',
dim_in=base_n_filters * 2,
dim_out=base_n_filters * 2,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_2_2'),
'contr_2_2',
dim_in=base_n_filters * 2,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
pool2 = brew.max_pool(m, contr_2_2, 'pool2', kernel=2, stride=2)
contr_3_1 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
pool2,
'conv_3_1',
dim_in=base_n_filters * 2,
dim_out=base_n_filters * 4,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_3_1'),
'contr_3_1',
dim_in=base_n_filters * 4,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
contr_3_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
contr_3_1,
'conv_3_2',
dim_in=base_n_filters * 4,
dim_out=base_n_filters * 4,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_3_2'),
'contr_3_2',
dim_in=base_n_filters * 4,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
pool3 = brew.max_pool(m, contr_3_2, 'pool3', kernel=2, stride=2)
contr_4_1 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
pool3,
'conv_4_1',
dim_in=base_n_filters * 4,
dim_out=base_n_filters * 8,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_4_1'),
'contr_4_1',
dim_in=base_n_filters * 8,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
contr_4_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
contr_4_1,
'conv_4_2',
dim_in=base_n_filters * 8,
dim_out=base_n_filters * 8,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_4_2'),
'contr_4_2',
dim_in=base_n_filters * 8,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
pool4 = brew.max_pool(m, contr_4_2, 'pool4', kernel=2, stride=2)
if do_dropout:
pool4 = brew.dropout(m, pool4, 'drop', ratio=0.4)
encode_5_1 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
pool4,
'conv_5_1',
dim_in=base_n_filters * 8,
dim_out=base_n_filters * 16,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_5_1'),
'encode_5_1',
dim_in=base_n_filters * 16,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
encode_5_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
encode_5_1,
'conv_5_2',
dim_in=base_n_filters * 16,
dim_out=base_n_filters * 16,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_5_2'),
'encode_5_2',
dim_in=base_n_filters * 16,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
upscale5 = brew.conv_transpose(m,
encode_5_2,
'upscale5',
dim_in=base_n_filters * 16,
dim_out=base_n_filters * 16,
kernel=2,
stride=2,
weight_init=weight_init)
concat6 = brew.concat(m, [upscale5, contr_4_2], 'concat6') #, axis=1)
expand_6_1 = brew.spatial_bn(
m,
brew.relu(
m,
brew.conv(m,
concat6,
'conv_6_1',
dim_in=base_n_filters * 8 * 3,
dim_out=base_n_filters * 8,
kernel=kernel_size,
pad=pad,
weight_init=weight_init), 'nonl_6_1'),
'expand_6_1',
dim_in=base_n_filters * 8,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
expand_6_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
expand_6_1,
'conv_6_2',
dim_in=base_n_filters * 8,
dim_out=base_n_filters * 8,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_6_2'),
'expand_6_2',
dim_in=base_n_filters * 8,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
upscale6 = brew.conv_transpose(m,
expand_6_2,
'upscale6',
dim_in=base_n_filters * 8,
dim_out=base_n_filters * 8,
kernel=2,
stride=2,
weight_init=weight_init)
concat7 = brew.concat(m, [upscale6, contr_3_2], 'concat7')
expand_7_1 = brew.spatial_bn(
m,
brew.relu(
m,
brew.conv(m,
concat7,
'conv_7_1',
dim_in=base_n_filters * 4 * 3,
dim_out=base_n_filters * 4,
kernel=kernel_size,
pad=pad,
weight_init=weight_init), 'nonl_7_1'),
'expand_7_1',
dim_in=base_n_filters * 4,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
expand_7_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
expand_7_1,
'conv_7_2',
dim_in=base_n_filters * 4,
dim_out=base_n_filters * 4,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_7_2'),
'expand_7_2',
dim_in=base_n_filters * 4,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
upscale7 = brew.conv_transpose(m,
expand_7_2,
'upscale7',
dim_in=base_n_filters * 4,
dim_out=base_n_filters * 4,
kernel=2,
stride=2,
weight_init=weight_init)
concat8 = brew.concat(m, [upscale7, contr_2_2], 'concat8')
expand_8_1 = brew.spatial_bn(
m,
brew.relu(
m,
brew.conv(m,
concat8,
'conv_8_1',
dim_in=base_n_filters * 2 * 3,
dim_out=base_n_filters * 2,
kernel=kernel_size,
pad=pad,
weight_init=weight_init), 'nonl_8_1'),
'expand_8_1',
dim_in=base_n_filters * 2,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
expand_8_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
expand_8_1,
'conv_8_2',
dim_in=base_n_filters * 2,
dim_out=base_n_filters * 2,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_8_2'),
'expand_8_2',
dim_in=base_n_filters * 2,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
upscale8 = brew.conv_transpose(m,
expand_8_2,
'upscale8',
dim_in=base_n_filters * 2,
dim_out=base_n_filters * 2,
kernel=2,
stride=2,
weight_init=weight_init)
concat9 = brew.concat(m, [upscale8, contr_1_2], 'concat9')
expand_9_1 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
concat9,
'conv_9_1',
dim_in=base_n_filters * 3,
dim_out=base_n_filters,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_9_1'),
'expand_9_1',
dim_in=base_n_filters,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
expand_9_2 = brew.spatial_bn(m,
brew.relu(
m,
brew.conv(m,
expand_9_1,
'conv_9_2',
dim_in=base_n_filters,
dim_out=base_n_filters,
kernel=kernel_size,
pad=pad,
weight_init=weight_init),
'nonl_9_2'),
'expand_9_2',
dim_in=base_n_filters,
epsilon=1e-3,
momentum=0.1,
is_test=is_test)
output_segmentation = brew.conv(m,
expand_9_2,
'output_segmentation',
dim_in=base_n_filters,
dim_out=num_classes,
kernel=1,
pad=0,
stride=1,
weight_init=weight_init)
m.net.AddExternalOutput(output_segmentation)
output_sigmoid = m.Sigmoid(output_segmentation, 'output_sigmoid')
m.net.AddExternalOutput(output_sigmoid)
return output_segmentation
def Concat(self, *args, **kwargs):
return brew.concat(self, *args, order=self.order, **kwargs)
def _InceptionModule(
model, input_blob, input_depth, output_name, conv1_depth, conv3_depths,
conv5_depths, pool_depth
):
# path 1: 1x1 conv
conv1 = brew.conv(
model, input_blob, output_name + ":conv1", input_depth, conv1_depth, 1,
('XavierFill', {}), ('ConstantFill', {})
)
conv1 = brew.relu(model, conv1, conv1)
# path 2: 1x1 conv + 3x3 conv
conv3_reduce = brew.conv(
model, input_blob, output_name + ":conv3_reduce", input_depth,
conv3_depths[0], 1, ('XavierFill', {}), ('ConstantFill', {})
)
conv3_reduce = brew.relu(model, conv3_reduce, conv3_reduce)
conv3 = brew.conv(
model,
conv3_reduce,
output_name + ":conv3",
conv3_depths[0],
conv3_depths[1],
3,
('XavierFill', {}),
('ConstantFill', {}),
pad=1
)
conv3 = brew.relu(model, conv3, conv3)
# path 3: 1x1 conv + 5x5 conv
conv5_reduce = brew.conv(
model, input_blob, output_name + ":conv5_reduce", input_depth,
conv5_depths[0], 1, ('XavierFill', {}), ('ConstantFill', {})
)
conv5_reduce = brew.relu(model, conv5_reduce, conv5_reduce)
conv5 = brew.conv(
model,
conv5_reduce,
output_name + ":conv5",
conv5_depths[0],
conv5_depths[1],
5,
('XavierFill', {}),
('ConstantFill', {}),
pad=2
)
conv5 = brew.relu(model, conv5, conv5)
# path 4: pool + 1x1 conv
pool = brew.max_pool(
model,
input_blob,
output_name + ":pool",
kernel=3,
stride=1,
pad=1
)
pool_proj = brew.conv(
model, pool, output_name + ":pool_proj", input_depth, pool_depth, 1,
('XavierFill', {}), ('ConstantFill', {})
)
pool_proj = brew.relu(model, pool_proj, pool_proj)
output = brew.concat(model, [conv1, conv3, conv5, pool_proj], output_name)
return output
