faster-rcnn构建backbone（fpn结构）

最新推荐文章于 2024-10-28 16:06:15 发布
最新推荐文章于 2024-10-28 16:06:15 发布
阅读量2k 收藏 8
点赞数 2
文章标签： pytorch 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45103604/article/details/124720251
版权
本文介绍了如何使用torchvision在Faster R-CNN中改造VGG16和ResNet50模型，移除FPN结构，选择适当特征层并调整输出通道，以便于目标检测任务，特别是针对小目标的检测。作者还展示了如何构建MobilenetV3-Large和EfficientNet-B0的FPN版本，并提供了关键代码片段和模型构建细节。
摘要由CSDN通过智能技术生成

torch 1.10以上 对应torch vision

不含fpn结构（一个预测特征层）

修改train文件更改create_model

导入包

import os
import datetime
import torch
import transforms
from network_files import FasterRCNN, AnchorsGenerator
from my_dataset import VOCDataSet
from train_utils import GroupedBatchSampler, create_aspect_ratio_groups
from train_utils import train_eval_utils as utils
def create_model(num_classes):
import torchvision
from torchvision.models.feature_extraction import create_feature_extractor

# vgg16
backbone = torchvision.models.vgg16_bn(pretrained=False)
# pretrained设为true会自动下载预训练权重，实例化vgg16模型
# print(backbone)
backbone = create_feature_extractor(backbone, return_nodes={"features.42": "0"})
# out = backbone(torch.rand(1, 3, 224, 224))
# print(out["0"].shape)
backbone.out_channels = 512

采用下采样16倍的特征层不要32倍，（由原图像224*224到7*7）倍率过大难以检测尺度较小的目标。针对vgg16：

# def forward(self, x: torch.Tensor) -> torch.Tensor:
#    x = self.features(x)
#    x = self.avgpool(x)
#    x = torch.flatten(x, 1)
#    x = self.classifier(x)
#    return x

feature：14*14*512后即是max pooling7*7*512所有去掉全连接层

"0"：构建backbone后对应值

通过create_feature_extractor方法重构backbone能获取中间层的输出

return_nodes={"features.42": "0"}

其中features.42对应最后一个卷积层14*14*512的最后一个模块

查看方法：

1.查看源码模型nodes

2.print(backbone)设断点如下：

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU(inplace=True)
    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU(inplace=True)
    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (7): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (9): ReLU(inplace=True)
    (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (12): ReLU(inplace=True)
    (13): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (14): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (16): ReLU(inplace=True)
    (17): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (19): ReLU(inplace=True)
    (20): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (21): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (26): ReLU(inplace=True)
    (27): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (28): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (29): ReLU(inplace=True)
    (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (31): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (32): ReLU(inplace=True)
    (33): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (35): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (36): ReLU(inplace=True)
    (37): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (38): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (39): ReLU(inplace=True)
    (40): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (41): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (42): ReLU(inplace=True)
    (43): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)
删除maxpooling,保留至42层

为backbone设置一个参数

# out = backbone(torch.rand(1, 3, 224, 224))
# print(out["0"].shape)
查看该处断点输出out shape
backbone.out_channels = 512

以上vgg16backbone构建完成

resnet50：

# resnet50 backbone
# backbone = torchvision.models.resnet50(pretrained=False)
# # print(backbone)
# backbone = create_feature_extractor(backbone, return_nodes={"layer3": "0"})
# layer3对应conv4刚好下采样16倍
# # out = backbone(torch.rand(1, 3, 224, 224))
# 下采样16倍后224/16=14
# # print(out["0"].shape)
# shape为14*14，channel为1024
# backbone.out_channels = 1024

resnet101,152同理

EfficientNetB0：

# EfficientNetB0
# backbone = torchvision.models.efficientnet_b0(pretrained=False)
# # print(backbone)
# backbone = create_feature_extractor(backbone, return_nodes={"features.5": "0"})
# 通过stage6刚好下采样16倍，stage7的stride为2，下采样变为32倍
# stage6对应feature模块索引为5的位置
# # out = backbone(torch.rand(1, 3, 224, 224))
# # print(out["0"].shape)
# size(1,112,14,14)
# backbone.out_channels = 112

搭建faster-rcnn

anchor_generator = AnchorsGenerator(sizes=((32, 64, 128, 256, 512),),
                                    aspect_ratios=((0.5, 1.0, 2.0),))
# 实例化AnchorsGenerator
# sizes元组类型：一个特征层上使用的anchorsizes
# aspect_ratios元组类型：每一个sizes的ratios
# 若不定义在fasterrcnn内部会自动构建fpn结构的AnchorsGenerator和roi_pooler
roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],  # 在哪些特征层上进行RoIAlign pooling
# MultiScaleRoIAlign是mask-rcnn中的结构，更加精确
                                                output_size=[7, 7],  # RoIAlign pooling输出特征矩阵尺寸
                                                sampling_ratio=2)  # 采样率

