YOLOv5算法改进（15）— 更换Neck之AFPN

前言：Hello大家好，我是小哥谈。在YOLOv5中添加AFPN（Adaptive Feature Pyramid Network）可以提高目标检测的准确性。AFPN是一种用于目标检测任务的功能增强模块，它能够自适应地融合来自不同层级的特征图，以提供更好的目标定位和尺度适应能力。  

前期回顾：

          YOLOv5算法改进（1）— 如何去改进YOLOv5算法

          YOLOv5算法改进（2）— 添加SE注意力机制

          YOLOv5算法改进（3）— 添加CBAM注意力机制

          YOLOv5算法改进（4）— 添加CA注意力机制

          YOLOv5算法改进（5）— 添加ECA注意力机制

          YOLOv5算法改进（6）— 添加SOCA注意力机制

          YOLOv5算法改进（7）— 添加SimAM注意力机制

          YOLOv5算法改进（8）— 替换主干网络之MobileNetV3

          YOLOv5算法改进（9）— 替换主干网络之ShuffleNetV2

          YOLOv5算法改进（10）— 替换主干网络之GhostNet

          YOLOv5算法改进（11）— 替换主干网络之EfficientNetv2

          YOLOv5算法改进（12）— 替换主干网络之Swin Transformer

          YOLOv5算法改进（13）— 替换主干网络之PP-LCNet

          YOLOv5算法改进（14）— 更换Neck之BiFPN

          目录

1.论文

2.AFPN网络架构及添加步骤

3.更换AFPN的方法

步骤1：在common.py中添加AFPN模块

步骤2：修改yolo.py文件

步骤3：创建自定义的yaml文件

步骤4：验证是否加入成功

1.论文

多尺度特征提取的一种常见策略是采用经典的自上而下和自下而上的特征金字塔网络。然而，这些方法遭受特征信息的丢失或退化，削弱了非相邻 Level 的融合效果。本文提出了一种渐近特征金字塔网络（AFPN）来支持非相邻层的直接交互。AFPN是通过融合两个相邻的Low-Level特征来启动的，并渐进地将High-Level特征纳入融合过程。通过这种方式，可以避免非相邻 Level 之间的较大语义差距。考虑到在每个空间位置的特征融合过程中可能出现多目标信息冲突，进一步利用自适应空间融合操作来缓解这些不一致。

本文将所提出的AFPN纳入两阶段和一阶段目标检测框架，并使用MS-COCO 2017验证和测试数据集进行评估。实验评估表明，与其他最先进的特征金字塔网络相比，论文作者的方法获得了更具竞争力的结果。

论文主要贡献：♨️♨️♨️

1.作者引入了一种渐进特征金字塔网络（AFPN），它有助于跨非相邻 Level 的直接特征融合，从而防止特征信息在传输和交互过程中的丢失或退化。

2.为了抑制不同层次特征之间的信息矛盾，作者在多层次特征融合过程中引入了自适应空间融合操作。

3.在MS COCO 2017验证和测试数据集上的大量实验表明，与其他特征金字塔网络相比，作者的方法表现出优越的计算效率，同时获得了更具竞争力的结果。

论文题目：《AFPN: Asymptotic Feature Pyramid Network for Object Detection》

论文地址：  https://arxiv.org/abs/2306.15988v1

代码实现：  GitHub - gyyang23/AFPN

---

2.AFPN网络架构及添加步骤

论文所提出的AFPN架构如下图所示。在Backbone网络自下而上的特征提取过程中，AFPN渐进地集成了Low-Level、High-Level和顶级特征。具体来说，AFPN最初融合了Low-Level特征，然后融合了深层特征，最后融合了最High-Level的特征，即最抽象的特征。非相邻层次特征之间的语义差距大于相邻层次特征间的语义差距，尤其是底部和顶部特征，这直接导致了非相邻层次特征的融合效果较差。由于AFPN的架构是渐进的，这将使不同 Level 特征的语义信息在渐进融合过程中更加接近，从而缓解上述问题。

