关闭

faster rcnn学习之rpn训练全过程

555人阅读 评论(0) 收藏 举报
分类:

上篇我们讲解了rpn与fast rcnn的数据准备阶段,接下来我们讲解rpn的整个训练过程。最后 讲解rpn训练完毕后rpn的生成。

我们顺着stage1_rpn_train.pt的内容讲解。

name: "VGG_CNN_M_1024"
layer {
  name: 'input-data'
  type: 'Python'
  top: 'data'
  top: 'im_info'
  top: 'gt_boxes'
  python_param {
    module: 'roi_data_layer.layer'
    layer: 'RoIDataLayer'
    param_str: "'num_classes': 21"
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param { lr_mult: 0 decay_mult: 0 }
  param { lr_mult: 0 decay_mult: 0 }
  convolution_param {
    num_output: 96
    kernel_size: 7 stride: 2
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "conv1"
  top: "conv1"
}
layer {
  name: "norm1"
  type: "LRN"
  bottom: "conv1"
  top: "norm1"
  lrn_param {
    local_size: 5
    alpha: 0.0005
    beta: 0.75
    k: 2
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "norm1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 3 stride: 2
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2"
  param { lr_mult: 1 }
  param { lr_mult: 2 }
  convolution_param {
    num_output: 256
    pad: 1 kernel_size: 5 stride: 2
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "conv2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0005
    beta: 0.75
    k: 2
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "norm2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 3 stride: 2
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "pool2"
  top: "conv3"
  param { lr_mult: 1 }
  param { lr_mult: 2 }
  convolution_param {
    num_output: 512
    pad: 1 kernel_size: 3
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  param { lr_mult: 1 }
  param { lr_mult: 2 }
  convolution_param {
    num_output: 512
    pad: 1 kernel_size: 3
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "conv4"
  top: "conv5"
  param { lr_mult: 1 }
  param { lr_mult: 2 }
  convolution_param {
    num_output: 512
    pad: 1 kernel_size: 3
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}

#========= RPN ============

layer {
  name: "rpn_conv/3x3"
  type: "Convolution"
  bottom: "conv5"
  top: "rpn/output"
  param { lr_mult: 1.0 }
  param { lr_mult: 2.0 }
  convolution_param {
    num_output: 256
    kernel_size: 3 pad: 1 stride: 1
    weight_filler { type: "gaussian" std: 0.01 }
    bias_filler { type: "constant" value: 0 }
  }
}
layer {
  name: "rpn_relu/3x3"
  type: "ReLU"
  bottom: "rpn/output"
  top: "rpn/output"
}
layer {
  name: "rpn_cls_score"
  type: "Convolution"
  bottom: "rpn/output"
  top: "rpn_cls_score"
  param { lr_mult: 1.0 }
  param { lr_mult: 2.0 }
  convolution_param {
    num_output: 18   # 2(bg/fg) * 9(anchors)
    kernel_size: 1 pad: 0 stride: 1
    weight_filler { type: "gaussian" std: 0.01 }
    bias_filler { type: "constant" value: 0 }
  }
}
layer {
  name: "rpn_bbox_pred"
  type: "Convolution"
  bottom: "rpn/output"
  top: "rpn_bbox_pred"
  param { lr_mult: 1.0 }
  param { lr_mult: 2.0 }
  convolution_param {
    num_output: 36   # 4 * 9(anchors)
    kernel_size: 1 pad: 0 stride: 1
    weight_filler { type: "gaussian" std: 0.01 }
    bias_filler { type: "constant" value: 0 }
  }
}
layer {
   bottom: "rpn_cls_score"
   top: "rpn_cls_score_reshape"
   name: "rpn_cls_score_reshape"
   type: "Reshape"
   reshape_param { shape { dim: 0 dim: 2 dim: -1 dim: 0 } }
}
layer {
  name: 'rpn-data'
  type: 'Python'
  bottom: 'rpn_cls_score'
  bottom: 'gt_boxes'
  bottom: 'im_info'
  bottom: 'data'
  top: 'rpn_labels'
  top: 'rpn_bbox_targets'
  top: 'rpn_bbox_inside_weights'
  top: 'rpn_bbox_outside_weights'
  python_param {
    module: 'rpn.anchor_target_layer'
    layer: 'AnchorTargetLayer'
    param_str: "'feat_stride': 16"
  }
}
layer {
  name: "rpn_loss_cls"
  type: "SoftmaxWithLoss"
  bottom: "rpn_cls_score_reshape"
  bottom: "rpn_labels"
  propagate_down: 1
  propagate_down: 0
  top: "rpn_cls_loss"
  loss_weight: 1
  loss_param {
    ignore_label: -1
    normalize: true
  }
}
layer {
  name: "rpn_loss_bbox"
  type: "SmoothL1Loss"
  bottom: "rpn_bbox_pred"
  bottom: "rpn_bbox_targets"
  bottom: 'rpn_bbox_inside_weights'
  bottom: 'rpn_bbox_outside_weights'
  top: "rpn_loss_bbox"
  loss_weight: 1
  smooth_l1_loss_param { sigma: 3.0 }
}

#========= RCNN ============

layer {
  name: "dummy_roi_pool_conv5"
  type: "DummyData"
  top: "dummy_roi_pool_conv5"
  dummy_data_param {
    shape { dim: 1 dim: 18432 }
    data_filler { type: "gaussian" std: 0.01 }
  }
}
layer {
  name: "fc6"
  type: "InnerProduct"
  bottom: "dummy_roi_pool_conv5"
  top: "fc6"
  param { lr_mult: 0 decay_mult: 0 }
  param { lr_mult: 0 decay_mult: 0 }
  inner_product_param {
    num_output: 4096
  }
}
layer {
  name: "fc7"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7"
  param { lr_mult: 0 decay_mult: 0 }
  param { lr_mult: 0 decay_mult: 0 }
  inner_product_param {
    num_output: 1024
  }
}
layer {
  name: "silence_fc7"
  type: "Silence"
  bottom: "fc7"
}

它的示意图如下: 这里借用了http://blog.csdn.net/zy1034092330/article/details/62044941里的图。

上面Conv layers包含了五层卷积层。 接下来,对于第五层卷积层,进行了3*3的卷积操作,输出了256个通道,当然大小与卷积前的大小相同。

然后开始分别接入了cls层与regression层。对于cls层,使用1*1的卷积操作输出了18(9*2 bg/fg)个通道的feature map,大小不变。而对于regression层,也使用1*1的卷积层输出了36(4*9)个通道的feature map,大小不变。 

对于cls层后又接了一个reshape层,为什么要接这个层呢?引用参考文献[1]的话,其实只是为了便于softmax分类,至于具体原因这就要从caffe的实现形式说起了。在caffe基本数据结构blob中以如下形式保存数据:
blob=[batch_size, channel,height,width]
对应至上面的保存bg/fg anchors的矩阵,其在caffe blob中的存储形式为[1, 2*9, H, W]。而在softmax分类时需要进行fg/bg二分类,所以reshape layer会将其变为[1, 2, 9*H, W]大小,即单独“腾空”出来一个维度以便softmax分类,之后再reshape回复原状。

我们可以用python模拟一下,看如下的程序:

>>> a=np.array([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]],[[13,14],[15,16]]])
>>> a
array([[[ 1,  2],
        [ 3,  4]],

       [[ 5,  6],
        [ 7,  8]],

       [[ 9, 10],
        [11, 12]],

       [[13, 14],
        [15, 16]]])
>>> a.shape
(4L, 2L, 2L)
然后由于caffe中是行优先,numpy也如此,那么reshape一下的结果如下:

>>> b=a.reshape(2,4,2)
>>> b
array([[[ 1,  2],
        [ 3,  4],
        [ 5,  6],
        [ 7,  8]],

       [[ 9, 10],
        [11, 12],
        [13, 14],
        [15, 16]]])

从上面可以看出reshape是把相邻通道的矩阵移到它的下面了。这样就剩下两个大的矩阵了,就可以相邻通道之间进行softmax了。从中其实我们也能发现,对于rpn每个点的18个输出通道,前9个为背景的预测分数,而后9个为前景的预测分数。

假定softmax昨晚后,我们看看是否能够回到原先?

>>> b.reshape(4,2,2)
array([[[ 1,  2],
        [ 3,  4]],

       [[ 5,  6],
        [ 7,  8]],

       [[ 9, 10],
        [11, 12]],

       [[13, 14],
        [15, 16]]])
果然又回到了原始的状态。

而对于regression呢,不需要这样的操作,那么他的36个通道是不是也是如上面18个通道那样呢?即第一个9通道为dx,第二个为dy,第三个为dw,第五个是dh。还是我们比较容易想到的那种,即第一个通道是第一个盒子的回归量(dx1,dy1,dw1,dh1),第二个为(dx2,dy2,dw,2,dh2).....。待后面查看对应的bbox_targets就知道了。先留个坑。

正如图上所示,我们还需要准备一个层rpn-data。

layer {
  name: 'rpn-data'
  type: 'Python'
  bottom: 'rpn_cls_score'
  bottom: 'gt_boxes'
  bottom: 'im_info'
  bottom: 'data'
  top: 'rpn_labels'
  top: 'rpn_bbox_targets'
  top: 'rpn_bbox_inside_weights'
  top: 'rpn_bbox_outside_weights'
  python_param {
    module: 'rpn.anchor_target_layer'
    layer: 'AnchorTargetLayer'
    param_str: "'feat_stride': 16"
  }
}

这一层输入四个量:data,gt_boxes,im_info,rpn_cls_score,其中前三个是我们在前面说过的,

data:         1*3*600*1000
gt_boxes: N*5,                   N为groundtruth box的个数,每一行为(x1, y1, x2, y2, cls) ,而且这里的gt_box是经过缩放的。
im_info: 1*3                   (h,w,scale)

rpn_cls_score是cls层输出的18通道,shape可以看成是1*18*H*W.  

输出为4个量:rpn_labels 、rpn_bbox_targets(回归目标)、rpn_bbox_inside_weights(内权重)、rpn_bbox_outside_weights(外权重)。

通俗地来讲,这一层产生了具体的anchor坐标,并与groundtruth box进行了重叠度计算,输出了kabel与回归目标。

接下来我们来看一下文件anchor_target_layer.py 

 def setup(self, bottom, top):
        layer_params = yaml.load(self.param_str_)    
		#在第5个卷积层后的feature map上的每个点取anchor,尺度为(8,16,32),结合后面的feat_stride为16,
		#再缩放回原来的图像大小,正好尺度是(128,256,512),与paper一样。
        anchor_scales = layer_params.get('scales', (8, 16, 32))  
        self._anchors = generate_anchors(scales=np.array(anchor_scales))  #产生feature map最左上角的那个点对应的anchor(x1,y1,x2,y2),
		# 尺度为原始图像的尺度(可以看成是Im_info的宽和高尺度,或者是600*1000)。
        self._num_anchors = self._anchors.shape[0]   #9
        self._feat_stride = layer_params['feat_stride'] #16

        if DEBUG:
            print 'anchors:'
            print self._anchors
            print 'anchor shapes:'
            print np.hstack((  # 输出宽和高
                self._anchors[:, 2::4] - self._anchors[:, 0::4], #第2列减去第0列
                self._anchors[:, 3::4] - self._anchors[:, 1::4], #第3列减去第1列
            ))
            self._counts = cfg.EPS
            self._sums = np.zeros((1, 4))
            self._squared_sums = np.zeros((1, 4))
            self._fg_sum = 0
            self._bg_sum = 0
            self._count = 0

        # allow boxes to sit over the edge by a small amount  
        self._allowed_border = layer_params.get('allowed_border', 0)    

        height, width = bottom[0].data.shape[-2:]   #cls后的feature map的大小
        if DEBUG:
            print 'AnchorTargetLayer: height', height, 'width', width

        A = self._num_anchors   
        # labels
        top[0].reshape(1, 1, A * height, width)     # 显然与rpn_cls_score_reshape保持相同的shape.
        # bbox_targets
        top[1].reshape(1, A * 4, height, width)     
        # bbox_inside_weights
        top[2].reshape(1, A * 4, height, width)
        # bbox_outside_weights
        top[3].reshape(1, A * 4, height, width)
setup设置了top输出的shape,并且做了一些准备工作。

接下来看forward函数。

 def forward(self, bottom, top):
        # Algorithm:
        #
        # for each (H, W) location i
        #   generate 9 anchor boxes centered on cell i
        #   apply predicted bbox deltas at cell i to each of the 9 anchors
        # filter out-of-image anchors
        # measure GT overlap

        assert bottom[0].data.shape[0] == 1, \
            'Only single item batches are supported'     # 仅仅支持一张图片

        # map of shape (..., H, W)
        height, width = bottom[0].data.shape[-2:]        
        # GT boxes (x1, y1, x2, y2, label)
        gt_boxes = bottom[1].data                          
        # im_info
        im_info = bottom[2].data[0, :]

        if DEBUG:
            print ''
            print 'im_size: ({}, {})'.format(im_info[0], im_info[1])
            print 'scale: {}'.format(im_info[2])
            print 'height, width: ({}, {})'.format(height, width)
            print 'rpn: gt_boxes.shape', gt_boxes.shape
            print 'rpn: gt_boxes', gt_boxes

        # 1. Generate proposals from bbox deltas and shifted anchors
        shift_x = np.arange(0, width) * self._feat_stride  
        shift_y = np.arange(0, height) * self._feat_stride 
        shift_x, shift_y = np.meshgrid(shift_x, shift_y)
        shifts = np.vstack((shift_x.ravel(), shift_y.ravel(),
                            shift_x.ravel(), shift_y.ravel())).transpose()
        # add A anchors (1, A, 4) to
        # cell K shifts (K, 1, 4) to get
        # shift anchors (K, A, 4)
        # reshape to (K*A, 4) shifted anchors
        A = self._num_anchors
        K = shifts.shape[0]
        all_anchors = (self._anchors.reshape((1, A, 4)) +
                       shifts.reshape((1, K, 4)).transpose((1, 0, 2)))
        all_anchors = all_anchors.reshape((K * A, 4))
        total_anchors = int(K * A)                       # 根据左上角的anchor生成所有的anchor,这里将所有的anchor按照行排列。行:K*A(K= height*width ,A=9),列:4,且按照feature map按行优先这样排下来。

        # only keep anchors inside the image   #取所有在图像内部的anchor
        inds_inside = np.where(
            (all_anchors[:, 0] >= -self._allowed_border) &
            (all_anchors[:, 1] >= -self._allowed_border) &
            (all_anchors[:, 2] < im_info[1] + self._allowed_border) &  # width
            (all_anchors[:, 3] < im_info[0] + self._allowed_border)    # height
        )[0]                                   

        if DEBUG:
            print 'total_anchors', total_anchors
            print 'inds_inside', len(inds_inside)

        # keep only inside anchors
        anchors = all_anchors[inds_inside, :]
        if DEBUG:
            print 'anchors.shape', anchors.shape

        # label: 1 is positive, 0 is negative, -1 is dont care
        labels = np.empty((len(inds_inside), ), dtype=np.float32)
        labels.fill(-1)

        # overlaps between the anchors and the gt boxes
        # overlaps (ex, gt)
        overlaps = bbox_overlaps(
            np.ascontiguousarray(anchors, dtype=np.float),
            np.ascontiguousarray(gt_boxes, dtype=np.float))
        argmax_overlaps = overlaps.argmax(axis=1)   #对于每一个anchor,取其重叠度最大的ground truth的序号
        max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]   #生成max_overlaps,(为一列)即每个anchor对应的最大重叠度
        gt_argmax_overlaps = overlaps.argmax(axis=0)          #对于每个类,选择其对应的最大重叠度的anchor序号
        gt_max_overlaps = overlaps[gt_argmax_overlaps,       
                                   np.arange(overlaps.shape[1])]  #生成gt_max_overlaps,(为一行)即每类对应的最大重叠度
        gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]  #找到那些等于gt_max_overlaps的anchor,这些anchor将参与训练rpn
        # 找到所有overlaps中所有等于gt_max_overlaps的元素,因为gt_max_overlaps对于每个非负类别只保留一个
        # anchor,如果同一列有多个相等的最大IOU overlap值,那么就需要把其他的几个值找到,并在后面将它们
        # 的label设为1,即认为它们是object,毕竟在RPN的cls任务中,只要认为它是否是个object即可,即一个
        # 二分类问题。   (总结)
		
		
		
		# 如下设置了前景(1)、背景(0)以及不关心(-1)的anchor标签
        if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:
            # assign bg labels first so that positive labels can clobber them
            labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0    #对于最大重叠度低于0.3的设为背景

        # fg label: for each gt, anchor with highest overlap  
        labels[gt_argmax_overlaps] = 1   

        # fg label: above threshold IOU
        labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1 

        if cfg.TRAIN.RPN_CLOBBER_POSITIVES:
            # assign bg labels last so that negative labels can clobber positives
            labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0
			
			
		# 取前景与背景的anchor各一半,目前一批有256个anchor.
        # subsample positive labels if we have too many
        num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)   #256*0.5=128
        fg_inds = np.where(labels == 1)[0]
        if len(fg_inds) > num_fg:
            disable_inds = npr.choice(
                fg_inds, size=(len(fg_inds) - num_fg), replace=False)
            labels[disable_inds] = -1

        # subsample negative labels if we have too many
        num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)  #另一半256*0.5=128
        bg_inds = np.where(labels == 0)[0]
        if len(bg_inds) > num_bg:
            disable_inds = npr.choice(
                bg_inds, size=(len(bg_inds) - num_bg), replace=False)
            labels[disable_inds] = -1
            #print "was %s inds, disabling %s, now %s inds" % (
                #len(bg_inds), len(disable_inds), np.sum(labels == 0))
        
		#计算了所有在内部的anchor与对应的ground truth的回归量
        bbox_targets = np.zeros((len(inds_inside), 4), dtype=np.float32)
        bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])
         
		 #只有前景类内部权重才非0,参与回归
        bbox_inside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)
        bbox_inside_weights[labels == 1, :] = np.array(cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS) #(1.0, 1.0, 1.0, 1.0)

		# Give the positive RPN examples weight of p * 1 / {num positives}
		# and give negatives a weight of (1 - p)/(num negative)    
		# Set to -1.0 to use uniform example weighting
        bbox_outside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)
        if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0:
            # uniform weighting of examples (given non-uniform sampling)
            num_examples = np.sum(labels >= 0)
            positive_weights = np.ones((1, 4)) * 1.0 / num_examples
            negative_weights = np.ones((1, 4)) * 1.0 / num_examples
        else:
            assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) &
                    (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))
            positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT /
                                np.sum(labels == 1))
            negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) /
                                np.sum(labels == 0))
        bbox_outside_weights[labels == 1, :] = positive_weights  # 前景与背景anchor的外参数相同,都是1/anchor个数
        bbox_outside_weights[labels == 0, :] = negative_weights

        if DEBUG:
            self._sums += bbox_targets[labels == 1, :].sum(axis=0)
            self._squared_sums += (bbox_targets[labels == 1, :] ** 2).sum(axis=0)
            self._counts += np.sum(labels == 1)
            means = self._sums / self._counts
            stds = np.sqrt(self._squared_sums / self._counts - means ** 2)
            print 'means:'
            print means
            print 'stdevs:'
            print stds

        # map up to original set of anchors 生成全部anchor的数据,将非0的数据填入。
        labels = _unmap(labels, total_anchors, inds_inside, fill=-1)
        bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)
        bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors, inds_inside, fill=0)
        bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors, inds_inside, fill=0)

        if DEBUG:
            print 'rpn: max max_overlap', np.max(max_overlaps)
            print 'rpn: num_positive', np.sum(labels == 1)
            print 'rpn: num_negative', np.sum(labels == 0)
            self._fg_sum += np.sum(labels == 1)
            self._bg_sum += np.sum(labels == 0)
            self._count += 1
            print 'rpn: num_positive avg', self._fg_sum / self._count
            print 'rpn: num_negative avg', self._bg_sum / self._count

        # labels 
        labels = labels.reshape((1, height, width, A)).transpose(0, 3, 1, 2)
        labels = labels.reshape((1, 1, A * height, width))
        top[0].reshape(*labels.shape)
        top[0].data[...] = labels

        # bbox_targets
        bbox_targets = bbox_targets \
            .reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)
        top[1].reshape(*bbox_targets.shape)
        top[1].data[...] = bbox_targets

        # bbox_inside_weights
        bbox_inside_weights = bbox_inside_weights \
            .reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)
        assert bbox_inside_weights.shape[2] == height
        assert bbox_inside_weights.shape[3] == width
        top[2].reshape(*bbox_inside_weights.shape)
        top[2].data[...] = bbox_inside_weights

        # bbox_outside_weights
        bbox_outside_weights = bbox_outside_weights \
            .reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)
        assert bbox_outside_weights.shape[2] == height
        assert bbox_outside_weights.shape[3] == width
        top[3].reshape(*bbox_outside_weights.shape)
        top[3].data[...] = bbox_outside_weights

