YOLO11改进 | Neck | 添加双向特征金字塔BiFPN【含二次独家创新】

kay_545

已于 2024-10-01 07:24:00 修改

阅读量1k

点赞数 29

分类专栏： YOLO11入门 + 改进有效涨点文章标签： YOLO 目标检测深度学习人工智能 python yolo11改进面试

于 2024-09-30 20:46:06 首次发布

本文链接：https://blog.csdn.net/m0_67647321/article/details/142654038

版权

YOLO11入门 + 改进有效涨点专栏收录该内容

8 篇文章 2 订阅

订阅专栏

💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

针对在特征提取过程中，特征信息丢失，特征提取能力不足等问题，本文介绍了一种加权双向特征金字塔网络（BiFPN），它允许简单快速的多尺度特征融合；可以同时统一缩放所有主干网络、特征网络以及边界框/类别预测网络的分辨率、深度和宽度。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址：YOLO11入门 + 改进涨点——点击即可跳转欢迎订阅

1. 原理

2.BiFPN代码实现

2.1 将BiFPN代码添加到YOLO11中

1. 原理

论文地址：EfficientDet: Scalable and Efficient Object Detection——点击即可跳转

官方代码：BiFPN官方代码仓库——点击即可跳转

BIFPN，全称为双向特征金字塔网络（Bidirectional Feature Pyramid Network），是一种用于目标检测和图像分割的神经网络架构。它在EfficientDet和其他一些计算机视觉任务中被广泛使用。BIFPN的设计目标是提高特征融合的效率和效果，使得模型在计算资源有限的情况下仍能保持高性能。以下是对BIFPN的详细讲解：

背景

在计算机视觉任务中，特征金字塔网络（FPN）是一种常用的方法，它通过构建不同尺度的特征图来捕获不同尺度的目标。然而，传统的FPN存在一些缺点，如特征融合效率低、信息流通不充分等。BIFPN则通过引入双向的特征融合机制和加权的特征融合方法来克服这些问题。

核心思想

双向特征融合：传统的FPN是单向的，即从高层特征图向低层特征图传递信息。而BIFPN在此基础上增加了反向的信息传递，即从低层特征图向高层特征图传递信息。这种双向的信息流动使得特征图之间的信息融合更加充分。
加权特征融合：在BIFPN中，不同尺度的特征图在融合时会分配不同的权重。这些权重是可学习的参数，模型在训练过程中会自动调整它们，以最优地融合不同尺度的特征。这样一来，模型能够更好地利用每个特征图的信息，提高整体的特征表示能力。

结构细节

BIFPN的结构设计非常灵活，可以适应不同的网络架构和任务需求。以下是BIFPN的几个关键组件：

上下文融合层：在上下文融合层中，BIFPN将来自不同尺度的特征图进行融合，采用加权求和的方式。这种加权求和通过学习到的权重来平衡不同特征图的贡献。
重复融合模块：BIFPN中通常会堆叠多个融合模块，这些模块会反复进行特征融合，从而进一步增强特征的表达能力。
尺度变化处理：BIFPN能够处理不同尺度的特征图，并在融合过程中考虑到这些尺度变化。通过上下采样等操作，BIFPN可以有效地处理不同分辨率的特征图。

优势

高效性：通过加权特征融合和重复融合模块，BIFPN能够在保持高效计算的同时，提升特征表示能力。
鲁棒性：双向特征融合使得BIFPN对不同尺度目标的检测更加鲁棒，能够更好地应对多尺度问题。
灵活性：BIFPN可以方便地集成到不同的神经网络架构中，适应不同的任务需求。

应用

BIFPN被广泛应用于各种计算机视觉任务中，尤其是在目标检测和图像分割方面表现出色。比如，在EfficientDet中，BIFPN作为核心组件之一，通过高效的特征融合机制显著提升了模型的检测性能。

总结

BIFPN通过引入双向特征融合和加权特征融合，克服了传统FPN的局限性，提高了特征融合的效率和效果。其灵活高效的设计使其在计算机视觉任务中得到广泛应用，为提升模型性能提供了有力支持。

2.BiFPN代码实现

2.1 将BiFPN代码添加到YOLO11中

关键步骤一: 将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加“Concat_BiFPN”

class Concat_BiFPN(nn.Module):
    def __init__(self, dimension=1):
        super(Concat_BiFPN, self).__init__()
        self.d = dimension
        self.w = nn.Parameter(torch.ones(3, dtype=torch.float32), requires_grad=True)
        self.epsilon = 0.0001
 
    def forward(self, x):
        w = self.w
        weight = w / (torch.sum(w, dim=0) + self.epsilon)  # 将权重进行归一化
        # Fast normalized fusion
        x = [weight[0] * x[0], weight[1] * x[1]]
        return torch.cat(x, self.d)

BiFPN的主要流程可以分为以下几个步骤：

