SiamRPN代码分析：training

r囧r小猫 2022-10-31 04:11 614阅读 0赞

### 文章目录 ###

*  前言
 *  1、数据增强、建立anchor
 *   *  1.1 数据增强
     *  1. 2 建立anchor
 *  2、分类和回归的target
 *  3、损失函数
 *   *  3.1 分类损失
     *  3.1 回归损失
 *  下一篇链接

--------------------

# 前言 #

本文是SiamRPN代码分析的第二部分**training**。训练时，使用GOT-10k数据集训练，所以测试结果性能与论文有些差距，最近在看pysot的训练过程，后续打算记录pysot的COCO、ILSVRC2015\_DET、ILSVRC2015\_VID、YouTube-BB数据集以及pysot提供的数据增强方法来训练自己的模型。  
  对模型训练代码部分不清晰的小伙伴请翻看之前关于SiamFC代码分析这篇文章，本文仅仅分析训练过程中的重点进行分析。

--------------------

# 1、数据增强、建立anchor #

SiamRPN关于training的详细流程图如下：

每个视频序列提取两帧

crop and resize

crop and resize and center\_shift and scale

目标的centerxy及wh

271x271x3的图像

GOT10k数据集

两帧图像

127x127x3的目标模板图像

271x271x3的搜索图像和目标的位置大小

分类和回归的target

建立anchors

最终的网络输出

分类和回归损失

优化

## 1.1 数据增强 ##

接下来，分析下数据增强和生成anchor的代码，数据增强就是在得到原始搜索图像的时候对目标进行了随机的小移位以及目标长宽的缩放，当然也可以添加其他数据增强方式，比如模糊处理等，代码中仅对搜索图像的目标进行了这些操作。**这里解释下代码中为什么没对目标模板图像数据增强呢**？因为在跟踪过程中，anchor是反映在搜索图像上，所以对搜索图像中的目标shift后，训练过程要找的anchor就不仅仅是整个搜索图像的中心位置了，而是在位移所在处，这样训练后的网络可以避免在测试过程中网络对中心的敏感趋向性。而对目标模板图像进行类似的处理显得就没那么重要了，因为可以把目标模板图像的特征图是卷积核，跟踪过程是在搜索图像寻找与卷积核最相似的部分(分类的前景值最大)，其实相比于shift，scale和图像模糊等对目标模板图像的意义更大，以上只是我个人的理解，其实加不加都行，多多少少有点益处。在阅读pysot源码时，对目标模板图像和搜索图像采取了同样的数据增强方式。

shift_x = np.random.choice(range(-12,12))
    	shift_y = np.random.choice(range(-12,12))
    	scale_h = 1.0 + np.random.uniform(-0.15, 0.15)
    	scale_w = 1.0 + np.random.uniform(-0.15, 0.15)

如代码所示，对目标的中心12个像素内的shift操作，12个像素的位移是相对于271x271大小的图像而言，并对其高宽进行0.85~1.15范围内的的缩放比例。验证下最终得到的搜索图像效果，

gt = np.array(list(map(round, gt)))
        print(gt) #前两个值是shift_x和shift_y
        gt[0:2] = gt[0:2]+135  #得到真正的center_x和center_y的坐标
        gt = cxcywhtoltwh(gt)
        gt = gt.squeeze(axis=0)
        print(gt)
    	plt.imshow(instance_img)
        ax = plt.gca()
        ax.add_patch(plt.Rectangle((gt[0:2]),gt[2],gt[3],color="red", fill=False, linewidth=1))
        plt.show()

![在这里插入图片描述][20210221160719682.jpg_pic_center]  
![20210221160729492.jpg_pic_center][]

## 1. 2 建立anchor ##

anchor的建立代码如下所示：

