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 _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