特征提取：首先，输入图像经过卷积神经网络（如EfficientNet等）进行特征提取，得到一系列特征图，这些特征图包含了不同层级的语义信息。
自下而上特征传递：BiFPN从底层开始，利用双线性池化将低分辨率特征图上采样到高分辨率，然后使用双向连接，将上一层的特征图与下一层的上采样特征图进行融合。这种自下而上的特征传递可以帮助从更低层级获取更丰富的信息。
自上而下特征传递：接着，BiFPN沿着特征金字塔网络的自上而下路径进行特征传递。在这个过程中，BiFPN利用双向连接，将上一层的特征图与下一层的上采样特征图进行融合，以获得更加丰富和准确的特征表征。
多尺度特征融合：BiFPN在每个层级上都进行多尺度特征融合，将不同分辨率的特征图通过双线性池化进行融合，从而提高特征的表征能力和鲁棒性。
最终特征输出：最后，BiFPN输出的特征图经过一系列后续处理，如分类器和回归器等，用于目标检测任务中的目标分类和边界框回归等。

通过这样的流程，BiFPN能够充分利用不同层级的特征信息，并通过双向连接和双线性池化等技巧，提高了特征的表征能力和目标检测的性能。

代码解析

Concat_BiFPN 是一个实现特征融合的自定义模块，使用了可学习的权重来进行双向特征金字塔网络（BiFPN）的融合。让我们逐步解析该代码：

1. 类的定义

该类继承自 nn.Module，表明它是一个自定义的 PyTorch 神经网络模块。

2. 构造函数 (__init__)

self.d = dimension: dimension 参数指定在连接特征图时的维度（默认为1，即在通道维度上进行拼接）。
self.w = nn.Parameter(torch.ones(3, dtype=torch.float32), requires_grad=True):
- 这里 self.w 是一个大小为3的可学习权重向量，初始值为全1，requires_grad=True 表示该权重在训练过程中会更新。
- 该权重用于对输入特征图进行加权融合。
self.epsilon = 0.0001: 这是一个小常数，防止在归一化过程中出现除零错误。

3. 前向传播 (forward)

w = self.w: 取出可学习的权重向量 self.w。
weight = w / (torch.sum(w, dim=0) + self.epsilon):
- 这一步对权重 w 进行归一化处理，使得它们的总和为1。这样可以保证特征图按比例进行融合。
- 加上 epsilon 是为了避免除零问题。
x = [weight[0] * x[0], weight[1] * x[1]]:
- 这里 x 是输入的特征图列表。这个列表的元素分别与归一化后的权重进行加权相乘。
- 只对 x[0] 和 x[1] 两个特征图进行加权。代码中 self.w 的长度为3，但目前只使用了前两个权重，因此可能是后续操作中需要使用更多的特征图。
torch.cat(x, self.d): 将加权后的特征图在 self.d 指定的维度上进行拼接（concatenation），输出最终的融合特征图。

4. 总结

Concat_BiFPN 是一个特征融合模块，它通过加权平均的方式将输入的特征图进行融合。
通过可学习的权重 self.w，模型可以自动调整每个特征图在融合过程中的权重比例。最终结果是通过 torch.cat 在指定维度上拼接特征图。

这个模块的作用类似于 BiFPN 中的加权特征融合，但在这里进行了归一化以确保稳定性，并拼接不同特征图用于后续的网络层操作。

2.2 更改init.py文件

关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数

然后在下面的__all__中声明函数

2.3 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/11下面新建文件yolo11_BiFPN.yaml文件，粘贴下面的内容

目标检测

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n 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, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat_BiFPN, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat_BiFPN, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat_BiFPN, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

旋转目标检测

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n 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, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat_BiFPN, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat_BiFPN, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat_BiFPN, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, OBB, [nc, 1]] # Detect(P3, P4, P5)

温馨提示：因为本文只是对yolov11基础上添加模块，如果要对yolo11n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。不明白的同学可以看这篇文章： yolov8yaml文件解读——点击即可跳转

# YOLO11n
depth_multiple: 0.50  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channel：1024
 
# YOLO11s
depth_multiple: 0.50  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channel：1024

# YOLO11m
depth_multiple: 0.50  # model depth multiple
width_multiple: 1.00  # layer channel multiple
max_channel：512
 
# YOLO11l 
depth_multiple: 1.00  # model depth multiple
width_multiple: 1.00  # layer channel multiple
max_channel：512 
 
# YOLO11x
depth_multiple: 1.00  # model depth multiple
width_multiple: 1.50 # layer channel multiple
max_channel：512

2.4 在task.py中进行注册

关键步骤四：在task.py的parse_model函数中进行注册

elif m is Concat_BiFPN:
            c2 = sum(ch[x] for x in f)

2.5 执行程序

