【pytorch】 目标检测:实现FPN特征金字塔网络 对照网络结构图手动编写

已于 2022-04-07 06:27:54 修改
阅读量1.2k 收藏 6
点赞数 1
分类专栏： 计算机视觉 pytorch python 文章标签： pytorch python 计算机视觉
于 2022-04-06 10:42:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hh1357102/article/details/123963547
版权
计算机视觉 同时被 3 个专栏收录
132 篇文章 10 订阅
订阅专栏
python
89 篇文章 11 订阅
订阅专栏
pytorch
65 篇文章 3 订阅
订阅专栏

特征金字塔网络能够同时输出四种不同尺度的特征图，供目标检测使用，能在一定程度上解决小尺寸目标的检测问题。
其主干卷积网络采用了ResNet网络。
在这里插入图片描述
注意，图中生成顺序是，P5,P4,P3,P2,先生成P5，再将上采样结果与C4卷积结果相加得到P4，再将P4上采样并与C3卷积结果相加。
使用Pytorch编写的代码如下：

import os.path
from typing import Iterator
import numpy as np
import torch
import cv2
from PIL import Image
from torch.utils.data import Dataset, DataLoader, Subset, random_split
import re
from functools import reduce
from torch.utils.tensorboard import SummaryWriter as Writer
from torchvision import transforms, datasets
import torchvision as tv
from torch import nn
import torch.nn.functional as F
import time