为了对齐维度并为特征融合做准备，作者使用1×1卷积和双线性插值方法对特征进行上采样。另一方面，作者根据所需的下采样率使用不同的卷积核和Stride来执行下采样。例如，作者应用Stride为2的2×2卷积来实现2次下采样，应用Stride为4的4×4卷积来实现4次下采样以及应用Stride为8的8×8卷积来实现8倍下采样。在特征融合之后，作者使用4个残差单元继续学习特征，这些残差单元类似于ResNet。每个残差单元包括2个3×3卷积。由于YOLO中只使用了3个 Level 的特征，因此没有8次上采样和8次下采样。

在YOLOv5中添加AFPN（Adaptive Feature Pyramid Network）可以提高目标检测的准确性。AFPN是一种用于目标检测任务的功能增强模块，它能够自适应地融合来自不同层级的特征图，以提供更好的目标定位和尺度适应能力。✅

要在YOLOv5中添加AFPN，可以按照以下步骤进行操作：

（1）首先，在YOLOv5的模型架构中引入AFPN模块。为此，您可以修改模型的backbone部分。通常，YOLOv5使用CSPDarknet53作为backbone，您可以在该部分添加AFPN。

（2）在引入AFPN之后，您需要确定要从backbone中选择哪些特征图进行融合。一般来说，可以选择较高层级和较低层级的特征图进行融合，以获得更好的目标定位和尺度适应。

（3）接下来，您需要实现AFPN模块的具体结构。AFPN通常由上采样和特征图融合两部分组成。上采样部分可以使用双线性插值或者转置卷积等方法进行实现。特征图融合部分可以使用逐元素相加或者卷积等方法进行实现。

（4）最后，在YOLOv5的检测头部之前，将AFPN模块的输出与backbone的输出进行融合。这样可以将更多信息引入到检测头部，提升目标检测的准确性。

说明：♨️♨️♨️

请注意，在实现AFPN时，您需要根据YOLOv5的具体版本和代码结构进行适当的修改。这里提供的步骤仅供参考，具体实现可能因版本而异。建议您查阅相关文档和代码，以了解如何在YOLOv5中添加AFPN的详细实现方法。另外，需要注意的是，添加AFPN可能会增加模型的计算和内存开销，因此在使用时需要根据实际情况进行权衡和优化。

---

3.更换AFPN的方法

步骤1：在common.py中添加AFPN模块

 
class Upsample(nn.Module):
    """Applies convolution followed by upsampling."""
# ---1.渐进架构部分（融合前的准备）--- #
    def __init__(self, c1, c2, scale_factor=2):
        super().__init__()
        # self.cv1 = Conv(c1, c2, 1)
        # self.upsample = nn.Upsample(scale_factor=scale_factor, mode='nearest')  # or model='bilinear' non-deterministic
        if scale_factor == 2:
            self.cv1 = nn.ConvTranspose2d(c1, c2, 2, 2, 0, bias=True)  # 如果下采样率为2，就用Stride为2的2×2卷积来实现2次下采样
        elif scale_factor == 4:
            self.cv1 = nn.ConvTranspose2d(c1, c2, 4, 4, 0, bias=True)  # 如果下采样率为4，就用Stride为4的4×4卷积来实现4次下采样
 
    def forward(self, x):
        # return self.upsample(self.cv1(x))
        return self.cv1(x)
 
# ---2.自适应空间融合（ASFF）--- #
class ASFF2(nn.Module):
    """ASFF2 module for YOLO AFPN head https://arxiv.org/abs/2306.15988"""
 
    def __init__(self, c1, c2, level=0):
        super().__init__()
        c1_l, c1_h = c1[0], c1[1]
        self.level = level
        self.dim = c1_l, c1_h
        self.inter_dim = self.dim[self.level]
        compress_c = 8
       
#如果是第0层
        if level == 0:
# self.stride_level_1调整level-1出来的特征图，通道调整为和level-0出来的特征图一样大小
            self.stride_level_1 = Upsample(c1_h, self.inter_dim)
