码迷,mamicode.com
首页 > 其他好文 > 详细

Faster RCNN代码解析

时间:2018-10-31 17:50:22      阅读:387      评论:0      收藏:0      [点我收藏+]

标签:net   from   object   com   size   wrapper   rap   logs   tla   

1.faster_rcnn_end2end训练

1.1训练入口及配置

    

def train():
    cfg.GPU_ID = 0
    cfg_file = "../experiments/cfgs/faster_rcnn_end2end.yml"
    cfg_from_file(cfg_file)
    if not False:
        # fix the random seeds (numpy and caffe) for reproducibility
        np.random.seed(cfg.RNG_SEED)
        caffe.set_random_seed(cfg.RNG_SEED)

    # set up caffe
    caffe.set_mode_gpu()
    caffe.set_device(0)

    imdb_name = "voc_2007_trainval"
    imdb, roidb = combined_roidb(imdb_name)
    output_dir = get_output_dir(imdb)
    max_iters = 10000
    pretrained_model = "../data/imagenet_models/ZF.v2.caffemodel"
    solver = "../models/pascal_voc/ZF/faster_rcnn_end2end/solver.prototxt"
    train_net(solver, roidb, output_dir,
              pretrained_model=pretrained_model,
              max_iters=max_iters)
if __name__ == ‘__main__‘:
train()

1.2 数据准备

    从train_net.py:combined_roidb(imdb_name)处开始,得到的是gt数据集。

    输入:“voc_2007_trainval”,  输出:imdb , roidb。 imdb是datasets.pascal_voc.pascal_voc 类,训练图像总数为5011. roidb: 长度为10022,

技术分享图片

1.3 训练

    跳转到lib/fast_rcnn/train.py:156行。

roidb = filter_roidb(roidb)

    由于这里使用的是gt数据集,所以没有过滤任何数据。

sw = SolverWrapper(solver_prototxt, roidb, output_dir,
                       pretrained_model=pretrained_model)

    训练中使用了BBOX_REG和BBOX_NORMALIZE_TARGETS,这里需要预计算BBOX的均值和方差。

    40行计算bounding-box回归目标:

self.bbox_means, self.bbox_stds =                     rdl_roidb.add_bbox_regression_targets(roidb)

    跳转到roidb.py的46行,这里对roidb中的每个元素计算‘bbox_targets’. 输入:rois: roidb[im_i][‘boxes‘], max_overlaps: [1,1,...], max_classes:[9,7,...]

roidb[im_i][bbox_targets] =                 _compute_targets(rois, max_overlaps, max_classes)

    _compute_targets()函数返回这个图像中每个推荐框的标签和回归目标(ti, 见上篇文章http://www.cnblogs.com/benbencoding798/archive/2018/10/26/9856617.html)。不过由于输入的只有真值框,所以得到的回归目标值只有0。接下来是归一化回归目标值。由于gt的值都是0,所以回归目标值也是0。

    现在到了lib/fast_rcnn/train.py:44行,建立网络结构。

self.solver = caffe.SGDSolver(solver_prototxt)

    models/pascal_voc/ZF/faster_rcnn_end2end/train.prototxt中有4个python层,下面逐一进行调试。

1.4 python层建立

  1.4.1 input-data层

    数据输入层

layer {
  name: ‘input-data‘
  type: ‘Python‘
  top: ‘data‘
  top: ‘im_info‘ (w, h, im_scales)
  top: ‘gt_boxes‘
  python_param {
    module: ‘roi_data_layer.layer‘
    layer: ‘RoIDataLayer‘
    param_str: "‘num_classes‘: 21"
  }
}

setup()函数执行:
top[0].reshape(1, 3, 600, 1000) self._name_to_top_map[data] = 0 top[1].reshape(1, 3) self._name_to_top_map[im_info] = 1 top[1].reshape(1, 4) self._name_to_top_map[gt_boxes] = 2

    在调用lib/roi_data_layer/layer.py中的setup()函数之后,调用reshape(self, bottom, top)函数。

    接着调用rpn/__init__.py。

   1.4.2 rpn-data层

Assign anchors to ground-truth targets. Produces anchor classification
labels and bounding-box regression targets.
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"
  }
}

    shape: bottom["rpn_cls_score"]: (img_number, 18, height, width) bottom["gt_boxes"]: (gt_boxes_number, 4), bottom["im_info"]: (img_number, 3), bottom["data"]: (img_number, 3, height, width).    

    接下来运行rpn/anchor_target_layer.py: setup()。首先看self._anchors