class Bottleneck(nn.Module):
    # 经过模块时，其通道的增加情况：默认增加4倍
    expansion = 4

    # 输入通道数，输出通道数（乘以4倍前），步长（一般resnet当步长为2时，尺寸减小，downsample为由外部传入的shortcut（如果有）
    def __init__(self, in_planes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.bottleneck = nn.Sequential(
            nn.Conv2d(in_planes, planes, 1, bias=False),
            nn.BatchNorm2d(planes),
            nn.ReLU(inplace=True),
            nn.Conv2d(planes, planes, 3, stride, 1, bias=False),
            nn.BatchNorm2d(planes),
            nn.ReLU(inplace=True),
            #最后一层进行ResNet的通道扩充工作
            nn.Conv2d(planes, self.expansion * planes, 1, bias=False),
            nn.BatchNorm2d(self.expansion * planes),
        )
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        out = self.bottleneck(x)
        # 如果旁支存在，则加和输出
        if self.downsample is not None:
            identity = self.downsample(x)
        out += identity
        out = self.relu(out)
        return out

class myCustomerFPNNet(nn.Module):
    # indim,outdim为输入及输出的通道数：
    def __init__(self):
        #初始输入通道数默认固定为64
        self.inplanes = 64
        super().__init__()
        #使用核大小(7),步长为(2），及padding为3，对初始输入图像进行处理;对nn.MaxPool 核大小为3，步长为，padding为1
        self.c1Layer =nn.Sequential(nn.Conv2d(3, 64, 7, 2, 3, bias=False),nn.BatchNorm2d(64),nn.ReLU(inplace=True),nn.MaxPool2d(3, 2, 1))
        #stage输出为64通道，内含3个resnet的Block模块
        self.c2Layer = self._make_layer(64, 3)
        # stage输出为64通道，内含4个resnet的Block模块，其步长为2
        self.c3Layer = self._make_layer(128, 4, 2)
        self.c4Layer= self._make_layer(256, 6, 2)
        self.c5Layer = self._make_layer(512, 3, 2)
        #特征图融合模块，不改变特征图尺寸，只是将上采样后的深度语义特征及浅层特征图做进一步融合
        self.smooth= nn.Conv2d(256, 256, 3, 1, 1)

    #进行网络搭建工作：
    def forward(self, x):
        c1=self.c1Layer(x)
        c2=self.c2Layer(c1)
        c2h=nn.Conv2d(256, 256, 1, 1, 0)(c2)
        c3 = self.c3Layer(c2)
        c3h=nn.Conv2d( 512, 256, 1, 1, 0)(c3)
        c4 = self.c4Layer(c3)
        c4h=nn.Conv2d( 1024, 256, 1, 1, 0)(c4)
        c5 = self.c5Layer(c4)
        p5=nn.Conv2d(2048, 256, 1, 1, 0)(c5)
        p4=self._upsample_add(p5,c4h)
        p3=self._upsample_add(p4,c3h)
        p2 =self._upsample_add(p3, c2h)
        return p2,p3,p4,p5
    #上采样：将x上采样至Y的尺寸，再两者相加
    def _upsample_add(self, x, y):
        _, _, H, W = y.shape
        return nn.Upsample(size=(H, W), mode='bilinear')(x) + y

    #该函数用于制作resnet的stage：planes为stage的输出通道数（未expansion前)
    #resnet的每一stage：为输入(带旁支)，一般，一般，输出（带
    def _make_layer(self, planes, blocks, stride=1):
        #初始默认没有旁支：
        downsample  = None
        #当reset模块的步长不为1或者stage的输入不等于stage的输出通道数时：需要有shortcut
        if stride != 1 or self.inplanes != Bottleneck.expansion * planes:
            downsample  = nn.Sequential(
                nn.Conv2d(self.inplanes, Bottleneck.expansion * planes, 1, stride, bias=False),
                nn.BatchNorm2d(Bottleneck.expansion * planes)
            )
        layers = []
        #加入第一个带downsample的模块：输入为inplanes，实际输出为planesx4
        layers.append(Bottleneck(self.inplanes, planes, stride, downsample))

        self.inplanes = planes * Bottleneck.expansion
        #第一个模块已产生，处理剩余blocks-2个模块
        for i in range(1, blocks):
            layers.append(Bottleneck(self.inplanes, planes))
        return nn.Sequential(*layers)
#进行实际测试：
myNet = myCustomerFPNNet()
print(myNet)
k = torch.rand(1, 3, 56, 56)
p2,p3,p4,p5=myNet(k)
#输出了不同尺度的特征图，其输出的特征图尺寸依次减半
print(p2.shape)
print(p3.shape)
print(p4.shape)
print(p5.shape)

输出的结果为：

myCustomerFPNNet(
  (c1Layer): Sequential(
    (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU(inplace=True)
    (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  )
  (c2Layer): Sequential(
    (0): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (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), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (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), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (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), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
  )
  (c3Layer): Sequential(
    (0): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=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): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
  )
  (c4Layer): Sequential(
    (0): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (4): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (5): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
  )
  (c5Layer): Sequential(
    (0): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (bottleneck): Sequential(
        (0): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
        (6): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (7): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
  )
  (smooth): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
torch.Size([1, 256, 14, 14])
torch.Size([1, 256, 7, 7])
torch.Size([1, 256, 4, 4])
torch.Size([1, 256, 2, 2])
颢师傅
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【论文解读】FPN 用于目标检测的特征金字塔网络
黎国溥
07-26 1474
FPN，全名是Feature Pyramid Networks，中文称为特征金字塔网络；它是目前用于目标检测、语义分割、行为识别等方面比较重要的一个部分，对于提高模型性能具有较好的表现。FPN的预测是在不同特征层独立进行的，即：同时利用低层特征高分辨率和高层特征的高语义信息，通过融合这些不同层的特征达到预测的效果。作者认为足够低层高分辨的特征对于检测小物体是很有帮助的。
Pytorch：目标检测网络-概述，指标计算和使用预训练网络
Jingmin Wei's Blog
02-17 1201
讲解了三大基本目标检测网络框架RCNN, SSD, YOLO。讲解了IoU计算，TP, FP, FN, TN四种样本，Precision, Recall指标，mAP计算。使用预训练的 Faster RCNN 完成目标检测与可视化结果。
Python-在特征金字塔网络FPN的Pytorch实现
08-11
在特征金字塔网络(FPN)的Pytorch实现
Backbone 之 FPN：特征金字塔 （Pytorch实现及代码解析）
热门推荐
weixin_45564943的博客
11-30 1万+
背景： 为了增强语义性，传统的物体检测模型通常只在深度卷积网络的最后一个特征图上进行后续操作，而这一层对应的下采样率（图像缩小的倍数）通常又比较大，如16、32，造成小物体在特征图上的有效信息较少，小物体的检测性能会急剧下降，这个问题也被称为多尺度问题。 ​ 解决多尺度问题的关键在于如何提取多尺度的特征。传统的方法有图像金字塔（Image Pyramid），主要思路是将输入图片做成多个尺度，不同尺度的图像生成不同尺度的特征，这种方法简单而有效，大量使用在了COCO等竞赛上，但缺点是非常耗...
推荐：PyTorch实现的金字塔特征注意力网络（PFAN）——精准的目标检测利器
gitblog_00072的博客
06-05 349
推荐：PyTorch实现的金字塔特征注意力网络（PFAN）——精准的目标检测利器 PyTorch-Pyramid-Feature-Attention-Network-for-Saliency-Detection项目地址:https://gitcode.com/gh_mirrors/py/PyTorch-Pyramid-Feature-Attention-Network-for-Saliency-...
特征金字塔：FPN网络 - Pytorch实现
02-28 3360
基础的FPN网络搭建测试
深度学习中小知识点系列(七) 解读Backbone之FPN与代码复现
weixin_44302770的博客
11-27 966
说的具体一些，Top-down过程的首先将 bottom-up最后一个阶段得到的特征图上采样到和bottom-up的第四阶段输出的特征图一样大的尺寸，然后在将通过横向连接（lateral connection）将他们进行 element-wise addition。输出相同的大小的特征图的卷积层作者称之为是一个阶段。​ 对于实际的物体检测算法，需要在特征图上进行**RoI（Region of Interests，感兴趣区域）**提取，而FPN有4个输出的特征图，选择哪一个特征图上面的特征也是个问题。
用于对象检测的特征金字塔网络（FPN）的Pytorch实现-Python开发
05-25
fpn.pytorch用于对象检测的功能金字塔网络（FPN）的Pytorch实现简介此项目继承了我们的r-cnn更快的pytorch实现的属性。 因此，它还具有以下特征专长fpn.pytorch：用于对象检测的功能金字塔网络（FPN）的Pytorch实现。简介该项目继承了我们的更快r-cnn的pytorch实现的属性。 因此，它还具有以下独特功能：它是纯Pytorch代码。 我们将所有的numpy实现都转换为pytorch。 它支持trainig batchsize>1。我们修改了所有层，包括数据加载器，rpn，roi-pooling等，以便在每次迭代时使用多个图像进行训练。 支持多个GP
Pytorch：目标检测网络-FPN
Jingmin Wei's Blog
02-17 1919
讲解了特征金字塔，使用Pytorch搭建了FPN
FPN(Feature Pyramid Networks)网络--特征图金字塔网络，适合小目标检测网络。
最新发布
weixin_43331421的博客
07-08 1264
特征图金字塔网络(Feature Pyramid Networks，FPN)，是一种在2017年提出的网络结构，主要解决的是物体检测中的多尺度问题。FPN通过简单的网络连接改变，实现了在不显著增加原有模型计算量的前提下，显著提升了小物体检测的性能。FPN的设计理念是利用不同层的特征图进行预测，这些特征图具有不同的尺度和语义信息。
FPN(特征金字塔)-pytorch实践
thehappysheep的博客
11-02 4096
1.FPN FPN来源于论文《Feature Pyramid Networks for Object Detection》 1.1要解决的问题 传统的物体检测模型通常只在深度卷积网络的最后一个特征图上进行后续操作，而这一层对应的下采样率（图像缩小的倍数）通常又比较大，如16、32，造成小物体在特征图上的有效信息较少，小物体的检测性能会急剧下降，这个问题也被称为多尺度问题。如图1所示，这样会导致小目标漏检检测，因为在下采样过程中小目标的像素较少，在下采样过程中会丢失。 图1 单一高层次特征 .
matlab代码金字塔-DeepPyramid:适用于各种计算机视觉算法（DPM，金字塔R-CNN等）的深层特征金字塔
05-20
Matlab代码金字塔深金字塔 DeepPyramid是用于从深度卷积网络构建要素金字塔的简单工具包。 DeepPyramid数据结构与代码中featpyramid.m函数创建的HOG特征金字塔几乎相同。 参考 我们在关于可变形零件模型和卷积网络之间的关系时使用了此代码。 @article{girshick14dpdpm, author = {Ross Girshick and Forrest Iandola and Trevor Darrell and Jitendra Malik}, title = {Deformable Part Models are Convolutional Neural Networks}, journal = {CoRR}, year = {2014}, volume = {abs/1409.5403}, url = {http://arxiv.org/abs/1409.5403}, year = {2014} } 安装 先决条件 MATLAB（已在2014位元上测试2014a在Linux上） 咖啡的 安装Caffe （这是最复杂的部分） 跟着 让我们将
python 图像金字塔代码
07-23
使用python实现的图像金字塔获取程序，包括高斯金字塔和拉普拉斯金字塔，用于检验CNN输出的残差
FPN网络结构及Pytorch实现
乐亦亦乐的博客
10-31 7867
FPN总体架构如图所示，主要包含自下而上网络、自上而下网络、横向连接与卷积融合4个部分。 自下而上：C2到C5代表不同的ResNet卷积组，这些卷积组包含了多个Bottleneck结构，组内的特征图大小相同，组间大小递减。 自下而上：首先对C5进行1x1卷积降低通道数得到P5，然后依次进行上采样得到P4、P3、P2.目的是得到与C4、C3与C2长宽相同的特征，方便下次进行逐元素相加。采用2倍最近邻上采样（直接对临近元素进行复制，而非线性插值）。 横向连接：（Lateral Connect...
人工智能(pytorch)搭建模型25-基于pytorch搭建FPN特征金字塔网络的应用场景，模型结构介绍
weixin_42878111的博客
03-28 1612
大家好，我是微学AI，今天给大家介绍一下人工智能(pytorch)搭建模型25-基于pytorch搭建FPN特征金字塔网络的应用场景，模型结构介绍。特征金字塔网络（FPN）是一种深度学习模型结构，主要应用于目标检测任务中，尤其是对于多尺度目标的检测问题。该网络通过构建自底向上的高分辨率特征图与自顶向下的语义信息丰富的特征图之间的连接，形成一个特征金字塔，从而在不同尺度上提取和利用物体特征。
FPN (特征金字塔) 的原理和代码
weixin_52668444的博客
12-02 9626
文章结构1. 为什么会使用金字塔式的representation以及它存在的问题。2. 原理和特点。3. 如何基于resnet实现（思路）。4. 小总结 1. 为什么会使用金字塔式的representation以及它存在的问题。 论文中提到一些传统的使用深度学习来做物体检测的结构会倾向于避开使用金字塔性质的representation, 因为使用这样的representation会对算力和内存带来很大的压力。但是金字塔形式的representation对物体检测有着非常大的作用。因为它可以将一张图像在多个不
比较清晰FPN的PyTorch实现
有问题请直接说问题就好
10-09 2840
比较清晰FPN的PyTorch实现
常见特征金字塔模块代码实现
qq_43471945的博客
10-08 1322
如何使用特征金字塔改进，常见的特征金字塔如何使用，代码实现
构造任意层数的金字塔（pytorch）
如人饮水、冷暖自知
12-01 1407
code import torch import torch.nn as nn import torch.nn.functional as F class ConvBnReLU(nn.Module): def __init__(self, in_channels, out_channels, kernel_size, stride, padding, bias=True, dilation=1): super(ConvBnReLU, self).__init__()
特征金字塔网络fpn代码
09-05
FPN是一种用于目标检测的网络结构，用于解决多尺度检测问题。它通过融合来自不同层的特征，提供了多个尺度的特征图，以便更好地检测不同大小的物体。 在FPN中，首先使用backbone网络（比如ResNet）生成一系列特征图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

颢师傅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值