faster-rcnn构建backbone（fpn结构）

最新推荐文章于 2024-07-25 13:50:13 发布
最新推荐文章于 2024-07-25 13:50:13 发布
阅读量1.9k 收藏 8
点赞数 2
文章标签： pytorch 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45103604/article/details/124720251
版权

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上预训练权重

余幼时即嗜学^
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Faster-RCNN网络backbone主干网络源码解析
吉米_王
03-30 3688
声明：今天我们解析的Faster-RCNN网络底层源码的backbone主干网络是由ResNet和FPN构成，以前也见过VGG的backbone主干网络构成的Faster-RCNN网络，相关论文我之前也草草的过了一遍，作者原文使用的是VGG构建的主干网络。今天的源码解析均依据，手中现有代码实现。 Faster-RCNN网络结构介绍 我们今天就按照这个顺序来简单分析一下Faster-RCNN网络底层源码： backbone主干网络 参数可控的ResNet50 or ResNet101网络 残差.
Faster R-CNN+FPN+ResNet-101项目。、
dpasdfjk66的博客
07-16 1690
项目实现环境搭建二级目录三级目录 先说下自己的环境：ubuntu18+python3.6+torch0.4.1+RTX2080Ti 哎，硬件更新了，以前的代码跑起来可费劲了 还有这个环境 cuda9.0+cudnn7.0 github项目地址：https://hub.fastgit.org/potterhsu/easy-fpn.pytorch 要是打不开，搜索最后的名字 环境搭建 RTX2080Ti对应的arch是sm_75，其他卡需要自己查清楚再对应修改 遇到gcc编译器报错，试下在makefile等脚本
Backbone 之 FPN：特征金字塔 （Pytorch实现及代码解析）
2401_85112148的博客
05-29 914
首先对C5进行1×1卷积降低通道数得到P5，然后依次进行上采样得到P4、P3和P2，目的是得到与C4、C3与C2长宽相同的特征，以方便。这里采用。
使用mmdetection训练模型--记faster-rcnn不同backbone性能比较
hedgehogbb的博客
12-15 4322
使用mmdetection训练模型--记faster-rcnn不同backbone性能比较
【目标检测与图像分割】Faster-RCNN 和 Mask-RCNN详解
一个努力写代码的小菜鸟，目前主要从事图像算法，目标检测/分割，模型量化与部署的工作
02-04 2084
图像分割：图像分割是对图像中属于特定类别的像素进行分类的过程叫图像分割，属于pixel-wise即像素级别的下游任务。简单来说，图像分割就是按像素进行分类的问题。传统的图像分割算法是基于灰度值的不连续性和相似的性质来进行分割，而深度学习则是利用卷积神经网络，来理解图像中的每个像素所代表的含义。基于深度学习的图像分割技术主要分为这两类：语义分割及实例分割。将完整的图像输入特征提取网络得到特征图使用RPN结构生成候选框信息，将RPN生成的候选框位置投影到原始的特征图的对应位置，得到对应的特征矩阵。
mmdet更改faster-rcnn的主干网络训练
m0_46022167的博客
05-02 1903
最近在学习mmdet这个工具包，用faster-rcnn训练yymnist，源代码中采用的主干网络为resnet50，在此基础上，尝试着更改了主干网络为mobilenetV2，其余暂时不变，竟然跑通了，再来学习网络结构。 打开mmdet/models/backbones/mobilenet_v2.py，查看mobilenetV2的参数说明， # model settings model = dict( type='FasterRCNN', backb...
目标检测篇-Faster-RCNN论文精读
acx0000的博客
02-20 3273
Faster RCNN论文精读包括其网络结构、RPN模块讲解、Fast RCNN部分的roi pooling以及两部分的回归和分类损失函数的计算。
Faster-RCNN网络详解
ThreeStones1029的博客
05-21 2447
前面铺垫都是为了学习最终的Faster-RCNN网络，为此学习了PASCAL VOC数据集、COCO数据集、评价指标、SS算法、R-CNN网络、Fast-RCNN网络，这些可以到本文参考博客查看。本文有两个目的，其一是作为本人自己的笔记，方便自己巩固复习；其二，希望拙劣的见解能够帮助到正在自学的朋友。
Faster-RCNN代码详解
weixin_51528791的博客
01-23 1391
部分注释中写的参数以mobilenet为Backbone，Pascal VOC为数据集作举例注释以特征图size=(34,25)为例，不同大小的图片生成的特征图尺寸不一定相同。
keras-faster-rcnn-master.zip
09-26
二、Keras实现Faster R-CNN的结构 在Keras中，Faster R-CNN通常包含以下部分： 1. 基础网络（Backbone）：通常是预训练的VGG16或ResNet等深度网络，用于提取图像的特征。 2. RPN网络：在基础网络的顶层特征图上...
基于MASK-RCNN人体姿态识别
04-04
MASK-RCNN是Facebook AI Research团队在2017年提出的一种深度学习模型，它在 Faster R-CNN的基础上进行了扩展，增加了像素级别的语义分割任务。MASK-RCNN不仅能够完成目标检测（识别物体并框出其位置），还能同时...
tensorflow-使用tensorflow实现的Mask-RCNN算法.zip
03-02
该算法是在 Faster R-CNN（快速区域卷积神经网络）基础上发展起来的，由Kaiming He, Georgia Gkioxari, Piotr Dollar, 和 Ross Girshick在2017年的论文《Mask R-CNN》中提出。它不仅能够识别图像中的对象，还能精确...
Python-用PyTorch实现FasterRCNN
08-09
在`faster_rcnn_pytorch-master`项目中，你可能会找到以下文件和组件： - `config.py`: 存储模型配置，如网络结构、学习率、训练轮数等。 - `models/`: 包含Faster R-CNN的网络结构定义。 - `data/`: 数据预处理和...
Mask-RCNN-pytorch.zip
05-31
2. `models/`：包含Mask R-CNN模型的定义，可能包括Backbone（如ResNet）、Feature Pyramid Network（FPN）以及RoIAlign操作的实现。 3. `datasets/`：数据集加载器，负责处理COCO或其他数据集，提供训练和验证所需...
【AI】Pytorch 平台随机种子设置说明
张哥频道：电生理信号和磁共振成像
07-24 197
Pytorch 平台随机种子设置说明
【Pytorch实战教程】Pytorch中model.load_state_dict()的详细介绍
最新发布
惊鸿若梦一书生
07-25 1621
该方法用于将预先保存的参数字典加载到模型中。这种方法非常灵活，适用于加载不同环境中的模型参数。是 PyTorch 中加载模型参数的标准方法。通过理解state_dict和strict参数的用法，可以灵活地在不同模型版本之间加载和迁移参数，提高模型的复用性和管理效率。
【Pytorch实战教程】Pytorch中model.train()和model.eval()的作用
惊鸿若梦一书生
07-22 271
在 PyTorch 中，`model.train()` 和 `model.eval()` 用于设置模型的`训练模式`和`评估模式`，它们的作用主要涉及模型中的特定层如批归一化（Batch Normalization）和丢弃（Dropout）等。
用PyTorch从零开始编写DeepSeek-V2
deephub
07-23 4719
本文详细介绍了DeepSeek-V2语言模型，这是一个强大的开源混合专家（MoE）语言模型，采用创新的架构来提高训练和推理的经济性和效率。DeepSeek-V2采用了两种核心技术：细粒度专家分割和共享专家隔离，这两种策略显著提高了专家的专业化水平。此外，文章还介绍了多头隐性注意力（MLA），这是一种改进的注意力机制，通过低秩键值联合压缩和解耦旋转位置嵌入，优化了模型的存储和计算效率。除了理论探讨，我们通过编写代码实现DeepSeek-V2，可以更深入地理解其架构和工作原理。
Faster-RCNN的特征图的代码
05-26
Faster-RCNN的特征图提取部分代码如下： ```python import torch import torchvision import torchvision.models as models import torchvision.transforms as transforms from torchvision.models.detection import fasterrcnn_resnet50_fpn # 加载预训练模型 model = fasterrcnn_resnet50_fpn(pretrained=True) # 转换为eval模式 model.eval() # 加载图像并进行预处理 image = Image.open('test.jpg') transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) image = transform(image) image = image.unsqueeze(0) # 提取特征图 features = model.backbone(image) # 打印特征图的大小 print(features[0].shape) ``` 在这个例子中，我们使用了PyTorch内置的`fasterrcnn_resnet50_fpn`模型来进行特征图提取。我们也可以使用其他的预训练模型，如ResNet、VGG等。特征图提取的输入是经过预处理的图像，输出是一个特征图张量。我们可以通过打印特征图张量的大小来查看它的形状。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值