model = FasterRCNN(backbone=backbone,
                   num_classes=num_classes,
                   rpn_anchor_generator=anchor_generator,
                   box_roi_pool=roi_pooler)

return model

以上faster-rcnn不含rpn结构

含fpn

1.获取那些特征层？

2.特征层对应哪些模块的输出？

mobilenetv3-large 
import os
import datetime

import torch

import transforms
from network_files import FasterRCNN, AnchorsGenerator
from my_dataset import VOCDataSet
from train_utils import GroupedBatchSampler, create_aspect_ratio_groups
from train_utils import train_eval_utils as utils
from backbone import BackboneWithFPN, LastLevelMaxPool


def create_model(num_classes):
    import torchvision
    from torchvision.models.feature_extraction import create_feature_extractor

    # --- mobilenet_v3_large fpn backbone --- #
    backbone = torchvision.models.mobilenet_v3_large(pretrained=True)
    # print(backbone)
    return_layers = {"features.6": "0",   # stride 8
                     "features.12": "1",  # stride 16
                     "features.16": "2"}  # stride 32
# 以上在pool前的16个模块，s列查看下采样倍数
# 提供给fpn的每个特征层channel
in_channels_list = [40, 112, 960]
new_backbone = create_feature_extractor(backbone, return_layers)
img = torch.randn(1, 3, 224, 224)
outputs = new_backbone(img)
[print(f"{k} shape: {v.shape}") for k, v in outputs.items()]

即可查看shape和channel

fpn结构：

backbone_with_fpn = BackboneWithFPN(new_backbone,
                                    return_layers=return_layers,
                                    in_channels_list=in_channels_list,
                                    out_channels=256,
                                    extra_blocks=LastLevelMaxPool(),  #最高层之上maxpooling采样，尺度更小，只参与rpn部分运算，在fastrcnn中不使用
                                    re_getter=False)  # 重构过backbone不需要再重构
anchor_sizes = ((64,), (128,), (256,), (512,))
aspect_ratios = ((0.5, 1.0, 2.0),) * len(anchor_sizes)
anchor_generator = AnchorsGenerator(sizes=anchor_sizes,
                                    aspect_ratios=aspect_ratios)

RoIAlign在fastrcnn中使用到的

roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0', '1', '2'],  # 在哪些特征层上进行RoIAlign pooling
                                                output_size=[7, 7],  # RoIAlign pooling输出特征矩阵尺寸
                                                sampling_ratio=2)  # 采样率

model = FasterRCNN(backbone=backbone_with_fpn,
                   num_classes=num_classes,
                   rpn_anchor_generator=anchor_generator,
                   box_roi_pool=roi_pooler)

return model

以下efficientnet_b0

 

# --- efficientnet_b0 fpn backbone --- #
# backbone = torchvision.models.efficientnet_b0(pretrained=True)
# # print(backbone)
# return_layers = {"features.3": "0",  # stride 8
#                  "features.4": "1",  # stride 16
#                  "features.8": "2"}  # stride 32
# # 提供给fpn的每个特征层channel
# in_channels_list = [40, 80, 1280]
# new_backbone = create_feature_extractor(backbone, return_layers)
# # img = torch.randn(1, 3, 224, 224)
# # outputs = new_backbone(img)
# # [print(f"{k} shape: {v.shape}") for k, v in outputs.items()]

自己训练效果一般很差，建议采用coco上预训练权重