这里已经有详细的注释,总的来说,rpn_cls_score的作用就是告知第五层feature map的宽和高。便于决定生成多少个anchor. 而其他的bottom输入才最终决定top的输出。


首先这里生成了所有feature map各点对应的anchors。生成的方式很特别,先考虑了左上角一个点的anchor生成,考虑到feat_stride=16,所以这个点对应原始图像(这里统一指缩放后image)的(0,0,15,15)感受野。然后取其中心点,生成比例为1:1,1:2,2:1,尺度在128,256,512的9个anchor.然后考虑使用平移生成其他的anchor.

然后过滤掉那些不在图像内部的anchor. 对于剩下的anchor,计算与gt_boxes的重叠度,再分别计算label,bbox_targets,bbox_inside_weights,bbox_outside_weights.


最后将内部的anchor的相关变量扩充到所有的anchor,只不过不在内部的为0即可。尤其值得说的是对于内部的anchor,bbox_targets都进行了运算。但是选取了256个anchor,前景与背景比例为1:1,bbox_inside_weights中只有label=1,即前景才进行了设置。正如论文所说,对于回归项,需要内部参数来约束,bbox_inside_weights正好起到了这个作用。

我们统计一下top的shape:

rpn_labels : (1, 1, 9 * height, width)

rpn_bbox_targets(回归目标): (1, 36,height, width)