#获取所有像素点的anchors
    #total_stride=8; base_size=8; scales=[8]; ratios=[0.33, 0.5, 1, 2, 3] ；core_size=19
    def generate_anchors(total_stride, base_size, scales, ratios, score_size):
        #获取不同尺度和大小的anchor
        anchor_num = len(ratios) * len(scales)   #5
        anchor = np.zeros((anchor_num, 4), dtype=np.float32) #shepe(5,4)
        size = base_size * base_size  #8*8=64 面积
        count = 0
        for ratio in ratios:
            #w和h是相对于19x19而言
            w = int(np.sqrt(size / ratio))
            h = int(w * ratio)
            for scale in scales:
                #anchor_w、anchor_h是相对于原始图片而言，因为stride=8，所以scale一定要是8得整数倍
                anchor_w = w * scale
                anchor_h = h * scale
                anchor[count, 0] = 0
                anchor[count, 1] = 0
                anchor[count, 2] = anchor_w
                anchor[count, 3] = anchor_h
                count += 1
        #tile复制功能，anchor[5,4]->[5,4*19*19]默认维度是第1维，不是第0维
        #anchor[5,0:4]=anchor[5,4*(i-1):4*i], i=1,2,3,,,19*19
        anchor= np.tile(anchor, score_size * score_size)
        #[1805,4],anchor[0:19*19,4]中每个元素都相同，anchor[19*19:19*19*2，4]中每个元素相同，以此类推
        anchor = anchor.reshape((-1, 4))
        #取19x19的中心区域画anchor
        ori =-(score_size // 2) * total_stride #ori=-72=-9*8
        """取19x19的feature map的anchor，范围为19//2，映射回原图(271*271)就是 19//2 * 8"""
        #xx={ndarray:(19,19)}[[-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -24 -16 -8 0 8 16 24 32 40 48 56 64, 72], [-72 -64 -56 -48 -40 -32 -2...
        #yy={ndarray:(19,19)}[[-72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72 -72, -72], [-64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64, -64], [-56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56 -56, -56], [-48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48 -48, -48], [-40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40 -40, -40], [-32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32 -32, -32], [-24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24 -24, -24], [-16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16, -16], [ -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8, -8], [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0, 0], [ 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8, 8], [ 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16, 16], [ 24 24 24 24 24 24 2...
        xx, yy = np.meshgrid([ori + total_stride * dx for dx in range(score_size)],
                             [ori + total_stride * dy for dy in range(score_size)])
        xx = np.tile(xx.flatten(), (anchor_num, 1)).flatten()  #(1805,)
        yy = np.tile(yy.flatten(), (anchor_num, 1)).flatten()  #(1805,)
        anchor[:, 0], anchor[:, 1] = xx.astype(np.float32), yy.astype(np.float32)
        #anchor.shape=(1805,4) 4代表[center_x,center_y,w,h]
        return anchor

anchor的尺度取\[0.5,0.66,1,1.5,2\]，尺度完全可以自己调整为其它，里面的具体尺度值代表高宽比，大小须为8的倍数，因为anchor是定义在19x19大小的feature map上的，最后得到的anchor要映射会272x272大小的原始图像，19x19上的8x8的像素面积的对应原图的面积大小是64x64。在穷举anchor的时候，论文提到，并不是对19x19每个像素位置都取5种尺度的anchor，而是在规定特征图范围内取anchor，![在这里插入图片描述][20210221185529957.jpg_pic_center]

在距离中心不超过7个像素点位置取anchor，即14x14的区域内，而代码中在19x19整个区域内穷取anchor，这样各有各的好把，14x14的情况下训练速度、跟踪速度都加快，19x19的话可以跟踪到快速运动的物体。  
  具体的anchor生成方法是，先得到基准anchor，基准anchor的shape是\[5,4\]，代表4中尺度，每种尺度的向量记录anchor的\[center\_x,center\_y,w,h\]，这里的基准anchor的center\_x和center\_y是图像的中心点(0,0)，然后再对其进行位移，再19x19的特征图上是x、y轴都是以1个像素为单位平移，x和y轴的平移坐标是-9.-8.-7…0…7.8.9，乘上步距8映射到原图的的位移就是-72.-64…0…64.72，所以共得到19x19x5=1805个anchor，下图展示了对比19x19的feature map的anchor和原图的anchor，这里feature map的anchor只简单展示，原图anchor穷举。有一点值得注意的是，原图的效果看上去并不是穷举anchor，在图像周边缘还有很多区域无anchor覆盖，这是由于19x8=152不等于272，网络卷积层no padding所造成的，不过看上去好像又覆盖了大面积，不像是152，至少200+，这是因为原图中anchor的大小是64x64，anchor给的是中心点坐标，中心位置加上一半的高宽就得到下面的效果。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODMxNzUz_size_16_color_FFFFFF_t_70_pic_center]

# 2、分类和回归的target #

分类的target是根据每个anchor与目标的grundtruth计算IOU得到，计算二者IOU的代码如下，函数给的参数是1805个anchor以及目标的单个groundtruth，最终返回1805个IOU值。