self._anchors = generate_anchors(scales=np.array(anchor_scales))

    跳转到rpn/generate_anchors.py:generate_anchors()。这里在rpn/output层特征图的每个位置会生成9个anchors。依我的理解,如果知道一张图片的大小,由于在基本层的卷积之后,图像大小会缩小到原来的1/16,所以每个anchor的位置都能在事先计算出来,并不需要放到rpn.anchor_target_layer计算。下面来看anchors是如何计算的。文中所说,基准的三个anchor size是[(16*8)*(16*8),  (16*16)*(16*16), (16*32)*(16*32)]。在代码中,16是基本大小,[8, 16, 32]是正方形框的伸缩尺度。也就是计算出基本大小上的anchor,乘以伸缩尺度,来得到在原图上的推荐框。

    rpn/generate_anchors.py这个文件是用来计算anchor的。 

ratio_anchors = _ratio_enum(base_anchor, ratios)

    base_anchor是[0,0,15,15],这个代码算出了base_size=16时,三种长宽比例的anchors。计算结果是:[[-3.5, 2, 18.5, 13], [0, 0, 15, 15], [2.5, -3, 12.5, 18]],  直接计算它们的面积,第个和第三个都不会256,这看似计算错误。然而这一个点,看似没有长度,实际上却代表了16个像素。


def _ratio_enum(anchor, ratios):
"""
Enumerate a set of anchors for each aspect ratio wrt an anchor.
"""

w, h, x_ctr, y_ctr = _whctrs(anchor)
size = w * h # 256
size_ratios = size / ratios # [512, 256, 128]
ws = np.round(np.sqrt(size_ratios)) # [sqrt(512), sqrt(256), sqrt(128)]
hs = np.round(ws * ratios) # [sqrt(512)/2, sqrt(256), 2*sqrt(128)]
anchors = _mkanchors(ws, hs, x_ctr, y_ctr)
return anchors
 

    保留根号看,这样是对的,宽和高的乘积都是256, 并且宽高比满足文中条件。

    最终9个anchors的结果是:这里需要注意的是中心点的坐标不应该乘以尺度。因为假设计算rpn/output特征图上(0,0)点处的anchors,那么这一点其实代表原图的{0,0,15,15]这一块矩形区域,而中心点正是(7.5,7.5)。9个anchors最终要得到的是在原图的坐标位置,所以中心点是不变的,只是宽度和高度会随尺度缩放。

 技术分享图片

    然后设置输出的shape。以某一图片举例,该图片在rpn/output层size为(39,64)(height, width)。

        # labels (1,1, 9×39, 64)
        top[0].reshape(1, 1, A * height, width)
        # bbox_targets (1,9×4, 39, 64)
        top[1].reshape(1, A * 4, height, width)
        # bbox_inside_weights (1,9*4, 39,64)
        top[2].reshape(1, A * 4, height, width)
        # bbox_outside_weights (1,9*4, 39,64)
        top[3].reshape(1, A * 4, height, width)    

 1.4.3 proposal 层

Outputs object detection proposals by applying estimated bounding-box
transformations to a set of regular boxes (called "anchors").    
layer {
  name: proposal
  type: Python
  bottom: rpn_cls_prob_reshape
  bottom: rpn_bbox_pred
  bottom: im_info
  top: rpn_rois
#  top: ‘rpn_scores‘
  python_param {
    module: rpn.proposal_layer
    layer: ProposalLayer
    param_str: "‘feat_stride‘: 16"
  }
}

    ProposalLayer层用于对anchors进行回归矫正得到输出的目标检测框。这层与AnchorTargetLayer相同,也会计算

