YOLO11 系列是 YOLO 家族中最先进的 (SOTA)、最轻量级、最高效的模型，其表现优于其前辈。它由 Ultralytics 创建，该组织发布了 YOLOv8，这是迄今为止最稳定、使用最广泛的 YOLO 变体。YOLO11 将延续 YOLO 系列的传奇。在本文中，我们将探讨 YOLO11
文章目录
YOLO11 官方代码： https://github.com/ultralytics/ultralytics
YOLO11 是 Ultralytics 的 YOLO 系列的最新版本。YOLO11 配备了超轻量级模型，比以前的 YOLO 更快、更高效。YOLO11 能够执行更广泛的计算机视觉任务。Ultralytics 根据规模发布了五种 YOLO11 模型，在所有任务中发布了 25 种模型：
- YOLO11n——适用于小型和轻量级任务的 Nano。
- YOLO11s ——Nano 的小幅升级，具有更高的准确性。
- YOLO11m – 适合通用的中等版本。
- YOLO11l – 大型，可实现更高的准确度和更高的计算量。
- YOLO11x – 超大尺寸，可实现最高准确度和性能。
YOLO11 建立在 Ultralytics YOLOv8 代码库之上，并进行了一些架构修改。它还集成了以前的 YOLO（如 YOLOv9 和 YOLOv10）中的新功能（改进了这些功能），以提高性能。
YOLO11 架构、YOLO11 新功能
0. YOLO11 总体网络结构图
1. YOLO11各部分细致结构图（C3k2、SPPF、C2PSA、YOLO11Head）
YOLO11 架构是对 YOLOv8 架构的升级，包含一些新的集成和参数调整。
原始 YOLO11 的配置文件：
# 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, [1]] # cat backbone P4
- [-1, 2, C3k2, [512, False]] # 13
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
- [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
- [-1, 1, Conv, [256, 3, 2]]
- [[-1, 13], 1, Concat, [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)
2 主干Backbone
主干是模型的一部分，用于从输入图像中提取多个尺度的特征。它通常涉及堆叠卷积层和块以创建不同分辨率的特征图。
2.1主干Backbone 结构图
左边部分
2.2 Conv卷积层
YOLO11 具有类似的结构，其中初始卷积层用于对图像进行下采样：
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
代码
class Conv(nn.Module):
default_act = nn.SiLU() # default activation
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
super().__init__()
self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
self.bn = nn.BatchNorm2d(c2)
self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
def forward(self, x):
return self.act(self.bn(self.conv(x)))
- 实现具有批量标准化和激活的标准卷积层。
- 组成：
self.conv：卷积层。
self.bn：批量标准化。
self.act：激活函数（默认为 nn.SiLU()）。
前向传递：应用卷积，然后进行批量标准化和激活。
2.3 C3k2 块
YOLO11 引入了C3k2块，而不是 C2f ，它在计算方面更高效。该块是CSP Bottleneck的自定义实现，它使用两个卷积，而不是一个大卷积（如 YOLOv8 中一样）。
CSP（Cross Stage Partial）： CSP 网络分割特征图，并通过瓶颈层处理一部分，同时将另一部分与瓶颈的输出合并。这减少了计算量并改善了特征表示。
C3k2 块还使用较小的内核大小（由 k2 表示），使其速度更快同时保持性能。
- [-1, 2, C3k2, [256, False, 0.25]]
C3k2 结构图
C3k2 解析
那么，让我们看看新的块（层）在代码中的样子：
- C3k2 块（来自blocks.py ）：
- C3k2是CSP bottleneck的一个更快、更高效的变体。它使用两个卷积而不是一个大卷积，从而加快了特征提取速度。
class C3k2(C2f):
"""Faster Implementation of CSP Bottleneck with 2 convolutions."""
def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
"""Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
super().__init__(c1, c2, n, shortcut, g, e)
self.m = nn.ModuleList(
C3k(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck(self.c, self.c, shortcut, g) for _ in range(n)
)
- C3k 块（来自blocks.py ）：
- C3k是一个更灵活的瓶颈模块，允许自定义内核大小。这对于提取图像中更详细的特征很有用。
class C3k(C3):
"""C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""
def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
"""Initializes the C3k module with specified channels, number of layers, and configurations."""
super().__init__(c1, c2, n, shortcut, g, e)
c_ = int(c2 * e) # hidden channels
# self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
2.4 C2PSA 和 SPPF
C2PSA 结构图
YOLO11 保留了 SPPF 块，但在 SPPF 之后添加了新的C2PSA块：
- [-1, 1, SPPF, [1024, 5]]
- [-1, 2, C2PSA, [1024]
C2PSA 解析
C2PSA （跨阶段局部空间注意）模块增强了特征图中的空间注意，提高了模型对图像重要部分的关注。通过空间池化特征，模型能够更有效地关注特定感兴趣区域。
- C2PSA 区块（来自blocks.py ）：
- C2PSA（跨阶段局部空间注意）增强了模型的空间注意能力。此模块将注意力添加到特征图，帮助模型关注图像的重要区域。
class C2PSA(nn.Module):
"""
具有注意力机制的 C2PSA 模块，用于增强特征提取和处理。
此模块实现了具有注意力机制的卷积块，以增强特征提取和处理
能力。它包括一系列用于自我注意和前馈操作的 PSABlock 模块。
属性：
c (int)：隐藏通道数。
cv1 (Conv)：1x1 卷积层，将输入通道数减少到 2*c。
cv2 (Conv)：1x1 卷积层，将输出通道数减少到 c。
m (nn.Sequential)：用于注意力和前馈操作的 PSABlock 模块的顺序容器。
方法：
forward：通过 C2PSA 模块执行前向传递，应用注意力和前馈操作。
注意：
此模块本质上与 PSA 模块相同，但经过重构，允许堆叠更多 PSABlock 模块。
示例：
>>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5)
>>> 输入张量 = torch.randn(1, 256, 64, 64)
>>> 输出张量 = c2psa(输入张量)
"""
def __init__(self, c1, c2, n=1, e=0.5):
"""Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
super().__init__()
assert c1 == c2
self.c = int(c1 * e)
self.cv1 = Conv(c1, 2 * self.c, 1, 1)
self.cv2 = Conv(2 * self.c, c1, 1)
self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
def forward(self, x):
"""Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
a, b = self.cv1(x).split((self.c, self.c), dim=1)
b = self.m(b)
return self.cv2(torch.cat((a, b), 1))
SPPF 结构图
SPPF 解析
- SPPF：空间金字塔池化快速模块，在多个尺度上执行池化。
class SPPF(nn.Module):
"""Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher."""
def __init__(self, c1, c2, k=5):
"""
Initializes the SPPF layer with given input/output channels and kernel size.
This module is equivalent to SPP(k=(5, 9, 13)).
"""
super().__init__()
c_ = c1 // 2 # hidden channels
self.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c_ * 4, c2, 1, 1)
self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
def forward(self, x):
"""Forward pass through Ghost Convolution block."""
y = [self.cv1(x)]
y.extend(self.m(y[-1]) for _ in range(3))
return self.cv2(torch.cat(y, 1))
- SPPF 模块在不同尺度上执行最大池化，并连接结果以捕获多个空间尺度的特征。
- 包括：
self.cv1：减少通道数量。
self.cv2：调整连接后的通道数量。
self.m：最大池化层。
前向传递：输入 x 经过 cv1，然后经过三个连续的最大池化层 (y1, y2, y3)。结果连接起来并经过 cv2。
总的
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
3 Neck部分
颈部负责聚合不同分辨率的特征并将它们传递给头部进行预测。它通常涉及不同级别的特征图的上采样和连接。
3.1 Neck结构图
中间部分
3.2 Neck模块解析
C3k2 块：
YOLO11 将颈部的 C2f 块替换为C3k2块。如前所述，C3k2 是一个更快、更高效的块。例如，经过上采样和连接后，YOLO11 中的颈部如下所示：
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
- [-1, 2, C3k2, [512, False]] # 13
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
- [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
- [-1, 1, Conv, [256, 3, 2]]
- [[-1, 13], 1, Concat, [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)
这一变化提高了特征聚合过程的速度和性能。
注意力机制： YOLO11 通过C2PSA更加关注空间注意力，这有助于模型聚焦于图像中的关键区域，从而实现更好的检测。YOLOv8 缺少这一功能，这使得 YOLO11 在检测较小或被遮挡的物体时可能更准确。
4. Head检测头
4.1 Head检测头 结构图
4.2 Head检测头 解析
头部是模型中负责生成最终预测的部分。在物体检测中，这通常意味着生成边界框并对这些框内的对象进行分类。
- [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)
class Detect(nn.Module):
def __init__(self, nc=80, ch=()):
super().__init__()
self.nc = nc # number of classes
self.nl = len(ch) # number of detection layers
self.reg_max = 16 # DFL channels
self.no = nc + self.reg_max * 4 # number of outputs per anchor
self.stride = torch.zeros(self.nl) # strides computed during build
# Define layers
self.cv2 = nn.ModuleList(
nn.Sequential(Conv(x, c2, 3), Conv(c2, c2, 3), nn.Conv2d(c2, 4 * self.reg_max, 1)) for x in ch
)
self.cv3 = nn.ModuleList(
nn.Sequential(
nn.Sequential(DWConv(x, x, 3), Conv(x, c3, 1)),
nn.Sequential(DWConv(c3, c3, 3), Conv(c3, c3, 1)),
nn.Conv2d(c3, self.nc, 1),
)
for x in ch
)
self.dfl = DFL(self.reg_max) if self.reg_max > 1 else nn.Identity()
- Detect 类定义输出边界框坐标和类概率的检测头。
- 组成：
self.cv2：用于边界框回归的卷积层。
self.cv3：用于分类的卷积层。
self.dfl：用于边界框细化的分布焦点损失模块。
前向传递：处理输入特征图并输出边界框和类别的预测。
YOLO11 的应用
YOLO 以其物体检测模型而闻名。然而，YOLO11 可以执行多种计算机视觉任务，例如 YOLOv8。它包括：
物体检测
实例分割
图像分类
姿态估计
定向物体检测 (OBB)
目标检测
YOLO11 通过将输入图像传入 CNN 来提取特征，从而执行对象检测。然后，网络预测这些网格内对象的边界框和类别概率。为了处理多尺度检测，使用层来确保检测到各种大小的对象。然后使用非最大抑制 (NMS) 细化这些预测以过滤掉重复或低置信度的框，从而实现更准确的对象检测。YOLO11 在 MS-COCO 数据集上进行对象检测训练，其中包括 80 个预训练类。
实例分割
除了检测物体之外，YOLO11 还通过添加掩码预测分支扩展到实例分割。这些模型在 MS-COCO 数据集上进行训练，该数据集包含 80 个预训练类。此分支为每个检测到的物体生成逐像素分割掩码，使模型能够区分重叠物体并提供其形状的精确轮廓。头部的掩码分支处理特征图并输出物体掩码，从而实现像素级精度来识别和区分图像中的物体。
姿态估计
YOLO11 通过检测和预测物体上的关键点（例如人体的关节）来执行姿势估计。关键点连接起来形成骨架结构，该结构表示姿势。这些模型在 COCO 上进行训练，其中包括一个预训练类“人”。
在头部添加姿势估计层，训练网络预测关键点的坐标，后处理步骤将这些点连接起来形成骨架结构，实现实时姿势识别。
图像分类
对于图像分类，YOLO11 使用其深度神经网络从输入图像中提取高级特征并将其分配给几个预定义类别之一。这些模型在 ImageNet 上进行训练，其中包含 1000 个预训练类别。网络通过多层卷积和池化处理图像，减少空间维度，同时增强基本特征。网络顶部的分类头输出预测的类别，使其适用于需要识别图像整体类别的任务。
定向物体检测 (OBB)
YOLO11 通过整合 OBB 扩展了常规物体检测，这使得模型能够检测和分类旋转或方向不规则的物体。这对于航空图像分析等应用特别有用。这些模型是在 DOTAv1 上训练的，其中包括 15 个预训练类。
OBB 模型不仅输出边界框坐标，还输出旋转角度 (θ) 或四个角点。这些坐标用于创建与物体方向一致的边界框，从而提高旋转物体的检测准确率。
参考：https://github.com/ultralytics/ultralytics
标签：YOLO11,nn,Conv,结构图,C2PSA,C3k2,解析,self From： https://blog.csdn.net/qq_38668236/article/details/143820170