def compute_iou(self, anchors, box):
            #将box复制1805份，gt_box.shape=(1805,4) 每个[i,4](i=0...1804)都相同
            gt_box = np.tile(box.reshape(1, -1), (anchors.shape[0], 1))
            anchor_x1 = anchors[:, :1] - anchors[:, 2:3] / 2 + 0.5 #xmin
            anchor_x2 = anchors[:, :1] + anchors[:, 2:3] / 2 - 0.5 #xmax
            anchor_y1 = anchors[:, 1:2] - anchors[:, 3:] / 2 + 0.5 #ymin
            anchor_y2 = anchors[:, 1:2] + anchors[:, 3:] / 2 - 0.5 #ymax
            gt_x1 = gt_box[:, :1] - gt_box[:, 2:3] / 2 + 0.5 #xmin
            gt_x2 = gt_box[:, :1] + gt_box[:, 2:3] / 2 - 0.5 #xmax
            gt_y1 = gt_box[:, 1:2] - gt_box[:, 3:] / 2 + 0.5 #ymin
            gt_y2 = gt_box[:, 1:2] + gt_box[:, 3:] / 2 - 0.5 #ymax
            xx1 = np.max([anchor_x1, gt_x1], axis=0)
            xx2 = np.min([anchor_x2, gt_x2], axis=0)
            yy1 = np.max([anchor_y1, gt_y1], axis=0)
            yy2 = np.min([anchor_y2, gt_y2], axis=0)
            inter_area = np.max([xx2 - xx1, np.zeros(xx1.shape)], axis=0) * np.max([yy2 - yy1, np.zeros(xx1.shape)],axis=0)
            area_anchor = (anchor_x2 - anchor_x1) * (anchor_y2 - anchor_y1)
            area_gt = (gt_x2 - gt_x1) * (gt_y2 - gt_y1)
            iou = inter_area / (area_anchor + area_gt - inter_area + 1e-6)
            #返回iou.shape=(1805,1)
            return iou

得到IOU值后，如论文所述，根据所给定的阈值0.6和0.3，大于0.6为正样本，target值为1，小于0.3为负样本，target值为0。代码中，在IOU在0.3到0.6之间的的anchor设它的target为-1，训练时，忽略target为-1的部分，所以分类target的维度是(1805,1)。![在这里插入图片描述][20210221195116371.jpg_pic_center]

iou = self.compute_iou(anchors, box).flatten()
            pos_index = np.where(iou > config.pos_threshold)[0]  #>0.6的为正样本
            neg_index = np.where(iou < config.neg_threshold)[0]  #<0.3的为负样本
            #正样本为1，负样本为0，抛弃的为-1(iou介于0.3到0.6之间)
            label = np.ones_like(iou) * -1
            label[pos_index] = 1
            label[neg_index] = 0

下面用图展示一下，左图红色框是目标的groundtruth，右图红色框是列举的几个anchor。

![20210221200949170.png_pic_center][]

然后就是回归的target了，在测试过程中，回归参数的作用是对预测到的目标框进行微调，使它的位置更加准确。计算回归target的代码和具体示意图如下：

#返回regression_target.shape=(1805,4),4:(dx,dy,dw,dh)
        def get_target_reg(self, anchors, gt_box):
            #anchor.shape=[1805,4] ge_box.shape(4,)
            anchor_xctr = anchors[:, :1]
            anchor_yctr = anchors[:, 1:2]
            anchor_w = anchors[:, 2:3]
            anchor_h = anchors[:, 3:]
            gt_cx, gt_cy, gt_w, gt_h = gt_box
            #真实gt以及anchor的回归参数，网络输出得到的是预测pre以及anchor的回归参数
            target_x = (gt_cx - anchor_xctr) / anchor_w  # (1805,1) dx=(gx-Ax)/Aw A:anchor g:groundtruth
            target_y = (gt_cy - anchor_yctr) / anchor_h  # (1805,1) dy
            target_w = np.log(gt_w / anchor_w)  # (1805,1) pw
            target_h = np.log(gt_h / anchor_h)  # (1805,1) ph
            regression_target = np.hstack((target_x, target_y, target_w, target_h)) #(1805,4)
            return regression_target

![20210221203211911.png_pic_center][]