self._anchors = generate_anchors(scales=np.array(anchor_scales))

    

# rois blob: holds R regions of interest, each is a 5-tuple
        # (n, x1, y1, x2, y2) specifying an image batch index n and a
        # rectangle (x1, y1, x2, y2)
        top[0].reshape(1, 5)

  1.4.4 roi-data 层

Assign object detection proposals to ground-truth targets. Produces proposal
classification labels and bounding-box regression targets.
layer {
  name: roi-data
  type: Python
  bottom: rpn_rois
  bottom: gt_boxes
  top: rois
  top: labels
  top: bbox_targets
  top: bbox_inside_weights
  top: bbox_outside_weights
  python_param {
    module: rpn.proposal_target_layer
    layer: ProposalTargetLayer
    param_str: "‘num_classes‘: 21"
  }
}

    shape

# sampled rois (0, x1, y1, x2, y2)
        top[0].reshape(1, 5)
        # labels
        top[1].reshape(1, 1)
        # bbox_targets
        top[2].reshape(1, self._num_classes * 4)
        # bbox_inside_weights
        top[3].reshape(1, self._num_classes * 4)
        # bbox_outside_weights
        top[4].reshape(1, self._num_classes * 4)

  1.5 前馈计算

  1.5.1 lib/roi_data_layer/layer.py     

        首先是得到当前批次的处理数据。当前设置的__C.TRAIN.IMS_PER_BAT CH=1,

blobs = self._get_next_minibatch()

    得到的minibatch_db如下图所示:

技术分享图片

    得到的blobs如下图所示:

技术分享图片

    这一层的输入是roidb,输出是‘data’, ‘gt_boxes‘, ‘im_info‘。

  1.5.2 lib/rpn/anchor_target_layer.py

    输入:‘rpn_cls_score‘(bottom_0) , ‘gt_boxes‘, ‘im_info‘, ‘data‘(bottom_3), 如图所示

技术分享图片

 

    total_anchors 得到卷积之后的特征图的每个anchor在原图中的位置。anchors保留所有不超过原图边界的anchors。下面的anchors都是指这个过滤了与边界相交的。

技术分享图片

     程序中会计算保留下来的anchors与真值框相关的内容。1.计算每个anchor与每个真值框的IoU, 2.得到每个anchor的最大真值框, 3.得到和每个真值框具有最大IoU的anchor序号(同一个真值框,可能有多个最大值)。4.基于阈值,赋予labels正负标签,当一个anchor和每个真值框的最大IoU小于cfg.TRAIN.RPN_NEGATIVE_OVERLAP=0.3时,赋予负标签, 对与任一真值框具有最大IoU或大于0.7阈值的anchor赋予正标签。5. 对正负样本采样,正样本数最多为128,多余的随机从中选取,负样本用256-正样本数,剩余样本设置为dondon‘t care。6.计算回归目标。

bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])
gt_boxes[argmax_overlaps, :]的数组长度和anchors相同,内容是与anchor面积IoU对应最大的真值框。计算t*(http://www.cnblogs.com/benbencoding798/archive/2018/10/26/9856617.html)
# ex_rois是anchors, gt_rois是与anchors中的每个元素对应的真值框
def
bbox_transform(ex_rois, gt_rois): ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0 ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0 ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0 gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0 gt_ctr_x = gt_rois[:, 0] + 0.5 * gt_widths gt_ctr_y = gt_rois[:, 1] + 0.5 * gt_heights targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights targets_dw = np.log(gt_widths / ex_widths) targets_dh = np.log(gt_heights / ex_heights) targets = np.vstack( (targets_dx, targets_dy, targets_dw, targets_dh)).transpose() return targets

    得到的bbox_targets如下图。

技术分享图片

7.设置权重。bbox_inside_weights,bbox_outside_weights shape为:((len(anchors), 4)
__C.TRAIN.RPN_BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)
#在对应为正样本的anchors列,内部权重给全1
bbox_inside_weights[labels == 1, :] = np.array(cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS)
# num_examples为256,就是每张图片的训练样本数
positive_weights = np.ones((1, 4)) * 1.0 / num_examples
negative_weights = np.ones((1, 4)) * 1.0 / num_examples
# 外部权重,采用平均赋值
bbox_outside_weights[labels == 1, :] = positive_weights
bbox_outside_weights[labels == 0, :] = negative_weights

    8. 当前集合到原始集合的映射(即从anchors到total_anchors)。labels,bbox_targets, bbox_inside_weights, bbox_outside_weights都做映射。9.对blob[top]的reshape。通过这一层,可以从anchors和真值框 得到每个anchor对应的回归目标值,也就是论文中的t*。并赋值了两个权重矩阵,进而可以在prototxt中计算边框回归的smooth_l1损失值。

1.5.3 lib/rpn/proposal_layer.py

    这层的目的就是利用在rpn网络中预测得到的anchors为目标的概率值和回归目标值,计算得到最终的推荐框。这里相当于知道了xa, tx,要计算x(见文章https://www.cnblogs.com/benbencoding798/p/9856617.html)

# Algorithm:
        #
        # for each (H, W) location i
        #   generate A anchor boxes centered on cell i
        #   apply predicted bbox deltas at cell i to each of the A anchors
        # clip predicted boxes to image
        # remove predicted boxes with either height or width < threshold
        # sort all (proposal, score) pairs by score from highest to lowest
        # take top pre_nms_topN proposals before NMS
        # apply NMS with threshold 0.7 to remaining proposals
        # take after_nms_topN proposals after NMS
        # return the top proposals (-> RoIs top, scores top)

    1.首先得到特征图上每个anchor分类为前景的scores. 2.和上节相同,计算anchors的坐标 3.形状格式化,anchors:(w*h*9,4), bbox_deltas:(w*h*9,4), scores:(w*h*9,1)。3.使用anchors和神经网络回归得到的bbox_deltas计算预测框。4.将越过原图像边框的proposal的相应坐标设置为边界坐标。 5.去除宽度或高度过小的proposal  6. 按proposals预测为前景的分数排序,取前pre_nms_topN个元素。7.应用nms(非极大化抑制),取前post_nms_topN个元素。8 输出到top的rpn_rois的每个推荐框的第一列元素是每批训练图像的序号索引,由于代码中只实现了单张图片训练实现,所以这列的值都是0,其余四列的值是推荐框的坐标。

    输出的rpn_rois shape: (2000, 5)

1.5.4  rpn/proposal_target_layer.py

    这里相当于fast rcnn中的数据输入层,因为前面已经得到推荐框了 。现在是计算推荐框和真值框的IoU得到具体的目标标签值(21类),并且计算预测框和真值框的偏移量。  

# Sample rois with classification labels and bounding box regressiontargets
        labels, rois, bbox_targets, bbox_inside_weights = _sample_rois(
            all_rois, gt_boxes, fg_rois_per_image,
            rois_per_image, self._num_classes)

    这是前馈传播的主要计算内容。all_rois是rois和gt的合集,fg_rois_per_image = 128* 1/4, rois_per_image = 128.

    1.首先计算all_rois与gt的IoU。此时all_rois shape: (2002,5), gt_boxes: (2,5), 得到的overlaps shape : (2002,2)

# overlaps: (rois x gt_boxes)
    overlaps = bbox_overlaps(
        np.ascontiguousarray(all_rois[:, 1:5], dtype=np.float),
        np.ascontiguousarray(gt_boxes[:, :4], dtype=np.float))

    2.根据overlaps得到all_rois的labels。

labels = gt_boxes[gt_assignment, 4]

    3. 根据阈值,选择前景和背景rois和labels.

    4.计算rois与对应的gt的偏移量。

    5.将targets映射到84类中,只有前景的targets才进行映射,背景的都是0.对应类的权重是1. bbox_targets shape: (128, 84)

技术分享图片

 

Faster RCNN代码解析

标签:net   from   object   com   size   wrapper   rap   logs   tla   

原文地址:https://www.cnblogs.com/benbencoding798/p/9858819.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!