rpn_bbox_inside_weights(内权重):(1, 36,height, width)

rpn_bbox_outside_weights(外权重):(1, 36,height, width)


回到stage1_rpn_train.pt,接下里我们就可以利用rpn_cls_score_reshape与rpn_labels计算SoftmaxWithLoss,输出rpn_cls_loss。

而regression可以利用rpn_bbox_pred,rpn_bbox_targets,rpn_bbox_inside_weights,rpn_bbox_outside_weights计算SmoothL1Loss,输出rpn_loss_bbox。

回到我们之前有一个问题rpn_bbox_pred的shape怎么构造的。其实从rpn_bbox_targets的生成过程中可以推断出应该采用后一种,即第一个盒子的回归量(dx1,dy1,dw1,dh1),第二个为(dx2,dy2,dw,2,dh2).....,这样顺序着来。


其实怎么样认为都是从我们方便的角度出发。



至此我们完成了rpn的前向过程,反向过程中只需注意AnchorTargetLayer不参与反向传播。因为它提供的都是源数据。


参考:

1.  http://blog.csdn.net/zy1034092330/article/details/62044941 

2. Faster RCNN anchor_target_layer.py


0
0
查看评论

Faster rcnn:实时目标检测系统,利用RPN-Net

1.   简介     近年来由于region proposal技术的成功,物体检测发展的非常快,涌现了如RCNN、SPP-net、Fast-Rcnn等一系列的目标识别系统,然而,region proposal的计算时间成为了制约这些系统成为实时监测...
  • u014156736
  • u014156736
  • 2016-06-20 00:37
  • 5414

