跳到主要内容10 张结构图深入理解 YOLOv11 算法各个模块 | 极客日志PythonAI算法
10 张结构图深入理解 YOLOv11 算法各个模块
基于 YOLOv11 源码，通过 10 张结构图和代码示例，深入解析了该算法的核心模块。内容涵盖动态卷积层、标准卷积层、Bottleneck 结构、C2f、C3k、C3K2、FFN、PSA 及 C2PSA 等关键组件的实现细节与设计逻辑。文章旨在帮助开发者理解 YOLOv11 在继承 YOLOv8 基础上的架构优化，包括参数量降低 20% 的技术背景及各模块在前向传播中的具体作用。
PhpPioneer4 浏览 YOLOv11 继承自 YOLOv8，使同等精度下参数量降低 20%。
一、YOLOv11 核心代码和对应结构
（1）动态卷积层
def autopad(k, p=None, d=1): """自动填充以保持输出形状相同"""
if d > 1:
k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]
if p is None:
p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
return p
class DynamicConv(nn.Module):
"""动态卷积层"""
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True, num_experts=):
().__init__()
.conv = nn.Sequential(
DynamicConv_Single(c1, c2, kernel_size=k, stride=s, padding=autopad(k, p, d), dilation=d, groups=g, num_experts=num_experts),
nn.BatchNorm2d(c2),
nn.SiLU() act nn.Identity()
)
():
.conv(x)
微信扫一扫，关注极客日志
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
相关免费在线工具
- 加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
- RSA密钥对生成器
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
- Mermaid 预览与可视化编辑
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
- curl 转代码
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
- Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
- Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
4
super
self
if
else
def
forward
self, x
return
self
（2）卷积层
class Conv(nn.Module):
"""卷积层，包含卷积、批归一化和激活函数"""
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=None, groups=1, act=True):
super(Conv, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, autopad(kernel_size, padding), groups=groups, bias=False)
self.bn = nn.BatchNorm2d(out_channels)
self.act = nn.SiLU() if act else nn.Identity()
def forward(self, x):
return self.act(self.bn(self.conv(x)))
（3）Bottleneck 结构
class Bottleneck(nn.Module):
"""标准瓶颈模块，包含两个卷积层"""
def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
super(Bottleneck, self).__init__()
c_ = int(c2 * e)
self.cv1 = Conv(c1, c_, k[0], 1)
self.cv2 = Conv(c_, c2, k[1], 1)
self.add = shortcut and c1 == c2
def forward(self, x):
"""前向传播，使用 shortcut 连接"""
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
（4）C2f 层
C2f 层使用了 2 个 Bottleneck 模块，在小网络会使用这个模块。
class C2f(nn.Module):
def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
"""Initializes a CSP bottleneck with 2 convolutions and n Bottleneck blocks for faster processing."""
super().__init__()
self.c = int(c2 * e)
self.cv1 = Conv(c1, 2 * self.c, 1, 1)
self.cv2 = Conv((2 + n) * self.c, c2, 1)
self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
def forward(self, x):
y = list(self.cv1(x).chunk(2, 1))
y.extend(m(y[-1]) for m in self.m)
return self.cv2(torch.cat(y, 1))
def forward_split(self, x):
"""Forward pass using split() instead of chunk()."""
y = self.cv1(x).split((self.c, self.c), 1)
y = [y[0], y[1]]
y.extend(m(y[-1]) for m in self.m)
return self.cv2(torch.cat(y, 1))
（5）C3k 层
class C3k(nn.Module):
"""C3k 模块，包含多个瓶颈模块"""
def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=3):
super(C3k, self).__init__()
c_ = int(c2 * e)
self.m = nn.Sequential(*(Bottleneck(c1, c2, shortcut, g, k=(k, k), e=e) for _ in range(n)))
def forward(self, x):
return self.m(x)
（6）C3K2 层
实际就是使用了 2 个上面讲的 C3K 层，在大网络会使用这个模块。
class C3k2(C2f):
def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
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)
)
（7）C3k 动态卷积
class C3k_DynamicConv(C3k):
"""C3k 模块，使用动态卷积"""
def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=3):
super().__init__(c1, c2, n, shortcut, g, e, k)
c_ = int(c2 * e)
self.m = nn.Sequential(*(Bottleneck_DynamicConv(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
class C3k2_DynamicConv(C3k2):
"""C3k2 模块，使用动态卷积"""
def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
super().__init__(c1, c2, n, c3k, e, g, shortcut)
self.m = nn.ModuleList(C3k_DynamicConv(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck_DynamicConv(self.c, self.c, shortcut, g, k=(3, 3), e=1.0) for _ in range(n))
（8）FFN 层
（9）PSA 层
这些模块负责自注意力（self-attention）和前馈（feed-forward）操作。PSABlock 类实现了神经网络中的位置敏感注意力块。这个类封装了应用多头注意力和前馈神经网络层的功能，并可选地包含快捷连接。
class PSABlock(nn.Module):
def __init__(self, c, attn_ratio=0.5, num_heads=4, shortcut=True) -> None:
super().__init__()
self.attn = Attention(c, attn_ratio=attn_ratio, num_heads=num_heads)
self.ffn = nn.Sequential(Conv(c, c * 2, 1), Conv(c * 2, c, 1, act=False))
self.add = shortcut
def forward(self, x):
x = x + self.attn(x) if self.add else self.attn(x)
x = x + self.ffn(x) if self.add else self.ffn(x)
return x
（10）C2PSA 层
- C2PSA 模块：这个模块实现了一个带有注意力机制的卷积块，目的是提升特征提取和处理的效果。
class C2PSA(nn.Module):
def __init__(self, c1, c2, n=1, e=0.5):
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):
a, b = self.cv1(x).split((self.c, self.c), dim=1)
b = self.m(b)
return self.cv2(torch.cat((a, b), 1))
