Faster R-CNN里的RPN网络到底在干嘛？用PyTorch手写一个简化版带你彻底搞懂

目标检测领域的从业者都知道，Faster R-CNN之所以能成为经典，很大程度上得益于它创新性地引入了区域提议网络（RPN）。但很多人在学习时都会遇到这样的困惑：RPN生成的锚框（Anchor）到底是如何工作的？那些密密麻麻的候选框是怎么从特征图上冒出来的？本文将用最直观的方式，带你从零实现一个简化版RPN，彻底揭开它的神秘面纱。

1. RPN的核心设计思想

RPN的本质是一个"注意力机制"，它告诉后续网络："图像中这些区域可能有物体，值得重点关注"。与传统滑动窗口方法不同，RPN通过神经网络自动学习如何生成高质量的候选区域。

RPN的三大核心组件：

• 锚框生成器：在特征图的每个位置上预设多种尺度和长宽比的基准框
• 分类分支：判断每个锚框包含物体的概率（前景/背景）
• 回归分支：对锚框位置进行微调，使其更贴合真实物体

python复制class RPNHead(nn.Module):
    def __init__(self, in_channels=256, num_anchors=9):
        super().__init__()
        # 分类分支：输出每个锚框是前景的概率
        self.cls_layer = nn.Conv2d(in_channels, num_anchors, kernel_size=1)
        # 回归分支：输出锚框的偏移量(dx, dy, dw, dh)
        self.reg_layer = nn.Conv2d(in_channels, num_anchors*4, kernel_size=1)

2. 锚框生成的秘密

锚框是RPN的基础单元，理解它的生成逻辑至关重要。假设我们有一张800x600的输入图像，经过主干网络下采样16倍后，得到50x38的特征图。在每个特征点位置上，我们会生成k个不同尺度和长宽比的锚框。

典型锚框配置：

python复制def generate_anchors(base_size=16, ratios=[0.5,1,2], 
                    scales=[8,16,32]):
    # 生成基准锚框(中心在(0,0))
    anchors = []
    for scale in scales:
        for ratio in ratios:
            w = scale * math.sqrt(ratio)
            h = scale / math.sqrt(ratio)
            anchors.append([-w/2, -h/2, w/2, h/2])
    return torch.tensor(anchors)

# 示例：生成9个基准锚框
base_anchors = generate_anchors()

3. RPN的双任务学习机制

RPN需要同时完成分类和回归两个任务，这通过多任务损失函数实现：

code复制L({pi}, {ti}) = (1/Ncls)∑Lcls(pi, pi*) + λ(1/Nreg)∑pi*Lreg(ti, ti*)

其中pi是预测为前景的概率，pi是真实标签（1为正样本，0为负样本），ti是预测的边界框偏移量，ti是与真实框的偏移量。

正负样本分配策略：

• 正样本：与任意真实框IoU>0.7，或与某真实框有最大IoU
• 负样本：与所有真实框IoU<0.3
• 忽略样本：0.3<IoU<0.7（不参与训练）

python复制def rpn_loss(pred_cls, pred_reg, gt_boxes, anchors):
    # 1. 计算anchors与gt_boxes的IoU矩阵
    iou_matrix = box_iou(anchors, gt_boxes)
    
    # 2. 分配正负样本标签
    max_iou, _ = iou_matrix.max(dim=1)
    labels = torch.zeros(len(anchors))
    labels[max_iou > 0.7] = 1    # 正样本
    labels[max_iou < 0.3] = 0    # 负样本
    
    # 3. 计算分类损失（二分类交叉熵）
    cls_loss = F.binary_cross_entropy_with_logits(pred_cls, labels)
    
    # 4. 计算回归损失（仅正样本参与）
    pos_mask = labels == 1
    if pos_mask.sum() > 0:
        # 计算回归目标：Δx, Δy, Δw, Δh
        matched_gt = gt_boxes[iou_matrix.argmax(dim=1)]
        reg_targets = box2delta(anchors[pos_mask], matched_gt[pos_mask])
        reg_loss = F.smooth_l1_loss(pred_reg[pos_mask], reg_targets)
    else:
        reg_loss = pred_reg.sum() * 0
    
    return cls_loss + reg_loss * 10  # λ通常取10

4. 从理论到实践：简化版RPN实现

现在我们将上述组件整合成一个完整的简化版RPN：

