common.py这个脚本主要包括conv_act_layer，legacy_conv_act_layer，multi_layer_feature，multibox_layer四个函数，因为在symbol_builder.py中先后调用了multi_layer_feature和multibox_layer两个函数，前面一个主要用来生成特征融合的几个层，后面一个主要用来生成分类层，回归层，生成anchor层，比较重要，因此可以先看看这两个函数。

    1. import mxnet as mx
    2. import numpy as np
    4. def multi_layer_feature(body, from_layers, num_filters, strides, pads, min_filter=128):
    5.     """Wrapper function to extract features from base network, attaching extra
    6.     layers and SSD specific layers
    8.     Parameters
    9.     ----------
    10.     from_layers : list of str
    11.         feature extraction layers, use '' for add extra layers
    12.         For example:
    13.         from_layers = ['relu4_3', 'fc7', '', '', '', '']
    14.         which means extract feature from relu4_3 and fc7, adding 4 extra layers
    15.         on top of fc7
    16.     num_filters : list of int
    17.         number of filters for extra layers, you can use -1 for extracted features,
    18.         however, if normalization and scale is applied, the number of filter for
    19.         that layer must be provided.
    20.         For example:
    21.         num_filters = [512, -1, 512, 256, 256, 256]
    22.     strides : list of int
    23.         strides for the 3x3 convolution appended, -1 can be used for extracted
    24.         feature layers
    25.     pads : list of int
    26.         paddings for the 3x3 convolution, -1 can be used for extracted layers
    27.     min_filter : int
    28.         minimum number of filters used in 1x1 convolution
    30.     Returns
    31.     -------
    32.     list of mx.Symbols
    34.     """
    35.     # arguments check
    36.     assert len(from_layers) > 0
    37.     assert isinstance(from_layers[0], str) and len(from_layers[0].strip()) > 0
    38.     assert len(from_layers) == len(num_filters) == len(strides) == len(pads)
    41. # 这个body是你导入的vgg16的symbol，get_internals函数是获取这个symbol的所有参数层的信息
    42.     internals = body.get_internals()
    43.     layers = []
    44.     for k, params in enumerate(zip(from_layers, num_filters, strides, pads)):
    45.         from_layer, num_filter, s, p = params
    46.         # from_layer大概是这样的['relu4_3','relu7','','','','']，因此如果是后面的空字符串，那么就会跳到else那一部分
    47.         if from_layer.strip(): 
    48.             # extract from base network
    49. # 得到from_layer里面指定名称的层，然后append到layers这个列表中
    50.             layer = internals[from_layer.strip() + '_output']
    51.             layers.append(layer)
    52.         else: # 这一部分就是给原来的VGG16网络加上几个新的卷积操作
    53.             # attach from last feature layer
    54.             assert len(layers) > 0
    55.             assert num_filter > 0
    56.             layer = layers[-1] # 这一行表示现在要加的层的输入是上一层的输出
    57.             num_1x1 = max(min_filter, num_filter // 2) 
    58. # 一共添加了1*1和3*3两个卷积层，前面一个起减少计算量的作用，一般把这两个当做一个层，或者叫symbol
    59.             conv_1x1 = conv_act_layer(layer, 'multi_feat_%d_conv_1x1' % (k),
    60.                 num_1x1, kernel=(1, 1), pad=(0, 0), stride=(1, 1), act_type='relu')
    61.             conv_3x3 = conv_act_layer(conv_1x1, 'multi_feat_%d_conv_3x3' % (k),
    62.                 num_filter, kernel=(3, 3), pad=(p, p), stride=(s, s), act_type='relu')
    63.             layers.append(conv_3x3)
    64. # 最终这个layers列表会有6个symbol（以输入大小是300*300的vgg16的basemodel为例，就是上面的那个from_layer）
    65.     return layers
    67. def multibox_layer(from_layers, num_classes, sizes=[.2, .95],
    68.                     ratios=[1], normalization=-1, num_channels=[],
    69.                     clip=False, interm_layer=0, steps=[]):
    70.     """
    71.     the basic aggregation module for SSD detection. Takes in multiple layers,
    72.     generate multiple object detection targets by customized layers
    74.     Parameters:
    75.     ----------
    76.     from_layers : list of mx.symbol
    77.         generate multibox detection from layers
    78.     num_classes : int
    79.         number of classes excluding background, will automatically handle
    80.         background in this function
    81.     sizes : list or list of list
    82.         [min_size, max_size] for all layers or [[], [], []...] for specific layers
    83.     ratios : list or list of list
    84.         [ratio1, ratio2...] for all layers or [[], [], ...] for specific layers
    85.     normalizations : int or list of int
    86.         use normalizations value for all layers or [...] for specific layers,
    87.         -1 indicate no normalizations and scales
    88.     num_channels : list of int
    89.         number of input layer channels, used when normalization is enabled, the
    90.         length of list should equals to number of normalization layers
    91.     clip : bool
    92.         whether to clip out-of-image boxes
    93.     interm_layer : int
    94.         if > 0, will add a intermediate Convolution layer
    95.     steps : list
    96.         specify steps for each MultiBoxPrior layer, leave empty, it will calculate
    97.         according to layer dimensions
    99.     Returns:
    100.     ----------
    101.     list of outputs, as [loc_preds, cls_preds, anchor_boxes]
    102.     loc_preds : localization regression prediction
    103.     cls_preds : classification prediction
    104.     anchor_boxes : generated anchor boxes
    105.     """
    106.     assert len(from_layers) > 0, "from_layers must not be empty list"
    107.     assert num_classes > 0, \
    108.         "num_classes {} must be larger than 0".format(num_classes)
    110.     assert len(ratios) > 0, "aspect ratios must not be empty list"
    111.     if not isinstance(ratios[0], list):
    112.         # provided only one ratio list, broadcast to all from_layers
    113.         ratios = [ratios] * len(from_layers)
    114.     assert len(ratios) == len(from_layers), \
    115.         "ratios and from_layers must have same length"
    117.     assert len(sizes) > 0, "sizes must not be empty list"
    118.     if len(sizes) == 2 and not isinstance(sizes[0], list):
    119.         # provided size range, we need to compute the sizes for each layer
    120.          assert sizes[0] > 0 and sizes[0] < 1
    121.          assert sizes[1] > 0 and sizes[1] < 1 and sizes[1] > sizes[0]
    122.          tmp = np.linspace(sizes[0], sizes[1], num=(len(from_layers)-1))
    123.          min_sizes = [start_offset] + tmp.tolist()
    124.          max_sizes = tmp.tolist() + [tmp[-1]+start_offset]
    125.          sizes = zip(min_sizes, max_sizes)
    126.     assert len(sizes) == len(from_layers), \
    127.         "sizes and from_layers must have same length"
    129.     if not isinstance(normalization, list):
    130.         normalization = [normalization] * len(from_layers)
    131.     assert len(normalization) == len(from_layers)
    133.     assert sum(x > 0 for x in normalization) <= len(num_channels), \
    134.         "must provide number of channels for each normalized layer"
    136.     if steps:
    137.         assert len(steps) == len(from_layers), "provide steps for all layers or leave empty"
    140. # 初始化了3个空列表，后面会用到
    141.     loc_pred_layers = []
    142.     cls_pred_layers = []
    143.     anchor_layers = []
    144.     num_classes += 1 # always use background as label 0
    147. # 前面基本上都是一些check操作，从这里开始才是硬货，这个大的for循环将循环每一个需要做特征融合的层（以VGG16网络，
    148. # 输入为300*300为例，有2个层是VGG16本身的，有4个层是额外加上去的，因此from_layers这个列表包含上述6个symbol）
    149.     for k, from_layer in enumerate(from_layers):
    150.         from_name = from_layer.name
    151.         # normalize
    152. # normalization是一个列表，以输入为300*300的VGG16网络为例，默认的normalization是[20,-1,-1,-1,-1,-1]，
    153. # 这里的-1表示该层不进行normalization。另外，normalization在这里是通过symbol中的L2Normalization和Variable来实现的。
    154. # 在L2Normalization中mode是channel，表示按照channel里面数值的L2范数进行归一化，
    155. # 类似这样：for i in 0...N , out[:,i,:,...,:] = data[:,i,:,...,:] / sqrt(sum(data[:,i,:,...,:] ** 2) + eps)。
    156. # broadcast_mul是做一个broadcast的乘法，简单讲就是将scale和from_layer做点乘
    157.         if normalization[k] > 0:
    158.             from_layer = mx.symbol.L2Normalization(data=from_layer, \
    159.                 mode="channel", name="{}_norm".format(from_name))
    160.             scale = mx.symbol.Variable(name="{}_scale".format(from_name),
    161.                 shape=(1, num_channels.pop(0), 1, 1),
    162.                 init=mx.init.Constant(normalization[k]),
    163.                 attr={'__wd_mult__': '0.1'})
    164.             from_layer = mx.symbol.broadcast_mul(lhs=scale, rhs=from_layer)
    165.         if interm_layer > 0:
    166.             from_layer = mx.symbol.Convolution(data=from_layer, kernel=(3,3), \
    167.                 stride=(1,1), pad=(1,1), num_filter=interm_layer, \
    168.                 name="{}_inter_conv".format(from_name))
    169.             from_layer = mx.symbol.Activation(data=from_layer, act_type="relu", \
    170.                 name="{}_inter_relu".format(from_name))
    172.         # estimate number of anchors per location
    173.         # here I follow the original version in caffe
    174.         # TODO: better way to shape the anchors??
    175.         size = sizes[k]
    176.         assert len(size) > 0, "must provide at least one size"
    177.         size_str = "(" + ",".join([str(x) for x in size]) + ")"
    178.         ratio = ratios[k]
    179.         assert len(ratio) > 0, "must provide at least one ratio"
    180.         ratio_str = "(" + ",".join([str(x) for x in ratio]) + ")"
    181. # anchor数目的计算，这里采用的并非len(size)*len(ratio)
    182.         num_anchors = len(size) -1 + len(ratio)
    184.         # create location prediction layer
    185. # 这一部分主要是和location相关的，也就是回归框的具体位置，
    186. # 主要是用一个filter数量为（anchor数目乘以4）的3*3的卷积操作得到预测的各anchor的坐标，该层是接在from_layer的后面。
    187. # 因为pad=1，stride=1，所以该卷积是不改变feature map的大小的。最后把增加的层append到loc_pred_layers列表。
    188. # 每个anchor对应4个坐标值
    189.         num_loc_pred = num_anchors * 4
    190. # __lr_mult__是指在该层的学习率要乘以的数值，得到的结果作为该层的学习率
    191.         bias = mx.symbol.Variable(name="{}_loc_pred_conv_bias".format(from_name),
    192.             init=mx.init.Constant(0.0), attr={'__lr_mult__': '2.0'})
    193.         loc_pred = mx.symbol.Convolution(data=from_layer, bias=bias, kernel=(3,3), \
    194.             stride=(1,1), pad=(1,1), num_filter=num_loc_pred, \
    195.             name="{}_loc_pred_conv".format(from_name))
    196. # transpose是交换的作用，比如loc_pred的维度是32*24*19*19，那么经过交换后得到的维度变成32*19*19*24，
    197. # Flatten是将4个维度转换成2个维度，比如从32*19*19*24转换到32*8664。
    198. # 之所以这样操作是为了后面特征融合时不受feature map大小不一致的影响。
    199.         loc_pred = mx.symbol.transpose(loc_pred, axes=(0,2,3,1))
    200.         loc_pred = mx.symbol.Flatten(data=loc_pred)
    201.         loc_pred_layers.append(loc_pred)
    203.         # create class prediction layer
    204. # 这一部分主要是和类别预测相关，num_cls_pred对应要用到的3*3卷积的卷积核数量，这里num_classes是实际类别数+1（背景算一类），
    205. # 最后把增加的层append到cls_pred_layers列表。
    206.         num_cls_pred = num_anchors * num_classes
    207.         bias = mx.symbol.Variable(name="{}_cls_pred_conv_bias".format(from_name),
    208.             init=mx.init.Constant(0.0), attr={'__lr_mult__': '2.0'})
    209.         cls_pred = mx.symbol.Convolution(data=from_layer, bias=bias, kernel=(3,3), \
    210.             stride=(1,1), pad=(1,1), num_filter=num_cls_pred, \
    211.             name="{}_cls_pred_conv".format(from_name))
    212.         cls_pred = mx.symbol.transpose(cls_pred, axes=(0,2,3,1))
    213.         cls_pred = mx.symbol.Flatten(data=cls_pred)
    214.         cls_pred_layers.append(cls_pred)
    216.         # create anchor generation layer
    217. # 这一部分是用来生成anchor的，在mxnet中有专门的symbol用来做这个是，那就是mxnet.contrib.symbol.MultiBoxPrior，
    218. # 输入也是from_layer，也就是要提取特征做融合的层。size_str是该层的anchor尺寸是原图尺寸的倍数关系，
    219. # 比如(0.1,0.141)，ratio_str是anchor的宽高比例，比如(1,2,0.5)，clip是False，step是(0.0266667,0.0266667)，
    220. # 表示该层的feature map的尺寸是输入图像尺寸的多少倍，
    221. # 生成的anchors的维度是batch size*（h*w*（len(sizes)+len(ratios)-1））*4，是3维的。
    222. # 最后把增加的层append到anchor_layers列表。
    223.         if steps:
    224.             step = (steps[k], steps[k])
    225.         else:
    226.             step = '(-1.0, -1.0)'
    227.         anchors = mx.contrib.symbol.MultiBoxPrior(from_layer, sizes=size_str, ratios=ratio_str, \
    228.             clip=clip, name="{}_anchors".format(from_name), steps=step)
    229.         anchors = mx.symbol.Flatten(data=anchors)
    230.         anchor_layers.append(anchors)
    233. # 出来这个for循环后，就要对几个层做concate操作了，分别生成loc_preds，cls_preds，anchor_boxes这三个symbol，
    234. # 这里做Reshape的时候，参数shape中有些值是-1，表示该维度的大小等于（原来几个维度的乘积）除以（现在其他维度的乘积），
    235. # 因此shape里面最多只能有一个-1，要不就没法计算了，因此reshape后的cls_preds的维度就是：batch size*number of anchors*num_classes。
    236. # 同样，reshape后的anchor_boxes的维度是：batch size*number of anchors*coordinate。
    237.     loc_preds = mx.symbol.Concat(*loc_pred_layers, num_args=len(loc_pred_layers), \
    238.         dim=1, name="multibox_loc_pred")
    239.     cls_preds = mx.symbol.Concat(*cls_pred_layers, num_args=len(cls_pred_layers), \
    240.         dim=1)
    241.     cls_preds = mx.symbol.Reshape(data=cls_preds, shape=(0, -1, num_classes))
    242.     cls_preds = mx.symbol.transpose(cls_preds, axes=(0, 2, 1), name="multibox_cls_pred")
    243.     anchor_boxes = mx.symbol.Concat(*anchor_layers, \
    244.         num_args=len(anchor_layers), dim=1)
    245.     anchor_boxes = mx.symbol.Reshape(data=anchor_boxes, shape=(0, -1, 4), name="multibox_anchors")
    246.     return [loc_preds, cls_preds, anchor_boxes]