红色的目标的groundtruth，黄色的是预测的目标框，黑色的经过微调之后得到的目标框，回归参数共有4个dx、dy、dw和dh，分别调整黄色预测框的中心位置和高宽。训练时，仅对正样本(分类target值为1)进行回归训练，训练的时候，就是要把网络输出得到的回归参数与给的回归target最小化，再用网络输出的回归参数微调预测框，得到的回归target维度是(1805,4)。

# 3、损失函数 #

损失函数分为分类损失和回归损失，分类损失计算方法采用交叉熵损失函数，回归损失计算方法采用smooth\_L1损失函数。训练时，采用损失加权的方法，代码中简单的使用1：5的权重。

"""———————将模板和搜索图像输入net，得到回归参数和分类分数————"""
    	    #score.shape=[8,10,19,19],regression.shape=[8,20,19,19]
    	    pred_score, pred_regression = model(exemplar_imgs.cuda(), instance_imgs.cuda())
    	    #pre_conf.shape=(8,1805,2)
    	    pred_conf = pred_score.reshape(-1, 2, config.anchor_num * config.score_size * config.score_size).permute(0,2,1)
    	    #pred_offset.shape=[8,1805,4]
    	    pred_offset = pred_regression.reshape(-1, 4,config.anchor_num * config.score_size * config.score_size).permute(0,2,1)
    	    """——————————————计算分类和回归损失————————————————————-"""
    	    cls_loss = rpn_cross_entropy_balance(pred_conf, conf_target, config.num_pos, config.num_neg, anchors,
    	                                         nms_pos=config.nms_pos, nms_neg=config.nms__neg)
    	    reg_loss = rpn_smoothL1(pred_offset, regression_target, conf_target, config.num_pos, nms_reg=config.nms_reg)
    	    loss = cls_loss + config.loss_weight * reg_loss    #分类权重和回归权重 1：5

将网络的输出与上一节所讲的分类和回归target输入损失函数进行训练，接下来分别讲解rpn\_cross\_entropy\_balance以及rpn\_smoothL1损失函数。

## 3.1 分类损失 ##

进入rpn\_cross\_entropy\_balance函数一探究竟

def rpn_cross_entropy_balance(input, target, num_pos, num_neg, anchors, nms_pos=None, nms_neg=None):
        loss_all = []
        for batch_id in range(target.shape[0]):  #遍历batch，计算损失
            min_pos = min(len(np.where(target[batch_id].cpu() == 1)[0]), num_pos) #num-pos=16，意思target=1的最多取16个
            min_neg = int(min(len(np.where(target[batch_id].cpu() == 1)[0]) * num_neg / num_pos, num_neg)) #target=0最多48个，且保证是target=1个数的三倍
            pos_index = np.where(target[batch_id].cpu() == 1)[0].tolist() #参数列表
            neg_index = np.where(target[batch_id].cpu() == 0)[0].tolist() #参数列表
            if nms_pos: #False
                pass
            else:
                pos_index_random = random.sample(pos_index, min_pos) #随机取min_pos个正样本的索引
                if len(pos_index) > 0:
                    # 交叉熵损失
                    pos_loss_bid_final = F.cross_entropy(input=input[batch_id][pos_index_random],target=target[batch_id][pos_index_random], reduction='none')
                else:
                    pos_loss_bid_final = torch.FloatTensor([0]).cuda()
            if nms_neg:#False
                pass
            else:
                if len(pos_index) > 0:
                    neg_index_random = random.sample(neg_index, min_neg)
                    #计算损失时，input要是float型，target为long型，reduction为None表示不计算损失平均
                    #如果target为1，把input的第二维度当作计算，target为0时，把input的第一位当作计算
                    neg_loss_bid_final = F.cross_entropy(input=input[batch_id][neg_index_random],target=target[batch_id][neg_index_random], reduction='none')
                else:
                    neg_index_random = random.sample(np.where(target[batch_id].cpu() == 0)[0].tolist(), num_neg)
                    neg_loss_bid_final = F.cross_entropy(input=input[batch_id][neg_index_random],target=target[batch_id][neg_index_random], reduction='none')
            #每张图片的损失平均值
            loss_bid = (pos_loss_bid_final.mean() + neg_loss_bid_final.mean()) / 2
            loss_all.append(loss_bid)
        final_loss = torch.stack(loss_all).mean()
        return final_loss

