"""
    Implementation of the SSD VGG-based 300 network.    The default features layers with 300x300 image input are:
      conv4 ==> 38 x 38
      conv7 ==> 19 x 19
      conv8 ==> 10 x 10
      conv9 ==> 5 x 5
      conv10 ==> 3 x 3
      conv11 ==> 1 x 1
    The default image size used to train this network is 300x300.
    """default_params = SSDParams(img_shape=(300, 300),#输入尺寸num_classes=21,#预测类别20+1=21（20类加背景）#获取feature map层feat_layers=['block4', 'block7', 'block8', 'block9', 'block10', 'block11'],feat_shapes=[(38, 38), (19, 19), (10, 10), (5, 5), (3, 3), (1, 1)],anchor_size_bounds=[0.15, 0.90],#anchor boxes的大小anchor_sizes=[(21., 45.),(45., 99.),(99., 153.),(153., 207.),(207., 261.),(261., 315.)],#anchor boxes的aspect ratiosanchor_ratios=[[2, .5],[2, .5, 3, 1./3],[2, .5, 3, 1./3],[2, .5, 3, 1./3],[2, .5],[2, .5]],anchor_steps=[8, 16, 32, 64, 100, 300],#anchor的层anchor_offset=0.5,#补偿阀值0.5normalizations=[20, -1, -1, -1, -1, -1],#该特征层是否正则，大于零即正则；小于零则否prior_scaling=[0.1, 0.1, 0.2, 0.2])

#建立ssd网络函数
def ssd_net(inputs,num_classes=21,feat_layers=SSDNet.default_params.feat_layers,anchor_sizes=SSDNet.default_params.anchor_sizes,anchor_ratios=SSDNet.default_params.anchor_ratios,normalizations=SSDNet.default_params.normalizations,is_training=True,dropout_keep_prob=0.5,prediction_fn=slim.softmax,reuse=None,scope='ssd_300_vgg'):"""SSD net definition.
    """# End_points collect relevant activations for external use.#用于收集每一层输出结果end_points = {}#采用slim建立vgg网络,网络结构参考文章内的结构图with tf.variable_scope(scope, 'ssd_300_vgg', [inputs], reuse=reuse):# Original VGG-16 blocks.net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')end_points['block1'] = netnet = slim.max_pool2d(net, [2, 2], scope='pool1')# Block 2.net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')end_points['block2'] = netnet = slim.max_pool2d(net, [2, 2], scope='pool2')# Block 3.net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')end_points['block3'] = netnet = slim.max_pool2d(net, [2, 2], scope='pool3')# Block 4.net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')end_points['block4'] = netnet = slim.max_pool2d(net, [2, 2], scope='pool4')# Block 5.net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')end_points['block5'] = netnet = slim.max_pool2d(net, [3, 3], 1, scope='pool5')#max pool#外加的SSD层# Additional SSD blocks.# Block 6: let's dilate the hell out of it!#输出shape为19×19×1024net = slim.conv2d(net, 1024, [3, 3], rate=6, scope='conv6')end_points['block6'] = net# Block 7: 1x1 conv. Because the fuck.#卷积核为1×1net = slim.conv2d(net, 1024, [1, 1], scope='conv7')end_points['block7'] = net# Block 8/9/10/11: 1x1 and 3x3 convolutions stride 2 (except lasts).end_point = 'block8'with tf.variable_scope(end_point):net = slim.conv2d(net, 256, [1, 1], scope='conv1x1')net = slim.conv2d(net, 512, [3, 3], stride=2, scope='conv3x3')end_points[end_point] = netend_point = 'block9'with tf.variable_scope(end_point):net = slim.conv2d(net, 128, [1, 1], scope='conv1x1')net = slim.conv2d(net, 256, [3, 3], stride=2, scope='conv3x3')end_points[end_point] = netend_point = 'block10'with tf.variable_scope(end_point):net = slim.conv2d(net, 128, [1, 1], scope='conv1x1')net = slim.conv2d(net, 256, [3, 3], scope='conv3x3', padding='VALID')end_points[end_point] = netend_point = 'block11'with tf.variable_scope(end_point):net = slim.conv2d(net, 128, [1, 1], scope='conv1x1')net = slim.conv2d(net, 256, [3, 3], scope='conv3x3', padding='VALID')end_points[end_point] = net# Prediction and localisations layers.#预测和定位predictions = []logits = []localisations = []for i, layer in enumerate(feat_layers):with tf.variable_scope(layer + '_box'):#接受特征层的输出，生成类别和位置预测p, l = ssd_multibox_layer(end_points[layer],num_classes,anchor_sizes[i],anchor_ratios[i],normalizations[i])#把每一层的预测收集predictions.append(prediction_fn(p))#prediction_fn为softmax，预测类别logits.append(p)#概率localisations.append(l)#预测位置信息return predictions, localisations, logits, end_points

#生成一层的anchor boxes
def ssd_anchor_one_layer(img_shape,#原始图像shapefeat_shape,#特征图shapesizes,#预设的box sizeratios,#aspect 比例step,#anchor的层offset=0.5,dtype=np.float32):"""Computer SSD default anchor boxes for one feature layer.    Determine the relative position grid of the centers, and the relative
    width and height.    Arguments:
      feat_shape: Feature shape, used for computing relative position grids;
      size: Absolute reference sizes;
      ratios: Ratios to use on these features;
      img_shape: Image shape, used for computing height, width relatively to the
        former;
      offset: Grid offset.    Return:
      y, x, h, w: Relative x and y grids, and height and width.
    """# Compute the position grid: simple way.# y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]]# y = (y.astype(dtype) + offset) / feat_shape[0]# x = (x.astype(dtype) + offset) / feat_shape[1]# Weird SSD-Caffe computation using steps values..."""
    #测试中，参数如下
    feat_shapes=[(38, 38), (19, 19), (10, 10), (5, 5), (3, 3), (1, 1)]
    anchor_sizes=[(21., 45.),
                      (45., 99.),
                      (99., 153.),
                      (153., 207.),
                      (207., 261.),
                      (261., 315.)]
    anchor_ratios=[[2, .5],
                       [2, .5, 3, 1./3],
                       [2, .5, 3, 1./3],
                       [2, .5, 3, 1./3],
                       [2, .5],
                       [2, .5]]
    anchor_steps=[8, 16, 32, 64, 100, 300]    offset=0.5    dtype=np.float32    feat_shape=feat_shapes[0]
    step=anchor_steps[0]
    """#测试中，y和x的shape为（38,38）（38,38）#y的值为#array([[ 0,  0,  0, ...,  0,  0,  0],#  [ 1,  1,  1, ...,  1,  1,  1],# [ 2,  2,  2, ...,  2,  2,  2],#   ..., #  [35, 35, 35, ..., 35, 35, 35],#  [36, 36, 36, ..., 36, 36, 36],#  [37, 37, 37, ..., 37, 37, 37]])y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]]#测试中y=(y+0.5)×8/300,x=(x+0.5)×8/300y = (y.astype(dtype) + offset) * step / img_shape[0]x = (x.astype(dtype) + offset) * step / img_shape[1]#扩展维度，维度为（38,38,1）# Expand dims to support easy broadcasting.y = np.expand_dims(y, axis=-1)x = np.expand_dims(x, axis=-1)# Compute relative height and width.# Tries to follow the original implementation of SSD for the order.#数值为2+2num_anchors = len(sizes) + len(ratios)#shape为（4,）h = np.zeros((num_anchors, ), dtype=dtype)w = np.zeros((num_anchors, ), dtype=dtype)# Add first anchor boxes with ratio=1.#测试中，h[0]=21/300,w[0]=21/300?h[0] = sizes[0] / img_shape[0]w[0] = sizes[0] / img_shape[1]di = 1if len(sizes) > 1:#h[1]=sqrt(21*45)/300h[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[0]w[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[1]di += 1for i, r in enumerate(ratios):h[i+di] = sizes[0] / img_shape[0] / math.sqrt(r)w[i+di] = sizes[0] / img_shape[1] * math.sqrt(r)#测试中，y和x shape为（38,38,1）#h和w的shape为（4,）return y, x, h, w

#label和bbox编码函数
def tf_ssd_bboxes_encode_layer(labels,#ground truth标签，1D tensorbboxes,#N×4 Tensor（float）anchors_layer,#anchors，为listmatching_threshold=0.5,#阀值prior_scaling=[0.1, 0.1, 0.2, 0.2],#缩放dtype=tf.float32):"""Encode groundtruth labels and bounding boxes using SSD anchors from
    one layer.    Arguments:
      labels: 1D Tensor(int64) containing groundtruth labels;
      bboxes: Nx4 Tensor(float) with bboxes relative coordinates;
      anchors_layer: Numpy array with layer anchors;
      matching_threshold: Threshold for positive match with groundtruth bboxes;
      prior_scaling: Scaling of encoded coordinates.    Return:
      (target_labels, target_localizations, target_scores): Target Tensors.
    """# Anchors coordinates and volume.#获取anchors层yref, xref, href, wref = anchors_layerymin = yref - href / 2.xmin = xref - wref / 2.ymax = yref + href / 2.xmax = xref + wref / 2.#xmax的shape为((38, 38, 1), (38, 38, 1), (4,), (4,))
(38, 38, 4)#体积vol_anchors = (xmax - xmin) * (ymax - ymin)# Initialize tensors...shape = (yref.shape[0], yref.shape[1], href.size)feat_labels = tf.zeros(shape, dtype=tf.int64)feat_scores = tf.zeros(shape, dtype=dtype)#shape为（38,38,4）feat_ymin = tf.zeros(shape, dtype=dtype)feat_xmin = tf.zeros(shape, dtype=dtype)feat_ymax = tf.ones(shape, dtype=dtype)feat_xmax = tf.ones(shape, dtype=dtype)#计算jaccard重合def jaccard_with_anchors(bbox):"""Compute jaccard score a box and the anchors.
        """# Intersection bbox and volume.int_ymin = tf.maximum(ymin, bbox[0])int_xmin = tf.maximum(xmin, bbox[1])int_ymax = tf.minimum(ymax, bbox[2])int_xmax = tf.minimum(xmax, bbox[3])h = tf.maximum(int_ymax - int_ymin, 0.)w = tf.maximum(int_xmax - int_xmin, 0.)# Volumes.inter_vol = h * wunion_vol = vol_anchors - inter_vol \+ (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])jaccard = tf.div(inter_vol, union_vol)return jaccard#条件函数 def condition(i, feat_labels, feat_scores,feat_ymin, feat_xmin, feat_ymax, feat_xmax):"""Condition: check label index.
        """#tf.less函数 Returns the truth value of (x < y) element-wise.r = tf.less(i, tf.shape(labels))return r[0]#主体def body(i, feat_labels, feat_scores,feat_ymin, feat_xmin, feat_ymax, feat_xmax):"""Body: update feature labels, scores and bboxes.
        Follow the original SSD paper for that purpose:
          - assign values when jaccard > 0.5;
          - only update if beat the score of other bboxes.
        """# Jaccard score.label = labels[i]bbox = bboxes[i]scores = jaccard_with_anchors(bbox)#计算jaccard重合值# 'Boolean' mask.#tf.greater函数返回大于的布尔值mask = tf.logical_and(tf.greater(scores, matching_threshold),tf.greater(scores, feat_scores))imask = tf.cast(mask, tf.int64)fmask = tf.cast(mask, dtype)# Update values using mask.feat_labels = imask * label + (1 - imask) * feat_labelsfeat_scores = tf.select(mask, scores, feat_scores)feat_ymin = fmask * bbox[0] + (1 - fmask) * feat_yminfeat_xmin = fmask * bbox[1] + (1 - fmask) * feat_xminfeat_ymax = fmask * bbox[2] + (1 - fmask) * feat_ymaxfeat_xmax = fmask * bbox[3] + (1 - fmask) * feat_xmaxreturn [i+1, feat_labels, feat_scores,feat_ymin, feat_xmin, feat_ymax, feat_xmax]# Main loop definition.i = 0[i, feat_labels, feat_scores,feat_ymin, feat_xmin,feat_ymax, feat_xmax] = tf.while_loop(condition, body,[i, feat_labels, feat_scores,feat_ymin, feat_xmin,feat_ymax, feat_xmax])# Transform to center / size.#计算补偿后的中心feat_cy = (feat_ymax + feat_ymin) / 2.feat_cx = (feat_xmax + feat_xmin) / 2.feat_h = feat_ymax - feat_yminfeat_w = feat_xmax - feat_xmin# Encode features.feat_cy = (feat_cy - yref) / href / prior_scaling[0]feat_cx = (feat_cx - xref) / wref / prior_scaling[1]feat_h = tf.log(feat_h / href) / prior_scaling[2]feat_w = tf.log(feat_w / wref) / prior_scaling[3]# Use SSD ordering: x / y / w / h instead of ours.feat_localizations = tf.stack([feat_cx, feat_cy, feat_w, feat_h], axis=-1)return feat_labels, feat_localizations, feat_scores#ground truth编码函数
def tf_ssd_bboxes_encode(labels,#ground truth标签，1D tensorbboxes,#N×4 Tensor（float）anchors,#anchors，为listmatching_threshold=0.5,#阀值prior_scaling=[0.1, 0.1, 0.2, 0.2],#缩放dtype=tf.float32,scope='ssd_bboxes_encode'):"""Encode groundtruth labels and bounding boxes using SSD net anchors.
    Encoding boxes for all feature layers.    Arguments:
      labels: 1D Tensor(int64) containing groundtruth labels;
      bboxes: Nx4 Tensor(float) with bboxes relative coordinates;
      anchors: List of Numpy array with layer anchors;
      matching_threshold: Threshold for positive match with groundtruth bboxes;
      prior_scaling: Scaling of encoded coordinates.    Return:
      (target_labels, target_localizations, target_scores):
        Each element is a list of target Tensors.
    """with tf.name_scope(scope):target_labels = []target_localizations = []target_scores = []for i, anchors_layer in enumerate(anchors):with tf.name_scope('bboxes_encode_block_%i' % i):#将label和bbox进行编码t_labels, t_loc, t_scores = \tf_ssd_bboxes_encode_layer(labels, bboxes, anchors_layer,matching_threshold, prior_scaling, dtype)target_labels.append(t_labels)target_localizations.append(t_loc)target_scores.append(t_scores)return target_labels, target_localizations, target_scores#编码goundtruth的label和bboxdef bboxes_encode(self, labels, bboxes, anchors,scope='ssd_bboxes_encode'):"""Encode labels and bounding boxes.
        """return ssd_common.tf_ssd_bboxes_encode(labels, bboxes, anchors,matching_threshold=0.5,prior_scaling=self.params.prior_scaling,scope=scope)

# =========================================================================== #
# SSD loss function.
# =========================================================================== #
def ssd_losses(logits, #预测类别localisations,#预测位置gclasses, #ground truth 类别glocalisations, #ground truth 位置gscores,#ground truth 分数match_threshold=0.5,negative_ratio=3.,alpha=1.,label_smoothing=0.,scope='ssd_losses'):"""Loss functions for training the SSD 300 VGG network.    This function defines the different loss components of the SSD, and
    adds them to the TF loss collection.    Arguments:
      logits: (list of) predictions logits Tensors;
      localisations: (list of) localisations Tensors;
      gclasses: (list of) groundtruth labels Tensors;
      glocalisations: (list of) groundtruth localisations Tensors;
      gscores: (list of) groundtruth score Tensors;
    """# Some debugging...# for i in range(len(gclasses)):#     print(localisations[i].get_shape())#     print(logits[i].get_shape())#     print(gclasses[i].get_shape())#     print(glocalisations[i].get_shape())#     print()with tf.name_scope(scope):l_cross = []l_loc = []for i in range(len(logits)):with tf.name_scope('block_%i' % i):# Determine weights Tensor.pmask = tf.cast(gclasses[i] > 0, logits[i].dtype)n_positives = tf.reduce_sum(pmask)#正样本数目#np.prod函数Return the product of array elements over a given axisn_entries = np.prod(gclasses[i].get_shape().as_list())# r_positive = n_positives / n_entries# Select some random negative entries.r_negative = negative_ratio * n_positives / (n_entries - n_positives)#负样本数nmask = tf.random_uniform(gclasses[i].get_shape(),dtype=logits[i].dtype)nmask = nmask * (1. - pmask)nmask = tf.cast(nmask > 1. - r_negative, logits[i].dtype)#cross_entropy loss# Add cross-entropy loss.with tf.name_scope('cross_entropy'):# Weights Tensor: positive mask + random negative.weights = pmask + nmaskloss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits[i],gclasses[i])loss = tf.contrib.losses.compute_weighted_loss(loss, weights)l_cross.append(loss)#smooth loss# Add localization loss: smooth L1, L2, ...with tf.name_scope('localization'):# Weights Tensor: positive mask + random negative.weights = alpha * pmaskloss = custom_layers.abs_smooth(localisations[i] - glocalisations[i])loss = tf.contrib.losses.compute_weighted_loss(loss, weights)l_loc.append(loss)# Total losses in summaries...with tf.name_scope('total'):tf.summary.scalar('cross_entropy', tf.add_n(l_cross))tf.summary.scalar('localization', tf.add_n(l_loc))