def CreateMultiBoxHead(net, data_layer="data", num_classes=[], from_layers=[], use_objectness=False, normalizations=[], use_batchnorm=True, min_sizes=[], max_sizes=[], prior_variance=[0.1], aspect_ratios=[], share_location=True, flip=True, clip=True, inter_layer_depth=0, kernel_size=1, pad=0, conf_postfix='', loc_postfix=''): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" if normalizations: assert len(from_layers) == len( normalizations ), "from_layers and normalizations should have same length" assert len(from_layers) == len( min_sizes), "from_layers and min_sizes should have same length" if max_sizes: assert len(from_layers) == len( max_sizes), "from_layers and max_sizes should have same length" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers" num = len(from_layers) priorbox_layers = [] loc_layers = [] conf_layers = [] objectness_layers = [] for i in range(0, num): from_layer = from_layers[i] # Get the normalize value. if normalizations: if normalizations[i] != -1: norm_name = "{}_norm".format(from_layer) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict( type="constant", value=normalizations[i]), across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate layers. if inter_layer_depth > 0: inter_name = "{}_inter".format(from_layer) ConvBNLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, num_output=inter_layer_depth, kernel_size=3, pad=1, stride=1) from_layer = inter_name # Estimate number of priors per location given provided parameters. aspect_ratio = [] if len(aspect_ratios) > i: aspect_ratio = aspect_ratios[i] if type(aspect_ratio) is not list: aspect_ratio = [aspect_ratio] if max_sizes and max_sizes[i]: num_priors_per_location = 2 + len(aspect_ratio) else: num_priors_per_location = 1 + len(aspect_ratio) if flip: num_priors_per_location += len(aspect_ratio) num_priors_per_location = 2 * num_priors_per_location # Create location prediction layer. name = "{}_mbox_loc{}".format(from_layer, loc_postfix) num_loc_output = num_priors_per_location * 4 if not share_location: num_loc_output *= num_classes ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layers.append(net[flatten_name]) # Create confidence prediction layer. name = "{}_mbox_conf{}".format(from_layer, conf_postfix) num_conf_output = num_priors_per_location * num_classes ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layers.append(net[flatten_name]) # Create prior generation layer. name = "{}_mbox_priorbox".format(from_layer) if max_sizes and max_sizes[i]: if aspect_ratio: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes[i], max_size=max_sizes[i], aspect_ratio=aspect_ratio, flip=flip, clip=clip, variance=prior_variance) else: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes[i], max_size=max_sizes[i], clip=clip, variance=prior_variance) else: if aspect_ratio: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes[i], aspect_ratio=aspect_ratio, flip=flip, clip=clip, variance=prior_variance) else: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes[i], clip=clip, variance=prior_variance) priorbox_layers.append(net[name]) # Create objectness prediction layer. if use_objectness: name = "{}_mbox_objectness".format(from_layer) num_obj_output = num_priors_per_location * 2 ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, num_output=num_obj_output, kernel_size=kernel_size, pad=pad, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) objectness_layers.append(net[flatten_name]) # Concatenate priorbox, loc, and conf layers. mbox_layers = [] name = "mbox_loc" net[name] = L.Concat(*loc_layers, axis=1) mbox_layers.append(net[name]) name = "mbox_conf" net[name] = L.Concat(*conf_layers, axis=1) mbox_layers.append(net[name]) name = "mbox_priorbox" net[name] = L.Concat(*priorbox_layers, axis=2) mbox_layers.append(net[name]) if use_objectness: name = "mbox_objectness" net[name] = L.Concat(*objectness_layers, axis=1) mbox_layers.append(net[name]) return mbox_layers
def CreateMultiBoxHeadForCoreML(net, data_layer="data", num_classes=[], from_layers=[], use_objectness=False, normalizations=[], use_batchnorm=True, lr_mult=1, use_scale=True, min_sizes=[], max_sizes=[], prior_variance = [0.1], aspect_ratios=[], steps=[], img_height=0, img_width=0, share_location=True, flip=True, clip=True, offset=0.5, inter_layer_depth=[], kernel_size=1, pad=0, conf_postfix='', loc_postfix='', head_postfix='ext/pm', **bn_param): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" if normalizations: assert len(from_layers) == len(normalizations), "from_layers and normalizations should have same length" assert len(from_layers) == len(min_sizes), "from_layers and min_sizes should have same length" if max_sizes: assert len(from_layers) == len(max_sizes), "from_layers and max_sizes should have same length" if aspect_ratios: assert len(from_layers) == len(aspect_ratios), "from_layers and aspect_ratios should have same length" if steps: assert len(from_layers) == len(steps), "from_layers and steps should have same length" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers" if inter_layer_depth: assert len(from_layers) == len(inter_layer_depth), "from_layers and inter_layer_depth should have same length" num = len(from_layers) priorbox_layers = [] loc_layers = [] conf_layers = [] objectness_layers = [] for i in range(0, num): from_layer = from_layers[i] # Get the normalize value. if normalizations: if normalizations[i] != -1: norm_name = "{}{}_norm".format(head_postfix, i+1) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalizations[i]), across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate layers. if inter_layer_depth: if inter_layer_depth[i] > 0: inter_name = "{}{}_inter".format(head_postfix, i+1) ConvBNLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, lr_mult=lr_mult, num_output=inter_layer_depth[i], kernel_size=3, pad=1, stride=1, **bn_param) from_layer = inter_name # Estimate number of priors per location given provided parameters. min_size = min_sizes[i] if type(min_size) is not list: min_size = [min_size] aspect_ratio = [] if len(aspect_ratios) > i: aspect_ratio = aspect_ratios[i] if type(aspect_ratio) is not list: aspect_ratio = [aspect_ratio] max_size = [] if len(max_sizes) > i: max_size = max_sizes[i] if type(max_size) is not list: max_size = [max_size] if max_size: assert len(max_size) == len(min_size), "max_size and min_size should have same length." if max_size: num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size) else: num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size) if flip: num_priors_per_location += len(aspect_ratio) * len(min_size) step = [] if len(steps) > i: step = steps[i] # Create location prediction layer. name = "{}{}_mbox_loc{}".format(head_postfix, i+1, loc_postfix) num_loc_output = num_priors_per_location * 4; if not share_location: num_loc_output *= num_classes ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) loc_layers.append(net[name]) # permute_name = "{}_perm".format(name) # net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) # flatten_name = "{}_flat".format(name) # net[flatten_name] = L.Flatten(net[permute_name], axis=1) # loc_layers.append(net[flatten_name]) # Create confidence prediction layer. name = "{}{}_mbox_conf{}".format(head_postfix, i+1, conf_postfix) num_conf_output = num_priors_per_location * num_classes; ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) conf_layers.append(net[name]) return conf_layers, loc_layers
def ACT_CreateCuboidHead(net, K=6, data_layer="data", num_classes=[], from_layers=[], normalizations=[], use_batchnorm=True, lr_mult=1, use_scale=True, min_sizes=[], max_sizes=[], prior_variance = [0.1], aspect_ratios=[], steps=[], img_height=0, img_width=0, share_location=True, flip=True, clip=True, offset=0.5, kernel_size=1, pad=0, conf_postfix='', loc_postfix='', m='', fusion="concat", **bn_param): ##################### 3 change it!!! ####################################### assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" if normalizations: assert len(from_layers) == len(normalizations), "from_layers and normalizations should have same length" assert len(from_layers) == len(min_sizes), "from_layers and min_sizes should have same length" if max_sizes: assert len(from_layers) == len(max_sizes), "from_layers and max_sizes should have same length" if aspect_ratios: assert len(from_layers) == len(aspect_ratios), "from_layers and aspect_ratios should have same length" if steps: assert len(from_layers) == len(steps), "from_layers and steps should have same length" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers" num = len(from_layers) priorbox_layers = [] loc_layers = [] conf_layers = [] for i in range(0, num): from_layer = from_layers[i] # Get the normalize value. if normalizations: if normalizations[i] != -1: for stream in xrange(K): norm_name = "{}_norm_stream{}{}".format(from_layer, stream, m) net[norm_name] = L.Normalize(net[from_layer + '_stream' + str(stream) + m], scale_filler=dict(type="constant", value=normalizations[i]), across_spatial=False, channel_shared=False) from_layer = "{}_norm".format(from_layer) # ACT: add a concatenation layer across streams if fusion == "concat": net[from_layer + '_concat'] = L.Concat( bottom=[from_layer + '_stream' + str(stream) + m for stream in xrange(K)], axis=1) from_layer += '_concat' else: assert fusion == "sum" net[from_layer + '_sum'] = L.EltWise( bottom=[from_layer + '_stream' + str(stream) + m for stream in xrange(K)]) from_layer += '_sum' # Estimate number of priors per location given provided parameters. min_size = min_sizes[i] if type(min_size) is not list: min_size = [min_size] aspect_ratio = [] if len(aspect_ratios) > i: aspect_ratio = aspect_ratios[i] if type(aspect_ratio) is not list: aspect_ratio = [aspect_ratio] max_size = [] if len(max_sizes) > i: max_size = max_sizes[i] if type(max_size) is not list: max_size = [max_size] if max_size: assert len(max_size) == len(min_size), "max_size and min_size should have same length." if max_size: num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size) else: num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size) if flip: num_priors_per_location += len(aspect_ratio) * len(min_size) step = [] if len(steps) > i: step = steps[i] # ACT-detector: location prediction layer # location prediction for K different frames name = "{}_mbox_loc{}".format(from_layer, loc_postfix) num_loc_output = num_priors_per_location * 4 * K if not share_location: num_loc_output *= num_classes ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layers.append(net[flatten_name]) # ACT-detector: confidence prediction layer # joint prediction of all frames name = "{}_mbox_conf{}".format(from_layer, conf_postfix) num_conf_output = num_priors_per_location * num_classes; ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layers.append(net[flatten_name]) # Create prior generation layer. name = "{}_mbox_priorbox".format(from_layer) net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_size, clip=clip, variance=prior_variance, offset=offset) if max_size: net.update(name, {'max_size': max_size}) if aspect_ratio: net.update(name, {'aspect_ratio': aspect_ratio, 'flip': flip}) if step: net.update(name, {'step': step}) if img_height != 0 and img_width != 0: if img_height == img_width: net.update(name, {'img_size': img_height}) else: net.update(name, {'img_h': img_height, 'img_w': img_width}) priorbox_layers.append(net[name]) # Concatenate priorbox, loc, and conf layers. mbox_layers = [] name = "mbox_loc" net[name] = L.Concat(*loc_layers, axis=1) mbox_layers.append(net[name]) name = "mbox_conf" net[name] = L.Concat(*conf_layers, axis=1) mbox_layers.append(net[name]) name = "mbox_priorbox" net[name] = L.Concat(*priorbox_layers, axis=2) mbox_layers.append(net[name]) return mbox_layers
def UnitLayerDenseDetectorHeader(net, data_layer="data", num_classes=2, feature_layer="conv5", \ normalization=-1, use_batchnorm=True, prior_variance = [0.1], \ pro_widths=[], pro_heights=[], flip=True, clip=True, \ inter_layer_channels=0, flat=False, use_focus_loss=False, stage=1,lr_mult=1.0,decay_mult=1.0,flag_withparamname=False,add_str = ""): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers." assert feature_layer + add_str in net_layers, "feature_layer is not in net's layers.(%s)" % ( feature_layer + add_str) assert pro_widths, "Must provide proposed width/height." assert pro_heights, "Must provide proposed width/height." assert len(pro_widths) == len( pro_heights), "pro_widths/heights must have the same length." from_layer = feature_layer prefix_name = '{}_{}'.format(from_layer, stage) from_layer += add_str # Norm-Layer if normalization != -1: norm_name = "{}_norm".format(prefix_name) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalization), \ across_spatial=False, channel_shared=False) from_layer = norm_name # InterLayers if not inter_layer_channels == 0: if len(inter_layer_channels) > 0: start_inter_id = 1 for inter_channel_kernel in inter_layer_channels: inter_channel = inter_channel_kernel[0] inter_kernel = inter_channel_kernel[1] inter_name = "{}_inter_{}".format(prefix_name, start_inter_id) if inter_kernel == 1: inter_pad = 0 elif inter_kernel == 3: inter_pad = 1 ConvBNUnitLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, num_output=inter_channel, kernel_size=inter_kernel, pad=inter_pad, stride=1, use_scale=True, leaky=False, lr_mult=lr_mult, decay_mult=decay_mult, flag_withparamname=flag_withparamname, pose_string=add_str) from_layer = inter_name + add_str start_inter_id = start_inter_id + 1 # PriorBoxes num_priors_per_location = len(pro_widths) print "num_priors_per_location:", num_priors_per_location # LOC name = "{}_mbox_loc".format(prefix_name) num_loc_output = num_priors_per_location * 4 * (num_classes - 1) ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_loc_output, kernel_size=3, pad=1, stride=1,lr_mult=lr_mult, decay_mult=decay_mult,pose_string=add_str) permute_name = "{}_perm".format(name) + add_str net[permute_name] = L.Permute(net[name + add_str], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) + add_str net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layer = net[flatten_name] else: loc_layer = net[permute_name] # CONF name = "{}_mbox_conf".format(prefix_name) + add_str num_conf_output = num_priors_per_location * num_classes if use_focus_loss: ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=3, pad=1, stride=1,init_xavier=False,bias_type='focal',sparse=num_classes, lr_mult=lr_mult, decay_mult=decay_mult,pose_string=add_str) else: ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=3, pad=1, stride=1,lr_mult=lr_mult, decay_mult=decay_mult,pose_string=add_str) permute_name = "{}_perm".format(name) + add_str net[permute_name] = L.Permute(net[name + add_str], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) + add_str net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layer = net[flatten_name] else: conf_layer = net[permute_name] # PRIOR name = "{}_mbox_priorbox".format(prefix_name) + add_str net[name] = L.PriorBox(net[from_layer], net[data_layer], pro_width=pro_widths, pro_height=pro_heights, \ flip=flip, clip=clip, variance=prior_variance) priorbox_layer = net[name] return loc_layer, conf_layer, priorbox_layer
def McDetectorHeader(net, num_classes=1, feature_layer="conv5", \ normalization=-1, use_batchnorm=False, boxsizes=[], aspect_ratios=[], pwidths=[], pheights=[], \ inter_layer_channels=0, kernel_size=1, pad=0): assert num_classes > 0, "num_classes must be positive number" net_layers = net.keys() assert feature_layer in net_layers, "feature_layer is not in net's layers." if boxsizes: assert not pwidths, "pwidths should not be provided when using boxsizes." assert not pheights, "pheights should not be provided when using boxsizes." assert aspect_ratios, "aspect_ratios should be provided when using boxsizes." else: assert pwidths, "Must provide proposed width/height." assert pheights, "Must provide proposed width/height." assert len(pwidths) == len( pheights), "provided widths/heights must have the same length." assert not boxsizes, "boxsizes should be not provided when using pro_widths/heights." assert not aspect_ratios, "aspect_ratios should be not provided when using pro_widths/heights." from_layer = feature_layer loc_conf_layers = [] # Norm-Layer if normalization > 0: norm_name = "{}_norm".format(from_layer) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalization), \ across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate Conv layers. if inter_layer_channels > 0: inter_name = "{}_inter".format(from_layer) ConvBNUnitLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, \ num_output=inter_layer_channels, kernel_size=3, pad=1, stride=1) from_layer = inter_name # Estimate number of priors per location given provided parameters. if boxsizes: num_priors_per_location = len(aspect_ratios) * len(boxsizes) + 1 else: num_priors_per_location = len(pwidths) + 1 # Create location prediction layer. name = "{}_loc".format(from_layer) num_loc_output = num_priors_per_location * 4 ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) loc_conf_layers.append(net[permute_name]) # Create confidence prediction layer. name = "{}_conf".format(from_layer) num_conf_output = num_priors_per_location * (num_classes + 1) ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) loc_conf_layers.append(net[permute_name]) return loc_conf_layers
def UnitLayerDetectorHeader(net, data_layer="data", num_classes=2, feature_layer="conv5", \ use_objectness=False, normalization=-1, use_batchnorm=True, prior_variance = [0.1], \ min_sizes=[], max_sizes=[], aspect_ratios=[], pro_widths=[], pro_heights=[], \ share_location=True, flip=True, clip=False, inter_layer_channels=0, kernel_size=1, \ pad=0, conf_postfix='', loc_postfix='', flat=False, use_focus_loss=False,stage=1): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers." assert feature_layer in net_layers, "feature_layer is not in net's layers." if min_sizes: assert not pro_widths, "pro_widths should not be provided when using min_sizes." assert not pro_heights, "pro_heights should not be provided when using min_sizes." if max_sizes: assert len(max_sizes) == len( min_sizes ), "min_sizes and max_sizes must have the same legnth." else: assert pro_widths, "Must provide proposed width/height." assert pro_heights, "Must provide proposed width/height." assert len(pro_widths) == len( pro_heights), "pro_widths/heights must have the same length." assert not min_sizes, "min_sizes should be not provided when using pro_widths/heights." assert not max_sizes, "max_sizes should be not provided when using pro_widths/heights." from_layer = feature_layer prefix_name = '{}_{}'.format(from_layer, stage) # Norm-Layer if normalization != -1: norm_name = "{}_{}_norm".format(prefix_name, stage) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalization), \ across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate Conv layers. # if inter_layer_channels > 0: # inter_name = "{}_inter".format(from_layer) # ConvBNUnitLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, \ # num_output=inter_layer_channels, kernel_size=kernel_size, pad=pad, stride=1,use_scale=True, leaky=True) # from_layer = inter_name if len(inter_layer_channels) > 0: start_inter_id = 1 for inter_channel_kernel in inter_layer_channels: inter_channel = inter_channel_kernel[0] inter_kernel = inter_channel_kernel[1] inter_name = "{}_inter_{}".format(prefix_name, start_inter_id) if inter_kernel == 1: inter_pad = 0 elif inter_kernel == 3: inter_pad = 1 ConvBNUnitLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, \ num_output=inter_channel, kernel_size=inter_kernel, pad=inter_pad, stride=1,use_scale=True, leaky=False) from_layer = inter_name start_inter_id = start_inter_id + 1 # Estimate number of priors per location given provided parameters. if min_sizes: if aspect_ratios: num_priors_per_location = len(aspect_ratios) + 1 if flip: num_priors_per_location += len(aspect_ratios) if max_sizes: num_priors_per_location += 1 num_priors_per_location *= len(min_sizes) else: if max_sizes: num_priors_per_location = 2 * len(min_sizes) else: num_priors_per_location = len(min_sizes) else: num_priors_per_location = len(pro_widths) # Create location prediction layer. name = "{}_mbox_loc{}".format(prefix_name, loc_postfix) num_loc_output = num_priors_per_location * 4 * (num_classes - 1) if not share_location: num_loc_output *= num_classes ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_loc_output, kernel_size=3, pad=1, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layer = net[flatten_name] else: loc_layer = net[permute_name] # Create confidence prediction layer. name = "{}_mbox_conf{}".format(prefix_name, conf_postfix) num_conf_output = num_priors_per_location * num_classes if use_focus_loss: ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=3, pad=1, stride=1,init_xavier=False,bias_type='focal',sparse=num_classes) else: ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=3, pad=1, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layer = net[flatten_name] else: conf_layer = net[permute_name] # Create prior generation layer. name = "{}_mbox_priorbox".format(prefix_name) if min_sizes: if aspect_ratios: if max_sizes: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes, max_size=max_sizes, \ aspect_ratio=aspect_ratios, flip=flip, clip=clip, variance=prior_variance) else: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes, \ aspect_ratio=aspect_ratios, flip=flip, clip=clip, variance=prior_variance) else: if max_sizes: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes, max_size=max_sizes, \ flip=flip, clip=clip, variance=prior_variance) else: net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_sizes, \ flip=flip, clip=clip, variance=prior_variance) priorbox_layer = net[name] else: net[name] = L.PriorBox(net[from_layer], net[data_layer], pro_width=pro_widths, pro_height=pro_heights, \ flip=flip, clip=clip, variance=prior_variance) priorbox_layer = net[name] # Create objectness prediction layer. if use_objectness: name = "{}_mbox_objectness".format(prefix_name) num_obj_output = num_priors_per_location * 2 ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_obj_output, kernel_size=kernel_size, pad=pad, stride=1) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) objectness_layer = net[flatten_name] else: objectness_layer = net[permute_name] if use_objectness: return loc_layer, conf_layer, priorbox_layer, objectness_layer else: return loc_layer, conf_layer, priorbox_layer
def UnitLayerDetectorHeader(net, data_layer="data", num_classes=2, feature_layer="conv5", \ normalization=-1, use_batchnorm=True, prior_variance = [0.1], \ pro_widths=[], pro_heights=[], flip=True, clip=True, inter_layer_channels=[], \ flat=False, use_focus_loss=False, stage=1,lr_mult=1.0,decay_mult=1.0): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers." print feature_layer assert feature_layer in net_layers, "feature_layer is not in net's layers." assert pro_widths, "Must provide proposed width/height." assert pro_heights, "Must provide proposed width/height." assert len(pro_widths) == len( pro_heights), "pro_widths/heights must have the same length." from_layer = feature_layer prefix_name = '{}_{}'.format(from_layer, stage) # Norm-Layer if normalization != -1: norm_name = "{}_{}_norm".format(prefix_name, stage) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalization), \ across_spatial=False, channel_shared=False) from_layer = norm_name if len(inter_layer_channels) > 0: start_inter_id = 1 for inter_channel_kernel in inter_layer_channels: inter_channel = inter_channel_kernel[0] inter_kernel = inter_channel_kernel[1] inter_name = "{}_inter_{}".format(prefix_name, start_inter_id) if inter_kernel == 1: inter_pad = 0 elif inter_kernel == 3: inter_pad = 1 if inter_name in truncvalues.keys(): trunc_v = truncvalues[inter_name] use_batchnorm = False else: trunc_v = -1 ConvBNUnitLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, \ num_output=inter_channel, kernel_size=inter_kernel, pad=inter_pad, stride=1,use_scale=True, leaky=False, lr_mult=lr_mult, decay_mult=decay_mult,truncvalue = trunc_v) from_layer = inter_name start_inter_id = start_inter_id + 1 # Estimate number of priors per location given provided parameters. num_priors_per_location = len(pro_widths) # Create location prediction layer. name = "{}_mbox_loc".format(prefix_name) num_loc_output = num_priors_per_location * 4 if name in truncvalues.keys(): trunc_v = truncvalues[name] else: trunc_v = -1 ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_loc_output, kernel_size=3, pad=1, stride=1,lr_mult=lr_mult, decay_mult=decay_mult,truncvalue = trunc_v) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layer = net[flatten_name] else: loc_layer = net[permute_name] # Create confidence prediction layer. name = "{}_mbox_conf".format(prefix_name) num_conf_output = num_priors_per_location * num_classes if name in truncvalues.keys(): trunc_v = truncvalues[name] else: trunc_v = -1 if use_focus_loss: ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=3, pad=1, stride=1,init_xavier=False,bias_type='focal',sparse=num_classes, lr_mult=lr_mult, decay_mult=decay_mult,truncvalue = trunc_v) else: ConvBNUnitLayer(net, from_layer, name, use_bn=False, use_relu=False, \ num_output=num_conf_output, kernel_size=3, pad=1, stride=1,lr_mult=lr_mult, decay_mult=decay_mult,truncvalue = trunc_v) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) if flat: flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layer = net[flatten_name] else: conf_layer = net[permute_name] # Create prior generation layer. name = "{}_mbox_priorbox".format(prefix_name) net[name] = L.PriorBox(net[from_layer], net[data_layer], pro_width=pro_widths, pro_height=pro_heights, \ flip=flip, clip=clip, variance=prior_variance) priorbox_layer = net[name] return loc_layer, conf_layer, priorbox_layer
def fc_norm_triplet_dep(bottom, num_output): """ for SketchTriplet quick prototyping deploy network""" fc = L.InnerProduct(bottom, num_output=num_output) return fc, L.Normalize(fc, in_place=True)
def L_Normalize(input_blob, normalize_type='L2', rescale=1.0): output = L.Normalize(input_blob, normalize_type=normalize_type, rescale=rescale) return output
def CreateMultiBoxHead(net, data_layer="data", num_classes=[], from_layers=[], use_objectness=False, normalizations=[], use_batchnorm=True, lr_mult=1, use_scale=True, min_sizes=[], max_sizes=[], prior_variance=[0.1], aspect_ratios=[], steps=[], img_height=0, img_width=0, share_location=True, flip=True, clip=True, offset=0.5, inter_layer_depth=[], kernel_size=1, pad=0, conf_postfix='', loc_postfix='', max_out=0, **bn_param): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" if normalizations: assert len(from_layers) == len( normalizations ), "from_layers and normalizations should have same length" assert len(from_layers) == len( min_sizes), "from_layers and min_sizes should have same length" if max_sizes: assert len(from_layers) == len( max_sizes), "from_layers and max_sizes should have same length" if aspect_ratios: assert len(from_layers) == len( aspect_ratios ), "from_layers and aspect_ratios should have same length" if steps: assert len(from_layers) == len( steps), "from_layers and steps should have same length" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers" if inter_layer_depth: assert len(from_layers) == len( inter_layer_depth ), "from_layers and inter_layer_depth should have same length" num = len(from_layers) priorbox_layers = [] loc_layers = [] conf_layers = [] objectness_layers = [] for i in range(0, num): from_layer = from_layers[i] # Get the normalize value. if normalizations: if normalizations[i] != -1: norm_name = "{}_norm".format(from_layer) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict( type="constant", value=normalizations[i]), across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate layers. if inter_layer_depth: if inter_layer_depth[i] > 0: inter_name = "{}_inter".format(from_layer) ConvBNLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, lr_mult=lr_mult, num_output=inter_layer_depth[i], kernel_size=3, pad=1, stride=1, **bn_param) from_layer = inter_name # Estimate number of priors per location given provided parameters. min_size = min_sizes[i] if type(min_size) is not list: min_size = [min_size] aspect_ratio = [] if len(aspect_ratios) > i: aspect_ratio = aspect_ratios[i] if type(aspect_ratio) is not list: aspect_ratio = [aspect_ratio] max_size = [] if len(max_sizes) > i: max_size = max_sizes[i] if type(max_size) is not list: max_size = [max_size] if max_size: assert len(max_size) == len( min_size), "max_size and min_size should have same length." if max_size: num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size) else: num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size) if flip: num_priors_per_location += len(aspect_ratio) * len(min_size) step = [] if len(steps) > i: step = steps[i] # Create location prediction layer. name = "{}_mbox_loc{}".format(from_layer, loc_postfix) num_loc_output = num_priors_per_location * 4 if not share_location: num_loc_output *= num_classes if max_out > 0: slice_point = [] for i in range(max_out - 1): slice_point.append(num_loc_output * (i + 1)) ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output * max_out, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) net[name+'_slice_0'],net[name+'_slice_1'],net[name+'_slice_2'],net[name+'_slice_3'],\ net[name+'_slice_4'],net[name+'_slice_5'] ,\ net[name+'_slice_6'],net[name+'_slice_7'] ,\ net[name+'_slice_8'] = L.Slice(net[name],slice_param={'axis':1,'slice_point':slice_point},ntop = 9) net[name+'_max'] = L.Eltwise(net[name+'_slice_0'],net[name+'_slice_1'],net[name+'_slice_2'],net[name+'_slice_3'],\ net[name+'_slice_4'],net[name+'_slice_5'] ,\ net[name+'_slice_6'],net[name+'_slice_7'] ,\ net[name+'_slice_8'],eltwise_param = {'operation':2}) name = name + '_max' else: ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layers.append(net[flatten_name]) # Create confidence prediction layer. name = "{}_mbox_conf{}".format(from_layer, conf_postfix) num_conf_output = num_priors_per_location * num_classes if max_out > 0: ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_conf_output * max_out, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) slice_point = [] for i in xrange(max_out - 1): slice_point.append(num_conf_output * (i + 1)) net[name+'_slice_0'],net[name+'_slice_1'],net[name+'_slice_2'],net[name+'_slice_3'],\ net[name+'_slice_4'],net[name+'_slice_5'] ,\ net[name+'_slice_6'],net[name+'_slice_7'] ,\ net[name+'_slice_8'] = L.Slice(net[name],slice_param={'axis':1,'slice_point':slice_point},ntop = 9) net[name+'_max'] = L.Eltwise(net[name+'_slice_0'],net[name+'_slice_1'],net[name+'_slice_2'],net[name+'_slice_3'],\ net[name+'_slice_4'],net[name+'_slice_5'] ,\ net[name+'_slice_6'],net[name+'_slice_7'] ,\ net[name+'_slice_8'],eltwise_param = {'operation':2}) name = name + '_max' else: ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layers.append(net[flatten_name]) # Create prior generation layer. name = "{}_mbox_priorbox".format(from_layer) net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_size, clip=clip, variance=prior_variance, offset=offset) if max_size: net.update(name, {'max_size': max_size}) if aspect_ratio: net.update(name, {'aspect_ratio': aspect_ratio, 'flip': flip}) if step: net.update(name, {'step': step}) if img_height != 0 and img_width != 0: if img_height == img_width: net.update(name, {'img_size': img_height}) else: net.update(name, {'img_h': img_height, 'img_w': img_width}) priorbox_layers.append(net[name]) # Create objectness prediction layer. if use_objectness: name = "{}_mbox_objectness".format(from_layer) num_obj_output = num_priors_per_location * 2 ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_obj_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) objectness_layers.append(net[flatten_name]) # Concatenate priorbox, loc, and conf layers. mbox_layers = [] name = "mbox_loc" net[name] = L.Concat(*loc_layers, axis=1) mbox_layers.append(net[name]) name = "mbox_conf" net[name] = L.Concat(*conf_layers, axis=1) mbox_layers.append(net[name]) name = "mbox_priorbox" net[name] = L.Concat(*priorbox_layers, axis=2) mbox_layers.append(net[name]) if use_objectness: name = "mbox_objectness" net[name] = L.Concat(*objectness_layers, axis=1) mbox_layers.append(net[name]) return mbox_layers
def CreateRefineDetHead(net, data_layer="data", num_classes=[], from_layers=[], from_layers2=[], normalizations=[], use_batchnorm=True, lr_mult=1, min_sizes=[], max_sizes=[], prior_variance = [0.1], aspect_ratios=[], steps=[], img_height=0, img_width=0, share_location=True, flip=True, clip=True, offset=0.5, inter_layer_depth=[], kernel_size=1, pad=0, conf_postfix='', loc_postfix='', **bn_param): assert num_classes, "must provide num_classes" assert num_classes > 0, "num_classes must be positive number" if normalizations: assert len(from_layers) == len(normalizations), "from_layers and normalizations should have same length" assert len(from_layers) == len(min_sizes), "from_layers and min_sizes should have same length" if max_sizes: assert len(from_layers) == len(max_sizes), "from_layers and max_sizes should have same length" if aspect_ratios: assert len(from_layers) == len(aspect_ratios), "from_layers and aspect_ratios should have same length" if steps: assert len(from_layers) == len(steps), "from_layers and steps should have same length" net_layers = net.keys() assert data_layer in net_layers, "data_layer is not in net's layers" if inter_layer_depth: assert len(from_layers) == len(inter_layer_depth), "from_layers and inter_layer_depth should have same length" use_relu = True conv_prefix = '' conv_postfix = '' bn_prefix = '' bn_postfix = '/bn' scale_prefix = '' scale_postfix = '/scale' kwargs = { 'param': [dict(lr_mult=1, decay_mult=1)], 'weight_filler': dict(type='gaussian', std=0.01), 'bias_term': False, } kwargs2 = { 'param': [dict(lr_mult=1, decay_mult=1)], 'weight_filler': dict(type='gaussian', std=0.01), } kwargs_sb = { 'axis': 0, 'bias_term': False } prefix = 'arm' num_classes_rpn = 2 num = len(from_layers) priorbox_layers = [] loc_layers = [] conf_layers = [] for i in range(0, num): from_layer = from_layers[i] # Get the normalize value. if normalizations: if normalizations[i] != -1: norm_name = "{}_norm".format(from_layer) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalizations[i]), across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate layers. if inter_layer_depth: if inter_layer_depth[i] > 0: # Inter layer from body to head inter_name = "{}_inter".format(from_layer) # Depthwise convolution layer inter_dw = inter_name + '/dw' DWConvBNLayer(net, from_layer, inter_dw, use_bn=True, use_relu=True, num_output=512, group=512, kernel_size=3, pad=1, stride=1, conv_prefix=conv_prefix, conv_postfix=inter_dw, bn_prefix=bn_prefix, bn_postfix=bn_postfix, scale_prefix=scale_prefix, scale_postfix=scale_postfix, **bn_param) # Seperate layer inter_sep = inter_name + '/sep' ConvBNLayer(net, inter_dw, inter_sep, use_bn=True, use_relu=True, num_output=512, kernel_size=1, pad=0, stride=1, conv_prefix=conv_prefix, conv_postfix=inter_sep, bn_prefix=bn_prefix, bn_postfix=bn_postfix, scale_prefix=scale_prefix, scale_postfix=scale_postfix, **bn_param) # Bridge of rest of head from_layer = inter_sep # Estimate number of priors per location given provided parameters. min_size = min_sizes[i] if type(min_size) is not list: min_size = [min_size] aspect_ratio = [] if len(aspect_ratios) > i: aspect_ratio = aspect_ratios[i] if type(aspect_ratio) is not list: aspect_ratio = [aspect_ratio] max_size = [] if len(max_sizes) > i: max_size = max_sizes[i] if type(max_size) is not list: max_size = [max_size] if max_size: assert len(max_size) == len(min_size), "max_size and min_size should have same length." if max_size: num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size) else: num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size) if flip: num_priors_per_location += len(aspect_ratio) * len(min_size) step = [] if len(steps) > i: step = steps[i] # Create location prediction layer. name = "{}_mbox_loc{}".format(from_layer, loc_postfix) num_loc_output = num_priors_per_location * 4 if not share_location: num_loc_output *= num_classes_rpn ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layers.append(net[flatten_name]) # Create confidence prediction layer. name = "{}_mbox_conf{}".format(from_layer, conf_postfix) num_conf_output = num_priors_per_location * num_classes_rpn ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layers.append(net[flatten_name]) # Create prior generation layer. name = "{}_mbox_priorbox".format(from_layer) net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_size, clip=clip, variance=prior_variance, offset=offset) if max_size: net.update(name, {'max_size': max_size}) if aspect_ratio: net.update(name, {'aspect_ratio': aspect_ratio, 'flip': flip}) if step: net.update(name, {'step': step}) if img_height != 0 and img_width != 0: if img_height == img_width: net.update(name, {'img_size': img_height}) else: net.update(name, {'img_h': img_height, 'img_w': img_width}) priorbox_layers.append(net[name]) # Concatenate priorbox, loc, and conf layers. mbox_layers = [] name = '{}{}'.format(prefix, "_loc") net[name] = L.Concat(*loc_layers, axis=1) mbox_layers.append(net[name]) name = '{}{}'.format(prefix, "_conf") net[name] = L.Concat(*conf_layers, axis=1) mbox_layers.append(net[name]) name = '{}{}'.format(prefix, "_priorbox") net[name] = L.Concat(*priorbox_layers, axis=2) mbox_layers.append(net[name]) prefix = 'odm' num = len(from_layers2) loc_layers = [] conf_layers = [] for i in range(0, num): from_layer = from_layers2[i] # Get the normalize value. if normalizations: if normalizations[i] != -1: norm_name = "{}_norm".format(from_layer) net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalizations[i]), across_spatial=False, channel_shared=False) from_layer = norm_name # Add intermediate layers. if inter_layer_depth: if inter_layer_depth[i] > 0: # Inter layer from body to head inter_name = "{}_inter".format(from_layer) # Depthwise convolution layer inter_dw = inter_name + '/dw' DWConvBNLayer(net, from_layer, inter_dw, use_bn=True, use_relu=True, num_output=512, group=512, kernel_size=3, pad=1, stride=1, conv_prefix=conv_prefix, conv_postfix=inter_dw, bn_prefix=bn_prefix, bn_postfix=bn_postfix, scale_prefix=scale_prefix, scale_postfix=scale_postfix, **bn_param) # Seperate layer inter_sep = inter_name + '/sep' ConvBNLayer(net, inter_dw, inter_sep, use_bn=True, use_relu=True, num_output=512, kernel_size=1, pad=0, stride=1, conv_prefix=conv_prefix, conv_postfix=inter_sep, bn_prefix=bn_prefix, bn_postfix=bn_postfix, scale_prefix=scale_prefix, scale_postfix=scale_postfix, **bn_param) # Bridge of rest of head from_layer = inter_sep # Estimate number of priors per location given provided parameters. min_size = min_sizes[i] if type(min_size) is not list: min_size = [min_size] aspect_ratio = [] if len(aspect_ratios) > i: aspect_ratio = aspect_ratios[i] if type(aspect_ratio) is not list: aspect_ratio = [aspect_ratio] max_size = [] if len(max_sizes) > i: max_size = max_sizes[i] if type(max_size) is not list: max_size = [max_size] if max_size: assert len(max_size) == len(min_size), "max_size and min_size should have same length." if max_size: num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size) else: num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size) if flip: num_priors_per_location += len(aspect_ratio) * len(min_size) # Create location prediction layer. name = "{}_mbox_loc{}".format(from_layer, loc_postfix) num_loc_output = num_priors_per_location * 4 if not share_location: num_loc_output *= num_classes ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) loc_layers.append(net[flatten_name]) # Create confidence prediction layer. name = "{}_mbox_conf{}".format(from_layer, conf_postfix) num_conf_output = num_priors_per_location * num_classes ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param) permute_name = "{}_perm".format(name) net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1]) flatten_name = "{}_flat".format(name) net[flatten_name] = L.Flatten(net[permute_name], axis=1) conf_layers.append(net[flatten_name]) # Concatenate priorbox, loc, and conf layers. name = '{}{}'.format(prefix, "_loc") net[name] = L.Concat(*loc_layers, axis=1) mbox_layers.append(net[name]) name = '{}{}'.format(prefix, "_conf") net[name] = L.Concat(*conf_layers, axis=1) mbox_layers.append(net[name]) return mbox_layers