python复制class SimpleRPN(nn.Module):
    def __init__(self, feat_channels=256, anchor_scales=[8,16,32],
                 anchor_ratios=[0.5,1,2]):
        super().__init__()
        self.anchor_generator = AnchorGenerator(anchor_scales, anchor_ratios)
        self.rpn_head = RPNHead(feat_channels, len(anchor_scales)*len(anchor_ratios))
        
    def forward(self, features, image_size):
        # 1. 生成所有锚框
        anchors = self.anchor_generator(features, image_size)
        
        # 2. RPN预测
        pred_cls = self.rpn_head.cls_layer(features)  # [B, A, H, W]
        pred_reg = self.rpn_head.reg_layer(features)  # [B, A*4, H, W]
        
        # 3. 转换预测结果格式
        pred_cls = pred_cls.permute(0,2,3,1).reshape(-1,1)  # [B*H*W*A, 1]
        pred_reg = pred_reg.permute(0,2,3,1).reshape(-1,4)  # [B*H*W*A, 4]
        
        return pred_cls, pred_reg, anchors

训练过程的关键细节：

1. 通常采用"图像中心化"策略，即只训练位于图像有效区域内的锚框
2. 使用NMS（非极大值抑制）过滤重叠的候选框，通常保留前2000个训练，测试时保留300个
3. 正负样本比例控制在1:1，避免样本不平衡

python复制def filter_proposals(proposals, scores, image_shape, nms_thresh=0.7, top_n=2000):
    # 1. 裁剪越界提案
    proposals = clip_boxes(proposals, image_shape)
    
    # 2. 移除小面积提案
    keep = remove_small_boxes(proposals, min_size=16)
    proposals, scores = proposals[keep], scores[keep]
    
    # 3. 按得分排序
    order = scores.argsort(descending=True)[:top_n]
    
    # 4. 应用NMS
    keep = nms(proposals[order], scores[order], nms_thresh)
    
    return proposals[keep]

5. RPN的进阶理解与调优

理解了基础实现后，我们还需要掌握一些实战经验：

锚框设计的艺术：

• 尺度选择应与数据集中的物体大小分布匹配
• 长宽比要考虑目标物体的常见形状（如行人检测需要更高的锚框）
• 过密的锚框会增加计算量，但可能提升小物体检测效果

训练技巧：

• 使用OHEM（在线难例挖掘）提升困难样本的学习效果
• 采用GN（Group Normalization）替代BN（Batch Normalization），在小batch size时更稳定
• 对回归目标进行标准化（除以锚框的宽高）使训练更稳定

python复制# 改进版的回归目标计算
def box2delta(boxes, targets):
    # 计算中心点偏移和宽高缩放的对数
    boxes_x = (boxes[:, 0] + boxes[:, 2]) * 0.5
    boxes_y = (boxes[:, 1] + boxes[:, 3]) * 0.5
    boxes_w = boxes[:, 2] - boxes[:, 0]
    boxes_h = boxes[:, 3] - boxes[:, 1]
    
    targets_x = (targets[:, 0] + targets[:, 2]) * 0.5
    targets_y = (targets[:, 1] + targets[:, 3]) * 0.5
    targets_w = targets[:, 2] - targets[:, 0]
    targets_h = targets[:, 3] - targets[:, 1]
    
    dx = (targets_x - boxes_x) / boxes_w
    dy = (targets_y - boxes_y) / boxes_h
    dw = torch.log(targets_w / boxes_w)
    dh = torch.log(targets_h / boxes_h)
    
    return torch.stack([dx, dy, dw, dh], dim=1)

6. RPN的变体与演进

随着目标检测技术的发展，RPN也衍生出多种改进版本：

主流变体对比：

FPN-RPN的实现要点：

python复制class FPNRPN(nn.Module):
    def __init__(self, in_channels_list, anchor_scales_per_level):
        super().__init__()
        # 为每个特征层级创建独立的RPN头
        self.rpn_heads = nn.ModuleList()
        for in_channels in in_channels_list:
            self.rpn_heads.append(RPNHead(in_channels))
        
        # 不同层级的锚框尺度不同
        self.anchor_generators = nn.ModuleList()
        for scales in anchor_scales_per_level:
            self.anchor_generators.append(AnchorGenerator(scales))

在实现简化版RPN的过程中，最让我印象深刻的是锚框与特征图位置的对应关系。刚开始我总以为锚框是在原图上生成的，实际上它们完全对应于特征图上的位置，只是通过感受野反推回原图坐标。这种空间对应关系是理解RPN工作机制的关键。