#如果是第1层
        if level == 1:
# self.stride_level_0通道调整为和level-1出来的特征图一样大小
            self.stride_level_0 = Conv(c1_l, self.inter_dim, 2, 2, 0)  # stride=2 下采样为2倍
 
 
# 两个卷积为了学习权重
        self.weight_level_0 = Conv(self.inter_dim, compress_c, 1, 1)
        self.weight_level_1 = Conv(self.inter_dim, compress_c, 1, 1)
# 用于调整拼接后的两个权重的通道
        self.weights_levels = nn.Conv2d(compress_c * 2, 2, kernel_size=1, stride=1, padding=0)
        self.conv = Conv(self.inter_dim, self.inter_dim, 3, 1)
 
    def forward(self, x):
        x_level_0, x_level_1 = x[0], x[1]
 
# 如果在第0层
# level-0出来的特征图保持不变
# 调整level-1的特征图，使得其channel、width、height与level-0一致
        if self.level == 0:
            level_0_resized = x_level_0
            level_1_resized = self.stride_level_1(x_level_1)
# 如果在第1层，同上
        elif self.level == 1:
            level_0_resized = self.stride_level_0(x_level_0)
            level_1_resized = x_level_1
 
# 将N*C*H*W的level-0特征图卷积得到权重，权重level_0_weight_v:N*256*H*W
        level_0_weight_v = self.weight_level_0(level_0_resized)
        level_1_weight_v = self.weight_level_1(level_1_resized)
 
# 将各个权重矩阵按照通道拼接
# levels_weight_v：N*3C*H*W
        levels_weight_v = torch.cat((level_0_weight_v, level_1_weight_v), 1)
 
# 将拼接后的矩阵调整，每个通道对应着不同的level_0_resized，level_1_resized的权重
        levels_weight = self.weights_levels(levels_weight_v)
 
# 在通道维度，对权重做归一化，也就是对于二通道tmp：tmp[0][0]+tmp[1][0]=1
        levels_weight = F.softmax(levels_weight, dim=1)
 
# 将levels_weight各个通道分别乘level_0_resized level_1_resized 
# 点乘用到了广播机制
        fused_out_reduced = level_0_resized * levels_weight[:, 0:1] + level_1_resized * levels_weight[:, 1:2]
        return self.conv(fused_out_reduced)
 
# ASFF3的运算流程同上
class ASFF3(nn.Module):
    """ASFF3 module for YOLO AFPN head https://arxiv.org/abs/2306.15988"""
 
    def __init__(self, c1, c2, level=0):
        super().__init__()
        c1_l, c1_m, c1_h = c1[0], c1[1], c1[2]
        self.level = level
        self.dim = c1_l, c1_m, c1_h
        self.inter_dim = self.dim[self.level]
        compress_c = 8
 
        if level == 0:
            self.stride_level_1 = Upsample(c1_m, self.inter_dim)
            self.stride_level_2 = Upsample(c1_h, self.inter_dim, scale_factor=4)
 
        if level == 1:
            self.stride_level_0 = Conv(c1_l, self.inter_dim, 2, 2, 0)  # downsample 2x
            self.stride_level_2 = Upsample(c1_h, self.inter_dim)
 
        if level == 2:
            self.stride_level_0 = Conv(c1_l, self.inter_dim, 4, 4, 0)  # downsample 4x
            self.stride_level_1 = Conv(c1_m, self.inter_dim, 2, 2, 0)  # downsample 2x
 
        self.weight_level_0 = Conv(self.inter_dim, compress_c, 1, 1)
        self.weight_level_1 = Conv(self.inter_dim, compress_c, 1, 1)
        self.weight_level_2 = Conv(self.inter_dim, compress_c, 1, 1)
 
        self.weights_levels = nn.Conv2d(compress_c * 3, 3, kernel_size=1, stride=1, padding=0)
        self.conv = Conv(self.inter_dim, self.inter_dim, 3, 1)
 
    def forward(self, x):
        x_level_0, x_level_1, x_level_2 = x[0], x[1], x[2]
 
        if self.level == 0:
            level_0_resized = x_level_0
            level_1_resized = self.stride_level_1(x_level_1)
            level_2_resized = self.stride_level_2(x_level_2)
 
        elif self.level == 1:
            level_0_resized = self.stride_level_0(x_level_0)
            level_1_resized = x_level_1
            level_2_resized = self.stride_level_2(x_level_2)
 
        elif self.level == 2:
            level_0_resized = self.stride_level_0(x_level_0)
            level_1_resized = self.stride_level_1(x_level_1)
            level_2_resized = x_level_2
 
        level_0_weight_v = self.weight_level_0(level_0_resized)
        level_1_weight_v = self.weight_level_1(level_1_resized)
        level_2_weight_v = self.weight_level_2(level_2_resized)
 
        levels_weight_v = torch.cat((level_0_weight_v, level_1_weight_v, level_2_weight_v), 1)
        w = self.weights_levels(levels_weight_v)
        w = F.softmax(w, dim=1)
 
        fused_out_reduced = level_0_resized * w[:, :1] + level_1_resized * w[:, 1:2] + level_2_resized * w[:, 2:]
        return self.conv(fused_out_reduced)
 