Faster-RCNN特征图可视化
qq_31930361的博客
12-09 7324
Faster-RCNN特征图可视化 pytorch官方的FasterRCNN算法，backbone部分是加了FPN的resnet50，整体是这样的结构 。由于特征矩阵实在是看不懂在一层一层的Layer中发生了什么效果，因此将每一层的特征图绘制出来。 1. 算法结构 大佬画的FasterRCNN算法结构： FasterRCNN四大接口： transform backbone rpn roi_heads Backbone的输入是张图像，输出是feature map（特征图）。这些特征图会送去后面的RPN（区域
基于pytorch的faster-rcnn目标检测框架
qq_16117931的博客
11-15 1528
基于pytorch的faster-rcnn目标检测框架 paper:Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks pytorch-faster-rcnn github-----pytorch-faster-rcnn 1. 简介 faster rcnn是何凯明等大神在2015年提出目标检测算法， 一直作为经典的两阶段检测算法。该算法在2015年的ILSVRV和COCO竞赛中获得多项第一。本检测框架是
Faster R-CNN backbone - ResNet101.zip
07-03
Faster R-CNN 的基础网络，ckpt 文件
Faster R-CNN
HY的博客
10-28 2882
上文提到的k就是anchors的数量，所以2k个分数就是9个anchors的共18个分数，36（4×9）个坐标。这个2k score只区分是不是目标，输出候选区域属于前景（物体）和背景的分数，这里注意，这里的分类只区分是否包含目标，至于所包含目标的类别，是Faster-RCNN最后的分类网络干的事情。由于是2分类（有无物体两种分类），所以它的维度是2k score（2个分数）。2k score，因为RPN是提候选框，还不用判断类别，所以只要求区分是不是物体就行，2个分数：前景（物体）的分数，和背景的分数；
faster r-cnn实现--backbone
SuperJayzz1的博客
03-21 1123
backbone的意思就是骨干网络，backbone+head subnet就可以组成一个目标检测网络，为了有一个好的初始值以及加快训练，往往会使用imagenet的预训练模型作为backbone，以vgg16作为backbone为例。 上节说到就是在vgg中间塞一个rpn，也就是在分类的全连接层之前加rpn，那么我们把这两部分分开。用的是torchvision的实现和预训练模型。 def load_backbonevgg16(pretrained=True,**kwargs): model=vgg16(p
3 -【Faster R-CNN】之 backbone 代码精读
weixin_37804469的博客
02-01 639
在上一篇文章中，我们得到了图像尺寸统一的 batch 了，接下来，就是 feed 到 backbone 中 获取 feature map。
faster rcnn fpn_FPN+RetinaNet
weixin_39770311的博客
11-22 383
FPN:Feature Puramid Networks for Object Detection11.18在学习RetinaNet的过程中也涉及到FPN部分，虽然现在其作用已经厘清，但是还是想把原文看看，大概两周没有看论文了，要么撸代码，要么做一些比较细碎的工作去了，今天看半天，总是不能静下心来，不过今天熬，我也得熬完这篇文章，因为拖到第二题我会更不可能好好学习了。11.19说话不负责任真好，我...
笔记：Faster R-CNN系列以及FPN
pangpangben的博客
05-12 2596
R-CNN: 注意首先去掉AlexNet的全连接层，则剩下的AlexNet的最后一层经过展平处理为4096维，则2000个候选区域经过AlexNet后为20004096维矩阵（每一行为一个候选区域的特征向量） 20004096的每一行为一个候选区域的特征向量，而409620的每一列表示一种分类器（比如，第一列为猫的分类器，第二列为狗的分类器），得到的200020矩阵（例如，第一行的第一个元素表示第一个候选区域为猫的概率，第一行第二个元素表示第一个候选区域为狗的概率）的每一列表示每个候选区域属于某分类
keras-faster-rcnn-master.zip
09-26
二、Keras实现Faster R-CNN的结构 在Keras中，Faster R-CNN通常包含以下部分： 1. 基础网络（Backbone）：通常是预训练的VGG16或ResNet等深度网络，用于提取图像的特征。 2. RPN网络：在基础网络的顶层特征图上...
Faster-RCNN网络实现目标检测----pytorch
weixin_43227526的博客
07-19 1879
pytorch框架实现faster-RCNN网络 https://blog.csdn.net/weixin_44791964/article/details/105739918 代码来自： https://github.com/bubbliiiing/faster-rcnn-pytorch 1 faster-RCNN网络概述 Faster-RCNN是一种two-stage的目标检测方法，（与one-stage方法相比two-stage的目标检测方法检测精度高，但是速度较慢） Faster-RCNN网络对
Faster-RCNN 中的 anchor 与原图中 boundingbox 的对应关系
Yafee的专栏
03-23 4326
通常在 Flag 立下之后的第一篇博客，总想把很多东西都放在一篇文章里面说得透透的，这样就像是在一个迷宫，越走发现可以走的路越多，所以往往就偏离主线越来越远，因此原计划就成了烂尾楼。 而解决拖延症的最好办法就是抛弃完美主义，无论写的多烂，先搞定一个版本，后面再改。因此本篇就是出于这个初衷，可能有理解不到位的地方，希望大家讨论指正。 闲话少叙，下面进入主题 ------------------...
Faster R-CNN backbone - VGG16.zip
05-19
Faster R-CNN 的基础网络，ckpt 文件
目标检测系列视频讲解(RCNN>FastRCNN>FasterRCNN>FPN>MaskRCNN)
03-13
自己精心整理的目标检测系列视频讲解mp4,从RCNN>FastRCNN>FasterRCNN>FPN>MaskRCNN,华文讲解,很详细! 01懒人学RCNN.mp4 02懒人学FastRCNN.mp4 03懒人讲FasterRCNN之简介.mp4 04懒人学FasterRCNN之融合.mp4 05懒人讲FasterRCNN之RPN.mp4 06懒人讲FPN之引言.mp4 07懒人讲FPN之深入浅出FPN.mp4 08懒人讲FPN之FasterRCNN实践.mp4 09懒人学MaskRCNN之介绍.mp4 10懒人学MaskRCNN之RoIAlign.mp4 11懒人学MaskRCNN之画龙点睛.mp4 12懒人学MaskRCNN之Architecture.mp4 13懒人学MaskRCNN之Architecture&画龙点睛.mp4 14懒人学Focal Loss.mp4
fasterrcnn_resnet50_fpn_coco-258fb6c6.pth
09-01
fasterrcnn_resnet50_fpn_coco-258fb6c6.pth fasterrcnn_resnet50_fpn_coco-258fb6c6.pthfasterrcnn_resnet50_fpn_coco-258fb6c6.pthfasterrcnn_resnet50_fpn_coco-258fb6c6.pth
faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
06-16
mmdetection2.x版本的fasterrcnn权重，可以测试自己安装的是否成功mmdetection2.x版本的fasterrcnn权重，可以测试自己安装的是否成功 这个总是自动要积分,回复我我可以改过来
mmdetection测试权重文件--faster_rcnn_r50_fpn_1x_20181010-3d1b3351.pth
04-23
mmdetection测试权重文件--faster_rcnn_r50_fpn_1x_20181010-3d1b3351.pth
更换目标检测的backbone（以Faster RCNN为例）_frozenbatchnorm2d
2301_82243078的博客
04-20 1065
roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[‘0’], # 在哪些特征层上进行RoIAlign pooling。output_size=[7, 7], # RoIAlign pooling输出特征矩阵尺寸。(img-46j4mFPs-1713613100508)]从而完成BackboneWithFPN的backbone的构建。sampling_ratio=2) # 采样率。
后R-CNN时代的目标检测综述(转)
JustForYou的博客
08-27 1661
Thanks ：https://zhuanlan.zhihu.com/p/38709522 前言深度学习助力目标检测达到了一个前所未有的高峰。自 2014 年以来，目标检测框架分为two-stage 和 one-stage 两大类，前者以经典方法 Faster R-CNN 为代表，后者以 YOLO 和 SSD 为主要框架。近年来，两类最深刻的idea：更好的基础网络 & 融合不同...
FASTERRCNN的代码过程！！！之fpn。
xiaommianyang的博客
07-21 532
fpn
faster-rcnn+resnet50预训练权重
最新发布
12-26
上述Python代码片段展示了如何简便地从torchvision库中加载带有FPN（Feature Pyramid Network）结构增强版的Faster R-CNN ResNet-50模型，并将其设置为评估模式以便于推断操作[^2]。 值得注意的是，当提到具体硬件...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>