关键步骤五：在ultralytics文件中新建train.py，将model的参数路径设置为yolo11_BiFPN.yaml的路径即可

from ultralytics import YOLO
import warnings
warnings.filterwarnings('ignore')
from pathlib import Path
 
if __name__ == '__main__':
 
 
    # 加载模型
    model = YOLO("ultralytics/cfg/11/yolo11.yaml")  # 你要选择的模型yaml文件地址
    # Use the model
    results = model.train(data=r"你的数据集的yaml文件地址",
                          epochs=100, batch=16, imgsz=640, workers=4, name=Path(model.cfg).stem)  # 训练模型

建议大家写绝对路径，确保一定能找到

🚀运行程序，如果出现下面的内容则说明添加成功🚀

                   from  n    params  module                                       arguments
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]
  2                  -1  1      6640  ultralytics.nn.modules.block.C3k2            [32, 64, 1, False, 0.25]
  3                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
  4                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]
  5                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
  6                  -1  1     87040  ultralytics.nn.modules.block.C3k2            [128, 128, 1, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]
 10                  -1  1    249728  ultralytics.nn.modules.block.C2PSA           [256, 256, 1]
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 12             [-1, 6]  1         3  ultralytics.nn.modules.block.Concat_BiFPN    [1]
 13                  -1  1    111296  ultralytics.nn.modules.block.C3k2            [384, 128, 1, False]
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 15             [-1, 4]  1         3  ultralytics.nn.modules.block.Concat_BiFPN    [1]
 16                  -1  1     32096  ultralytics.nn.modules.block.C3k2            [256, 64, 1, False]
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
 18            [-1, 13]  1         3  ultralytics.nn.modules.block.Concat_BiFPN    [1]
 19                  -1  1     86720  ultralytics.nn.modules.block.C3k2            [192, 128, 1, False]
 20                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 22                  -1  1    378880  ultralytics.nn.modules.block.C3k2            [384, 256, 1, True]
 23        [16, 19, 22]  1    464912  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLO11_BiFPN_1 summary: 319 layers, 2,624,089 parameters, 2,624,073 gradients, 6.6 GFLOPs

3.修改后的网络结构图

4. 完整代码分享

https://pan.baidu.com/s/1OzbnIu1OcNPCOEN6eCuLBA?pwd=9i9j

提取码: 9i9j

5. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的YOLO11n GFLOPs

改进后的GFLOPs

6. 进阶

只需要更换关键步骤一的code和ymal文件，其他的步骤相同

# 结合BiFPN 设置可学习参数 学习不同分支的权重
# 两个分支concat操作
class BiFPN_Concat2(nn.Module):
    def __init__(self, dimension=1):
        super(BiFPN_Concat2, self).__init__()
        self.d = dimension
        self.w = nn.Parameter(torch.ones(2, dtype=torch.float32), requires_grad=True)
        self.epsilon = 0.0001
 
    def forward(self, x):
        w = self.w
        weight = w / (torch.sum(w, dim=0) + self.epsilon)  # 将权重进行归一化
        # Fast normalized fusion
        x = [weight[0] * x[0], weight[1] * x[1]]
        return torch.cat(x, self.d)
 
 
# 三个分支concat操作
class BiFPN_Concat3(nn.Module):
    def __init__(self, dimension=1):
        super(BiFPN_Concat3, self).__init__()
        self.d = dimension
        # 设置可学习参数 nn.Parameter的作用是：将一个不可训练的类型Tensor转换成可以训练的类型parameter
        # 并且会向宿主模型注册该参数 成为其一部分 即model.parameters()会包含这个parameter
        # 从而在参数优化的时候可以自动一起优化
        self.w = nn.Parameter(torch.ones(3, dtype=torch.float32), requires_grad=True)
        self.epsilon = 0.0001
 
    def forward(self, x):
        w = self.w
        weight = w / (torch.sum(w, dim=0) + self.epsilon)  # 将权重进行归一化
        # Fast normalized fusion
        x = [weight[0] * x[0], weight[1] * x[1], weight[2] * x[2]]
        return torch.cat(x, self.d)

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n 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, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, BiFPN_Concat2, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, BiFPN_Concat2, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, BiFPN_Concat3, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, BiFPN_Concat2, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

7. 总结

BIFPN（双向特征金字塔网络）通过双向特征融合和加权特征融合的创新设计，显著提升了特征金字塔网络（FPN）的性能。其核心思想是将信息在特征金字塔中双向传递，即从高层特征图向低层特征图传递，同时也从低层特征图向高层特征图传递，确保特征信息的充分融合。同时，BIFPN引入了可学习的加权机制，通过在训练过程中自动调整权重，优化不同尺度特征图的融合效果。这种设计不仅提高了特征表示的能力，还保持了计算的高效性，使其在目标检测和图像分割等计算机视觉任务中表现出色，能够更好地应对多尺度问题和不同任务需求。