neural-network - Resnet-18 作为 Faster R-CNN 的主干-6ren

neural-network - Resnet-18 作为 Faster R-CNN 的主干

转载作者：行者123 更新时间：2023-12-03 23:21:02

我用 pytorch 编码，我想使用 resnet-18 作为 Faster R-RCNN 的主干。当我打印 resnet18 的结构时，这是输出:

>>import torch
>>import torchvision
>>import numpy as np
>>import torchvision.models as models

>>resnet18 = models.resnet18(pretrained=False)
>>print(resnet18)


ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)

我的问题是，直到哪一层是特征提取器？ AdaptiveAvgPool2d 应该是 Faster R-CNN 的主干的一部分吗？

在 this toturial 中，展示了如何用任意主干训练 Mask R-CNN，我想用 Faster R-CNN 做同样的事情并用 resnet-18 训练一个 Faster R-CNN，但直到哪一层应该是特征提取器让我感到困惑。

我知道如何使用 resnet+Feature Pyramid Network 作为主干，我的问题是关于 resent。

最佳答案

如果我们想使用自适应平均池化的输出，我们对不同的 Resnet 使用此代码:

# backbone
        if backbone_name == 'resnet_18':
            resnet_net = torchvision.models.resnet18(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 512
        elif backbone_name == 'resnet_34':
            resnet_net = torchvision.models.resnet34(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 512
        elif backbone_name == 'resnet_50':
            resnet_net = torchvision.models.resnet50(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 2048
        elif backbone_name == 'resnet_101':
            resnet_net = torchvision.models.resnet101(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 2048
        elif backbone_name == 'resnet_152':
            resnet_net = torchvision.models.resnet152(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 2048
        elif backbone_name == 'resnet_50_modified_stride_1':
            resnet_net = resnet50(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 2048
        elif backbone_name == 'resnext101_32x8d':
            resnet_net = torchvision.models.resnext101_32x8d(pretrained=True)
            modules = list(resnet_net.children())[:-1]
            backbone = nn.Sequential(*modules)
            backbone.out_channels = 2048

如果我们想使用卷积特征图，我们使用以下代码:

 # backbone
        if backbone_name == 'resnet_18':
            resnet_net = torchvision.models.resnet18(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

        elif backbone_name == 'resnet_34':
            resnet_net = torchvision.models.resnet34(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

        elif backbone_name == 'resnet_50':
            resnet_net = torchvision.models.resnet50(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

        elif backbone_name == 'resnet_101':
            resnet_net = torchvision.models.resnet101(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

        elif backbone_name == 'resnet_152':
            resnet_net = torchvision.models.resnet152(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

        elif backbone_name == 'resnet_50_modified_stride_1':
            resnet_net = resnet50(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

        elif backbone_name == 'resnext101_32x8d':
            resnet_net = torchvision.models.resnext101_32x8d(pretrained=True)
            modules = list(resnet_net.children())[:-2]
            backbone = nn.Sequential(*modules)

关于neural-network - Resnet-18 作为 Faster R-CNN 的主干，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/58362892/

文章推荐： asp.net-mvc - 如何在 Rider 中启用 View 热重载？

文章推荐： scheme - 如何在 Racket 中安装 sicp 包模块？

deep-learning - 在 R-CNN、fast R-CNN、faster R-CNN 和 YOLO 中哪个最适合对象定位
R-CNN、fast R-CNN、faster R-CNN 和 YOLO 在以下方面有什么区别: (1) 同一图像集上的精度 (2) 给定 SAME IMAGE SIZE，运行时间 (3) 支持安卓移
python - CNN 模型比 CNN-SVM 组合模型具有更好的精度
我试图比较 CNN 模型和组合 CNN-SVM 模型进行分类的准确性结果。然而我发现 CNN 模型比 CNN-SVM 组合模型具有更好的准确性。这是正确的还是可能发生？最佳答案这取决于很多因素，但
machine-learning - 深度 CNN 和密集 CNN 的区别
我知道这可能是一个愚蠢的问题，但我对机器学习和人工神经网络有点陌生。深度卷积神经网络和密集卷积神经网络有什么区别吗？提前致谢! 最佳答案密集 CNN 是深度 CNN 的一种，其中每一层都与比自身
machine-learning - 使用预训练 CNN 提取的特征作为 CNN/NN 的新特征
我正在使用预训练的 CNN 从图片中提取特征。使用这些特征作为新 CNN/NN 的输入有意义吗？以前做过吗？我很高兴得到答复。最佳答案这称为微调。这是非常常用的。通常，我们会删除 VGG 或类似网
neural-network - 尝试使用 Region CNN (R-CNN) 训练 ImageNet 模型
与 caffe 合作几个月后，我已经能够成功地训练我自己的模型。例如，比我自己的模型更进一步，我已经能够用 1000 个类来训练 ImageNet。现在在我的项目中，我试图提取我感兴趣的区域。之后我
python - CNN 中的模型精度和损失没有改善
我正在使用下面的 LeNet 架构来训练我的图像分类模型，我注意到每次迭代都不会提高训练和验证的准确性。这方面的任何专家都可以解释可能出了什么问题吗？训练样本 - 属于 2 个类别的 110 张图像
python - 将剩余连接添加到简单的 CNN
我使用剩余连接实现了以下 CNN，用于在 CIFAR10 上对 10 个类进行分类: class ConvolutionalNetwork(nn.Module): def __init__(se
tensorflow - 具有自定义损失函数的多输入多输出 CNN
我有一组二维输入数组 m x n即 A,B,C我必须预测两个二维输出数组，即 d,e我确实有预期值。如果您愿意，您可以将输入/输出视为灰色图像。由于空间信息是相关的(这些实际上是 2D 物理域)我想
python - 为什么python线程会减慢推理时间以实现更快的R-CNN
我正在开发一个交通跟踪系统，该系统可以分析已经收集的视频。我正在使用opencv，线程，pytorch和dectron2。为了加快从opencv抓帧的速度，我决定使用Thread，该线程运行一个循环，
python - CNN 自动编码器可以有不同的输入和输出维度吗？
我正在解决一个问题，需要我构建一个深度学习模型，该模型必须基于某些输入图像输出另一个图像。值得注意的是，这两个图像在概念上是相关的，但它们没有相同的尺寸。起初我认为具有最终密集层(其参数是输出图像的
python - CNN - 多类分类的错误预测
我正在制作一个卷积网络来预测 3 类图像:猫、狗和人。我训练了又训练它，但是当我传递猫图像来预测时，它总是给出错误的输出。我尝试了其他猫的照片，但结果没有改变。对于人和狗来说没有问题，只是对于猫来说。
python - 如何在不损失准确性的情况下使用不同的 CNN
我接到一项任务，要实现一个卷积神经网络，该网络可以评估 MNIST dataset 中找到的手写数字。网络架构如下所示: 我已经实现了一个与架构相匹配的 CNN，不幸的是它的准确率只有 10% 左右。
python - CNN 对所有输入数据预测相同的类别
我正在尝试在 Keras 中重新创建 CNN 来对点云数据进行分类。 CNN 在 this 中描述。纸。网络设计这是我当前的实现: inputs = Input(shape=(None, 3))
tensorflow - CNN 的模型架构设计
我想为有 300 个类的数据集设计 CNN。我已经用以下模型对两个类(class)进行了测试。它具有良好的准确性。 model = Sequential([ Conv2D(16, 3, padding
python - CNN 模型无法做出预测
我成功训练了 CNN 模型，但是当我向模型提供图像以使其预测标签时，出现错误。这是我的模型(我正在使用 saver.restore 恢复它)... # load dataset mnist = in
python - CNN 批处理不同大小的图像
我恢复了用于人脸检测的预训练模型，该模型一次获取单个图像并返回边界框。如果这些图像具有不同的尺寸，如何才能获取一批图像？最佳答案您可以使用tf.image.resize_images方法来实现这一
python - CNN 的验证准确率没有提高
我有大约 8200 张图像用于人脸检测任务。其中 4800 个包含人脸。其他 3400 张图像包含 3D 人脸面具(由橡胶/ latex 制成)、卡通人脸、猴子脸的图像。我想检测给定的图像是否包含真实
使用 CNN 去噪图像中的图像尺寸
我有一组合成噪声图像。示例如下: 我还有它们相应的干净文本图像作为我的地面实况数据。下面的例子: 两个图像的尺寸为4918 x 5856。它的大小是否适合训练我的执行图像去噪的卷积神经网络？如果没有，
python - 具有动态输入形状的 CNN
大家好! 由于我正在尝试制作一个将灰度图像转换为 RGB 图像的全卷积神经网络，所以我想知道是否可以在不同大小的图像(不同的像素和比率)上训练和测试模型。通常你只会下采样或上采样，这是我不想做的。我听
matlab - CNN 特征的后期融合
我正在研究 CNN 特征的早期和晚期融合。我从 CNN 的多层中获取了特征。对于早期融合，我捕获了三个不同层的特征，然后水平连接它们 F= [F1' F2' F3']; 对于后期融合，我正在阅读此 p

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

neural-network - Resnet-18 作为 Faster R-CNN 的主干