具体如下图所示：

步骤2：修改yolo.py文件

修改yolo.py文件，在 parse_model函数中找到 elif m is Concat: 语句，在其后面加上下列代码：

        elif m is ASFF2:
            c1, c2 = [ch[f[0]], ch[f[1]]], args[0]
            c2 = make_divisible(c2 * gw, 8)
            args = [c1, c2, *args[1:]]
        elif m is ASFF3:
            c1, c2 = [ch[f[0]], ch[f[1]], ch[f[2]]], args[0]
            c2 = make_divisible(c2 * gw, 8)
            args = [c1, c2, *args[1:]]

具体如下图所示：

步骤3：创建自定义的yaml文件

在models文件夹中复制yolov5s.yaml，粘贴并重命名为yolov5s_AFPN.yaml。

yaml文件完整代码如下：

# YOLOv5  by Ultralytics, GPL-3.0 license
 
# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32
 
# YOLOv5 v6.1 backbone
backbone:
  # [from, repeats, module, args]
  [[-1, 1, Conv, [64, 3, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]], # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 6, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],
  ]  # 9
 
# YOLOv5 v6.1 head
head:
  [[4, 1, Conv, [128, 1, 1]], # 10 downsample backbone P3
   [6, 1, Conv, [256, 1, 1]], # 11 downsample backbone P4
 
   [[10, 11], 1, ASFF2, [128, 0]], # 12
   [[10, 11], 1, ASFF2, [256, 1]], # 13
 
   [-2, 1, C3, [128, False]], # 14
   [-2, 1, C3, [256, False]], # 15
 
   [9, 1, Conv, [512, 1, 1]], # 16 downsample backbone P5
 
   [[14, 15, 16], 1, ASFF3, [128, 0]], # 17
   [[14, 15, 16], 1, ASFF3, [256, 1]], # 18
   [[14, 15, 16], 1, ASFF3, [512, 2]], # 19
 
   [17, 1, C3, [256, False]],  # 20 (P3/8-small)
   [18, 1, C3, [512, False]],  # 21 (P4/16-medium)
   [19, 1, C3, [1024, False]],  # 22 (P5/32-large)
  [[20, 21, 22], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]
 

步骤4：验证是否加入成功

在yolo.py文件里，配置我们刚才自定义的yolov5s_AFPN.yaml。

然后运行yolo.py。我运行时出现报错信息。 ❌

报错信息如图所示：

解决方法：

需要导入包

import torch.nn.functional as F

导入后，则报错消失。然后继续运行yolo.py，得到运行结果。✅

这样就算添加成功了。  

我没有试验过这种方法效果如何，有实验过的小伙伴可以把效果在评论区打出来！我们共同讨论下！  

---