首先，代码没有使用论文提及的nms非极大抑制比，原因是在分类损失中，只有前景和后景两个分数值，这两个分数值不能直观体现anchor的重叠率，倘若两个anchor分数都为0.7，那么anchor的位置可以在groundtruth的上下左右各个位置，所以代码中，随机抽取了16个分类target为1的正样本和48个分类target为0的负样本进行训练。  
  `F.cross_entropy`函数是重点，在训练过程中，正样本和负样本单独训练，先分析正样本训练，输入从每个batch中取16个样本，它的索引为分类target为1的索引，target肯定就是16个1喽，那么训练时，使用的是输入的第二维度，白话讲，就是让第input每个anchor分类预测的**第二个值，即前景**的值训练得接近于1；负样本训练类似，只是target值为0，所以要训练使得anchor分类预测的第一个值为0。具体见下图分析，并且还用代码作了验证。这里提前说下，在测试过程中，要得到预测框的方法是选择1805个anchor第2个值最大的anchor作为预测框，再进行微调。

if __name__ == '__main__':
        input = np.array([[0.2,0.8],[0.4,0.6],[0.9,0.1]],dtype=float)
        input = torch.from_numpy(input)
        target = np.array([1,1,0],dtype='int64')
        target = torch.from_numpy(target)
        loss = F.cross_entropy(input,target,reduction='none')
        print(loss)  #输出为tensor([0.4375, 0.5981, 0.3711], dtype=torch.float64)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODMxNzUz_size_16_color_FFFFFF_t_70_pic_center 1]

## 3.1 回归损失 ##

回归损失使用的是smooth\_L1函数，该函数的详解查看这篇[文章][Link 1]，极力推荐!anchor位置的回归训练仅针对正样本，首先要得到anchor，那么根据分类的target为1得到对应正样本anchor的索引。接下来本该对anchor为1的样本作nms处理，因为这样可以得到不重叠的anchor，但是，代码却没有，为什么？因为之前在计算正样本的时候，IOU要大于0.6，这样基本上正样本anchor都集中在groundtruth附近，如果再剔出重复anchor，那么阈值得设置很大才合适，因为设置小了，基本上就得不到16个正样本了，所以nms操作对回归训练影响很小。代码中选择损失值最大的16个anchor策略进行回归训练来替代nms。

# input(batch,1805,4) target(batch,1805,4) label(16,1805),num_pos=16 ohem=False(不使用nms)
    def rpn_smoothL1(input, target, label, num_pos=16, nms_reg=True):
        loss_all = []
        for batch_id in range(target.shape[0]): #遍历每张图片计算回归损失
            min_pos = min(len(np.where(label[batch_id].cpu() == 1)[0]), num_pos) #最多取16个正样本，回归只针对正样本
            if nms_reg:
                pos_index = np.where(label[batch_id].cpu() == 1)[0]
                if len(pos_index) > 0:
                    loss_bid = F.smooth_l1_loss(input[batch_id][pos_index], target[batch_id][pos_index], reduction='none')
                    #得到损失值得索引，损失小到大排列
                    sort_index = torch.argsort(loss_bid.mean(1))
                    #从最后取损失值大的用于训练
                    loss_bid_nms = loss_bid[sort_index[-num_pos:]]
                else:
                    loss_bid_nms = torch.FloatTensor([0]).cuda()[0]
                loss_all.append(loss_bid_nms.mean())
        final_loss = torch.stack(loss_all).mean()
        return final_loss

至此，training分析代码完了，最后是test代码的分析。

# 下一篇链接 #

[SiamRPN代码分析：test][SiamRPN_test]

[20210221160719682.jpg_pic_center]: /images/20221024/b7447372934844249dfcb0a2429b1826.png
[20210221160729492.jpg_pic_center]: /images/20221024/ec2bbb4eba7c4e1582908c008293fe35.png
[20210221185529957.jpg_pic_center]: /images/20221024/a954796620df48039e5b45a4d7895a80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODMxNzUz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/9909d5dabb0c4da5a2a0656f9566f075.png
[20210221195116371.jpg_pic_center]: /images/20221024/afb92363b7b84102a6db1d7659faf71c.png
[20210221200949170.png_pic_center]: /images/20221024/8ca0c499a4fb49d1846a17b761caf012.png
[20210221203211911.png_pic_center]: /images/20221024/9919e6f538974c65a7337a7aef0117f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODMxNzUz_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/1b76c98c326341ada2e3d838f6a18768.png
[Link 1]: https://www.cnblogs.com/wangguchangqing/p/12021638.html
[SiamRPN_test]: https://blog.csdn.net/qq_41831753/article/details/113930169