Faster RCNN 演进之路 01-基石篇：从RCNN到RoI Pooling的核心思想与代码实践

1. 从RCNN到Faster RCNN：目标检测的进化逻辑

第一次接触目标检测算法时，我被RCNN的复杂流程震惊了——先提取2000个候选框，再逐个送入CNN提取特征，最后用SVM分类。这种设计在2014年确实推动了目标检测的进步，但用现在的眼光看简直像"用拖拉机跑F1赛道"。为什么后来会出现SPPNet、Fast RCNN这些改进？核心就三个痛点：

1. 重复计算：RCNN对每个候选框独立做卷积，一张图要算2000次CNN
2. 尺寸限制：必须把候选框缩放到固定尺寸（如227x227），导致物体变形
3. 训练低效：要分阶段训练CNN、SVM和回归器，无法端到端优化

这就像早期工厂的流水线：每个工人只做一个动作，效率低下还容易出错。而技术演进的方向，就是让这条"检测流水线"越来越智能高效。

2. RCNN：深度检测的开山之作

2.1 算法流程拆解

RCNN的工作流程就像工厂的装配线：

1. 候选框生成：用选择性搜索(Selective Search)在图像上生成约2000个候选区域
2. 特征提取：把每个候选区域缩放到227x227，分别输入AlexNet提取4096维特征
3. 分类识别：对每个特征向量，用训练好的SVM分类器判断类别
4. 框体修正：用回归器微调候选框位置

# 伪代码展示RCNN流程 def rcnn_predict(image): proposals = selective_search(image) # 生成约2000个候选框 features = [] for box in proposals: patch = resize(image[box], (227, 227)) # 缩放 feature = alexnet(patch) # 特征提取 features.append(feature) svm_scores = svm_classifier(features) # SVM分类 boxes = bbox_regressor(features) # 框体回归 return final_boxes

2.2 突破与局限

RCNN的mAP达到53.7%，相比传统方法DPM的35.1%是巨大飞跃。但实际使用时问题很明显：

• 速度极慢：处理一张图需要14秒（GPU）
• 内存黑洞：要存储所有候选框的特征用于SVM训练
• 训练复杂：需要分阶段训练CNN、SVM和回归器

我在第一次复现时就踩过坑：当尝试处理1000张图片时，光特征文件就占用了200GB磁盘空间，SVM训练直接内存溢出崩溃。

3. SPPNet：空间金字塔的智慧

3.1 核心创新：空间金字塔池化

SPPNet的突破点在于整图特征共享和多尺度池化。就像用同一个模具制作不同尺寸的零件：

1. 只对整图做一次CNN计算得到特征图
2. 根据候选框在特征图上截取对应区域
3. 通过空间金字塔池化(SPP)输出固定长度特征

class SpatialPyramidPool2D(nn.Module): def __init__(self, pool_sizes=[1, 2, 4]): super().__init__() self.pools = nn.ModuleList([ nn.AdaptiveMaxPool2d((size, size)) for size in pool_sizes ]) def forward(self, x): features = [pool(x).flatten(1) for pool in self.pools] return torch.cat(features, dim=1) # 拼接多尺度特征

3.2 实际效果对比

在我的实验中，SPPNet相比RCNN有三个明显提升：

1. 速度提升50倍：整图特征提取只需0.3秒
2. 支持任意尺寸输入：不再需要强制缩放
3. 多尺度特征融合：金字塔池化提升小目标检测

但SPPNet仍有硬伤：无法端到端训练。特征提取和分类还是割裂的，这就像汽车发动机和变速箱不匹配，再好的零件也发挥不出最佳性能。

4. Fast RCNN：统一架构的诞生

4.1 两大关键技术

Fast RCNN的改进就像把分散的车间整合成自动化工厂：

1. RoI Pooling：在特征图上直接截取候选区域并池化为固定尺寸
   • 例如将7x7的候选区域池化成3x3输出
2. 多任务损失：分类和框体回归联合训练

import torchvision.ops as ops class FastRCNN(nn.Module): def __init__(self, backbone): super().__init__() self.backbone = backbone self.roi_pool = ops.RoIPool((7,7), spatial_scale=1.0) self.cls_head = nn.Linear(4096, num_classes) self.reg_head = nn.Linear(4096, 4*num_classes) def forward(self, images, rois): features = self.backbone(images) # 整图特征 pooled = self.roi_pool(features, rois) # RoI池化 cls_scores = self.cls_head(pooled) reg_pred = self.reg_head(pooled) return cls_scores, reg_pred

4.2 性能飞跃

实测VGG16模型在PASCAL VOC上的表现：

Fast RCNN最大的价值在于统一了训练流程。以前需要分别训练CNN、SVM和回归器，现在一个网络搞定全部。这就像把分散的手工作坊变成了现代化生产线。

5. RoI Pooling的代码级解析

5.1 实现细节揭秘

RoI Pooling的工作流程可以分为三步：

1. 坐标映射：将原始图的候选框坐标映射到特征图
2. 区域划分：把候选区域均匀分成kxk个bin（如7x7）
3. 最大池化：对每个bin做max pooling

def roi_pooling(feature_map, rois, output_size): """ feature_map: 卷积特征图 [C, H, W] rois: 候选框坐标 [N, 4] (x1,y1,x2,y2) output_size: 池化后的尺寸 (h, w) """ # 1. 计算特征图与原始图的尺度比例 scale = feature_map.shape[1] / original_img_size # 2. 缩放ROI坐标到特征图尺度 rois = rois * scale # 3. 划分空间bins bin_h = (rois[:,3] - rois[:,1]) / output_size[0] bin_w = (rois[:,2] - rois[:,0]) / output_size[1] # 4. 对每个bin做max pooling pooled = [] for i in range(output_size[0]): for j in range(output_size[1]): h_start = rois[:,1] + i * bin_h w_start = rois[:,0] + j * bin_w h_end = rois[:,1] + (i+1) * bin_h w_end = rois[:,0] + (j+1) * bin_w # 取每个bin内的最大值 pool_val = feature_map[..., h_start.floor():h_end.ceil(), w_start.floor():w_end.ceil()].max(-1).values.max(-1).values pooled.append(pool_val) return torch.stack(pooled, dim=-1).view(-1, *output_size)

5.2 反向传播的玄机

RoI Pooling的反向传播需要特殊处理，因为前向传播时的max操作只保留最大值位置。在实现时通常要记录argmax位置：

class RoIPoolFunction(Function): @staticmethod def forward(ctx, features, rois, size): # 前向传播时记录最大值位置 ctx.save_for_backward(features, rois, argmax_data) return pooled_features @staticmethod def backward(ctx, grad_output): features, rois, argmax = ctx.saved_tensors grad_input = torch.zeros_like(features) # 只将梯度回传到前向传播时的最大值位置 for i in range(grad_output.shape[0]): grad_input[argmax[i]] += grad_output[i] return grad_input, None, None

这种设计使得Fast RCNN可以端到端训练，也是它相比SPPNet的关键优势。我在实现时曾忽略这点，导致模型无法收敛，调试两天才找到这个隐蔽的坑。