Faster RCNN代码理解(Python) ---训练过程

最近开始学习深度学习,看了下Faster RCNN的代码,在学习的过程中也查阅了很多其他人写的博客,得到了很大的帮助,所以也打算把自己一些粗浅的理解记录下来,一是记录下自己的菜鸟学习之路,方便自己过后查阅,二来可以回馈网络。目前编程能力有限,且是第一次写博客,中间可能会有一些错误。 目录 目录...
  • u014696921
  • u014696921
  • 2017-03-04 09:56
  • 4224

使用Faster-Rcnn进行目标检测(实践篇)

原理上一篇文章,已经说过了,大家可以参考一下,Faster-Rcnn进行目标检测(原理篇)实验我使用的代码是python版本的Faster Rcnn,官方也有Matlab版本的,链接如下:py-faster-rcnn(python)faster-rcnn(matlab)环境配置按照官方的README...
  • Gavin__Zhou
  • Gavin__Zhou
  • 2016-07-28 10:42
  • 39412

Faster RCNN代码理解(Python) ---训练过程

最近开始学习深度学习,看了下Faster RCNN的代码,在学习的过程中也查阅了很多其他人写的博客,得到了很大的帮助,所以也打算把自己一些粗浅的理解记录下来,一是记录下自己的菜鸟学习之路,方便自己过后查阅,二来可以回馈网络。目前编程能力有限,且是第一次写博客,中间可能会有一些错误。 目录 ...
  • a8039974
  • a8039974
  • 2017-08-02 13:38
  • 1292

【目标检测】Faster RCNN算法详解

继RCNN,fast RCNN之后,目标检测界的领军人物Ross Girshick在2015年提出faster RCNN。目标检测速度达到15fps。
  • shenxiaolu1984
  • shenxiaolu1984
  • 2016-04-21 15:08
  • 114288

Python中choice用法与三元操作

今天随手写了一个随机答案生成器,用到了random模块的choice和三元运算符。
  • pdcxs007
  • pdcxs007
  • 2015-07-21 21:11
  • 2291

faster-rcnn 之 RPN网络的结构解析

【说明】:我想很多人在看faster-rcnn的时候,都会被RPN的网络结构和连接方式纠结,作者在文中说的不是很清晰,这里给出解析; 【首先】:大家应该要了解卷积神经网络的连接方式,卷积核的维度,反向传播时是如何灵活的插入一层,这些要了解;这里我推荐一份资料,真是写的非常清晰,就是MatConvet...
  • sloanqin
  • sloanqin
  • 2016-05-31 15:03
  • 30135

faster-rcnn 中的RPN网络的结构解析

本文转载自: http://blog.csdn.net/sloanqin/article/details/51545125 【说明】:欢迎加入:faster-rcnn 交流群 238138700,我想很多人在看faster-rcnn的时候,都会被RPN的网络结构和连接方式纠结...
  • hx921123
  • hx921123
  • 2017-02-21 14:27
  • 933

faster rcnn源码理解

理解faster rcnn的源码有几个关键点 1.算法原理、网络结构、训练过程这是基本 2.要弄懂源码里训练数据数据是怎么组织起来的,imdb,roidb,blob很关键,弄清它们的数据结构以及各个阶段是如何产生的 3.一定的python、numpy基础知识 rpn_train.pt #s...
  • u014568921
  • u014568921
  • 2016-12-12 23:07
  • 8925

[caffe笔记005]:通过代码理解faster-RCNN中的RPN

注意:整个RPN完全是笔者自己的理解,可能会有一些理解错误的地方。1. RPN简介RPN是regional proposal networks的缩写,是faster-RCNN结构中的一部分。faster-RCNN由两个子网络构成。第一个子网络RPN的作用是在给定图像上提取一定数量带有objectne...
  • happyflyy
  • happyflyy
  • 2017-02-07 22:38
  • 11653
    个人资料
    • 访问:309443次
    • 积分:4352
    • 等级:
    • 排名:第8257名
    • 原创:118篇
    • 转载:82篇
    • 译文:8篇
    • 评论:107条
    个人网站
    最新评论