# 前言

本文为深度学习和YOLO系列的初学者提供了一份关于YOLOv11核心模块C3k2的详细解析。内容从基础概念（如卷积、通道、Bottleneck）讲起，逐步深入到C3k2模块的两种工作模式（简单模式c3k=False与复杂模式c3k=True）、参数配置详解及其源码实现。通过生动的比喻（如将模块比作“工厂生产线”）和清晰的代码注释，帮助读者直观理解C3k2如何通过灵活的结构在YOLOv11中实现高效的特征提取

文章目录： YOLOv11改进大全：卷积层、轻量化、注意力机制、损失函数、Backbone、SPPF、Neck、检测头全方位优化汇总

专栏链接: YOLOv11改进专栏

说明

本文基于版本：tag = 8.3.0，最早版本的YOLOv11代码，可能新版本有区别。但基本没啥影响。

---

🚀 快速理解：C3k2是什么？

用一句话概括

C3k2是一个"智能特征提取器"，它可以根据配置选择使用简单模式（Bottleneck）或复杂模式（C3k）来提取图像特征。

形象比喻

想象C3k2是一个工厂的生产线：

• 简单模式（c3k=False）：使用标准工人（Bottleneck）处理产品
• 复杂模式（c3k=True）：使用高级工人（C3k）处理产品，这些高级工人有更灵活的工具（可变卷积核）

为什么需要C3k2？

在YOLO11中，C3k2替代了YOLOv8的C2f模块，主要目的是：

• ✅ 提高效率：在保持精度的同时减少计算量
• ✅ 灵活配置：可以根据需要选择简单或复杂的特征提取方式
• ✅ 更好性能：通过优化结构实现更快的推理速度

---

📚 基础概念：你需要知道的名词

在深入理解C3k2之前，我们需要了解几个基础概念：

1. 卷积（Convolution）

简单理解：卷积就像用一个小窗口在图像上滑动，提取局部特征。

图像: [1, 2, 3, 4, 5]
窗口: [0.5, 1, 0.5]
结果: 通过窗口计算得到新的特征值

2. 通道（Channel）

简单理解：通道就像图像的"颜色层"。

• RGB图像有3个通道：红色、绿色、蓝色
• 在神经网络中，通道数表示特征图的"深度"

3. Bottleneck（瓶颈结构）

简单理解：Bottleneck就像一个"压缩-处理-扩展"的管道。

输入 (256通道) 
  ↓ [压缩] 
中间层 (128通道) ← 在这里处理特征
  ↓ [扩展]
输出 (256通道)

为什么叫Bottleneck？ 因为中间层通道数较少，像瓶颈一样。

4. 残差连接（Shortcut Connection）

简单理解：残差连接就像"抄近路"，让信息可以直接传递。

输入 → [处理] → 输出
  ↓              ↑
  └──────────────┘ (直接连接)

好处：可以避免信息丢失，让训练更容易。

5. 模块继承关系

简单理解：就像"父子关系"，子模块继承父模块的功能，但可以修改部分行为。

C2f (父类)
  ↓ 继承
C3k2 (子类) ← 可以修改父类的某些部分

---

🔄 C3k2模块的两种模式

C3k2模块有一个"开关"参数c3k，可以切换两种工作模式：

模式1：简单模式（c3k=False）

适用场景：轻量级模型，需要快速推理

工作原理：

输入图像
  ↓
[分割成两部分]
  ↓        ↓
直接传递  经过Bottleneck处理（n次）
  ↓        ↓
[合并两部分]
  ↓
输出特征

特点：

• ✅ 计算速度快
• ✅ 参数量少
• ✅ 适合移动设备

模式2：复杂模式（c3k=True）

适用场景：需要更高精度的场景

工作原理：

输入图像
  ↓
[分割成两部分]
  ↓        ↓
直接传递  经过C3k处理（n次）
  ↓        ↓
[合并两部分]
  ↓
输出特征

C3k内部结构：

C3k模块
  ↓
[分割成两部分]
  ↓        ↓
经过Bottleneck处理  直接传递
  ↓        ↓
[合并两部分]
  ↓
输出

特点：

• ✅ 特征提取能力强
• ✅ 支持可变卷积核大小
• ✅ 适合高精度需求

📊 两种模式对比

特性	简单模式 (c3k=False)	复杂模式 (c3k=True)
计算速度	⚡ 快	🐢 较慢
参数量	📉 少	📈 多
特征提取能力	⭐⭐	⭐⭐⭐
适用场景	移动设备、实时检测	高精度检测
内部结构	Bottleneck	C3k (包含Bottleneck)

---

⚙️ 参数配置详解

配置文件格式

在YOLO11的配置文件中，C3k2的使用格式如下：

[-1, 2, C3k2, [256, False, 0.25]]

参数含义（逐项解释）

让我们用一个快递配送的比喻来理解：

[-1, 2, C3k2, [256, False, 0.25]]
 │   │   │     │    │     │
 │   │   │     │    │     └─ 扩展系数：控制"仓库大小"（0.25表示用25%的空间）
 │   │   │     │    └─────── 模式选择：False=简单模式，True=复杂模式
 │   │   │     └──────────── 输出通道数：最终"货物"的数量（256个）
 │   │   └────────────────── 模块类型：使用C3k2这个"工厂"
 │   └────────────────────── 重复次数：这个"工厂"要运行2次
 └────────────────────────── 输入来源：-1表示使用上一层的输出

参数详细说明

1. 第一个参数：-1（输入来源）

• 含义：从哪里获取输入数据
• -1：使用上一层的输出
• 其他数字：使用指定层的输出（用于特征融合）

2. 第二个参数：2（重复次数 n）

• 含义：这个模块要重复执行几次
• 2：执行2次，意味着会有2个相同的处理单元
• 作用：增加模型的深度，提高特征提取能力

3. 第三个参数：C3k2（模块类型）

• 含义：使用哪种模块
• 固定值：C3k2

4. 第四个参数：[256, False, 0.25]（模块参数）

这是一个列表，包含3个参数：

① 输出通道数：256

• 含义：输出特征图的目标通道数（注意：实际输出会经过width缩放）
• 类比：最终输出的"货物种类"数量
• 影响：通道数越多，能表达的特征越丰富，但计算量也越大
• 实际值：对于yolo11n（width=0.25），实际输出通道 = 256 × 0.25 = 64

② 模式选择：False

• 含义：选择简单模式还是复杂模式
• False：使用简单模式（Bottleneck）
• True：使用复杂模式（C3k）

③ 扩展系数：0.25

• 含义：控制隐藏层的通道数
• 计算：隐藏通道数 = 输出通道数 × 扩展系数 = 256 × 0.25 = 64
• 类比：控制"中间仓库"的大小
• 影响：系数越小，计算量越少，但可能影响特征提取能力

参数解析过程

配置文件中的参数不会直接传递给模块，而是经过一个"翻译"过程：

配置文件: [-1, 2, C3k2, [256, False, 0.25]]
           ↓
     [解析过程]
           ↓
实际参数: c1=上一层的输出通道数
         c2=64 (256经过width=0.25缩放后)
         n=2
         c3k=False
         e=0.25
         g=1 (默认值)
         shortcut=True (默认值)

重要说明：

• c2的值会经过width缩放：c2 = make_divisible(min(256, max_channels) * width, 8)
• 对于yolo11n，width=0.25，所以c2 = 64（不是256）
• e参数直接来自配置文件的第三个参数，所以e=0.25（不是默认值0.5）

实际例子

例子1：简单模式（yolo11n）

[-1, 2, C3k2, [256, False, 0.25]]

解析结果：

• 输入：上一层的输出（假设是128通道）
• 输出：64通道（256 × 0.25 = 64，经过width缩放）
• 重复：2次
• 模式：简单模式（Bottleneck）
• 隐藏层：64 × 0.25 = 16通道（在C2f内部计算）

例子2：复杂模式（yolo11n）

[-1, 2, C3k2, [512, True]]

解析结果：

• 输入：上一层的输出（假设是256通道）
• 输出：128通道（512 × 0.25 = 128，经过width缩放）
• 重复：2次
• 模式：复杂模式（C3k）
• 隐藏层：128 × 0.5 = 64通道（使用默认扩展系数0.5，因为配置中没有提供e参数）

---

💻 代码实现分析

C3k2模块源码

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):
        # 调用父类C2f的初始化方法
        super().__init__(c1, c2, n, shortcut, g, e)

        # 根据c3k参数选择使用C3k还是Bottleneck
        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)  # 创建n个模块
        )

代码解读：

1. class C3k2(C2f)：C3k2继承自C2f，获得了C2f的所有功能
2. super().__init__()：先调用父类的初始化，设置基础结构
3. self.m = nn.ModuleList(...)：创建一个模块列表
4. if c3k else：根据c3k参数选择模块类型
5. for _ in range(n)：创建n个相同的模块

C2f模块（父类）源码

class C2f(nn.Module):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__()
        # 计算隐藏层通道数
        self.c = int(c2 * e)  # 例如：256 * 0.25 = 64

        # 第一个卷积：将输入扩展到2倍隐藏通道数
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)  # 例如：128 → 128

        # 第二个卷积：将合并后的特征压缩到输出通道数
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # 例如：(2+2)*64=256 → 256

        # 创建n个Bottleneck模块（C3k2会覆盖这部分）
        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):
        """前向传播过程"""
        # 1. 通过cv1卷积
        y = list(self.cv1(x).chunk(2, 1))  # 分成两部分

        # 2. 第一部分直接保留，第二部分经过m模块处理
        y.extend(m(y[-1]) for m in self.m)  # 逐层处理

        # 3. 合并所有特征
        return self.cv2(torch.cat(y, 1))  # 拼接后通过cv2输出

工作流程图解：

输入 x (128通道)
  ↓
cv1卷积 (128 → 128通道，分成两部分)
  ↓
[部分1: 64通道] [部分2: 64通道]
  ↓              ↓
保留            经过Bottleneck处理
  ↓              ↓
  └──────┬───────┘
         ↓
   合并 (256通道)
         ↓
    cv2卷积 (256 → 256通道)
         ↓
    输出 (256通道)

Bottleneck模块源码

class Bottleneck(nn.Module):
    """Standard bottleneck."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        super().__init__()
        # 计算隐藏层通道数
        c_ = int(c2 * e)  # 例如：64 * 1.0 = 64

        # 第一个卷积：压缩
        self.cv1 = Conv(c1, c_, k[0], 1)  # 例如：64 → 64 (3×3卷积)

        # 第二个卷积：扩展
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)  # 例如：64 → 64 (3×3卷积)

        # 是否使用残差连接
        self.add = shortcut and c1 == c2

    def forward(self, x):
        """前向传播"""
        # 如果可以使用残差连接，就加上原始输入
        if self.add:
            return x + self.cv2(self.cv1(x))  # 残差连接
        else:
            return self.cv2(self.cv1(x))  # 普通连接

Bottleneck工作流程：

输入 (64通道)
  ↓
cv1: 3×3卷积 (64 → 64通道)
  ↓
cv2: 3×3卷积 (64 → 64通道)
  ↓
[如果输入输出通道相同，加上原始输入]
  ↓
输出 (64通道)

C3k模块源码

class C3k(C3):
    """C3k is a CSP bottleneck module with customizable kernel sizes."""

    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
        # 调用父类C3的初始化
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # 隐藏通道数

        # 覆盖父类的self.m，使用可变卷积核大小
        self.m = nn.Sequential(
            *(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) 
            for _ in range(n))  # n个Bottleneck
        )

C3k与C3的区别：

特性	C3	C3k
卷积核	固定：1×1 和 3×3	可变：k×k 和 k×k
灵活性	低	高
默认k值	-	3

C3模块（C3k的父类）源码

class C3(nn.Module):
    """CSP Bottleneck with 3 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__()
        c_ = int(c2 * e)  # 隐藏通道数

        # 三个卷积层
        self.cv1 = Conv(c1, c_, 1, 1)  # 输入 → 隐藏层
        self.cv2 = Conv(c1, c_, 1, 1)  # 输入 → 隐藏层（另一路）
        self.cv3 = Conv(2 * c_, c2, 1)  # 合并 → 输出

        # 中间处理模块（C3k会覆盖这部分）
        self.m = nn.Sequential(
            *(Bottleneck(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) 
            for _ in range(n))
        )

    def forward(self, x):
        """前向传播"""
        # 两路处理：一路经过m模块，一路直接传递
        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))

C3工作流程：

输入 x
  ↓
  ├─→ cv1 → m模块处理 → ─┐
  │                      ↓
  └─→ cv2 (直接传递) → ──→ 合并 → cv3 → 输出

---

❓ 常见问题解答

Q1: C3k2中的"2"是什么意思？

A: 这个"2"容易引起误解。实际上：

• 不是：C3k2使用了2个C3k模块
• 而是：当c3k=True时，传递给C3k模块的参数n=2，表示C3k内部包含2个Bottleneck

正确理解：

C3k2模块
  ├─ self.m[0]: C3k模块（内部有2个Bottleneck）
  └─ self.m[1]: C3k模块（内部有2个Bottleneck）

Q2: 什么时候用简单模式，什么时候用复杂模式？

A:

• 简单模式（c3k=False）：

  • 模型的前几层（特征还比较简单）
  • 需要快速推理的场景
  • 移动设备部署

• 复杂模式（c3k=True）：

  • 模型的后几层（需要提取复杂特征）
  • 需要高精度的场景
  • 有足够计算资源的情况

Q3: 扩展系数e应该怎么设置？

A:

• e=0.25：轻量级，计算快，适合移动设备
• e=0.5：平衡模式，精度和速度兼顾（默认值）
• e=1.0：高精度，计算量大，适合服务器

Q4: 为什么C3k2要继承C2f？

A:

• 代码复用：不需要重复实现基础功能
• 保持兼容：可以无缝替换YOLOv8的C2f模块
• 灵活扩展：只需要修改self.m部分，其他部分保持不变

Q5: 参数解析是怎么工作的？

A: 配置文件中的参数经过parse_model函数处理。下面是详细的解析过程：

parse_model函数源码解读

def parse_model(d, ch, verbose=True):
    """Parse a YOLO model.yaml dictionary into a PyTorch model."""
    # 1. 获取模型配置参数
    depth, width, max_channels = scales[scale]  # 例如：width=0.25, max_channels=1024

    # 2. 遍历配置文件中的每一层
    for i, (f, n, m, args) in enumerate(d["backbone"] + d["head"]):
        # f: 输入来源（如-1表示上一层）
        # n: 重复次数（如2）
        # m: 模块类型（如"C3k2"）
        # args: 模块参数列表（如[256, False, 0.25]）

        # 3. 对于C3k2等模块的特殊处理
        if m in {C2f, C3k2, ...}:
            # 3.1 获取输入输出通道数
            c1 = ch[f]  # 从上一层的输出通道数获取
            c2 = args[0]  # 配置文件中的第一个参数（如256）

            # 3.2 对c2进行width缩放
            if c2 != nc:  # nc是类别数，这里不相等
                c2 = make_divisible(min(c2, max_channels) * width, 8)
                # 例如：min(256, 1024) * 0.25 = 64

            # 3.3 重新组织参数：将c1和缩放后的c2插入到args前面
            args = [c1, c2, *args[1:]]
            # 例如：[c1, 64, False, 0.25]

            # 3.4 对于C3k2等模块，需要插入重复次数n
            if m in {C2f, C3k2, ...}:
                args.insert(2, n)  # 在位置2插入n
                # 例如：[c1, 64, 2, False, 0.25]
                n = 1  # 重置n，因为已经插入到args中了

            # 3.5 对于C3k2的特殊处理：M/L/X尺寸模型自动启用c3k=True
            if m is C3k2 and scale in "mlx":
                args[3] = True  # 将c3k参数设置为True

        # 4. 创建模块实例
        m_ = m(*args)  # 例如：C3k2(c1, 64, 2, False, 0.25, g=1, shortcut=True)

实际解析示例

例子1：简单模式（yolo11n）

# 配置文件
[-1, 2, C3k2, [256, False, 0.25]]

解析过程：

# 初始状态
f = -1  # 使用上一层的输出
n = 2   # 重复2次
m = C3k2
args = [256, False, 0.25]

# 步骤1：获取输入通道数
c1 = ch[-1]  # 假设上一层的输出是128通道

# 步骤2：计算输出通道数（经过width缩放）
c2 = make_divisible(min(256, 1024) * 0.25, 8) = 64

# 步骤3：重新组织参数
args = [c1, c2, *args[1:]]  # [128, 64, False, 0.25]

# 步骤4：插入重复次数n
args.insert(2, n)  # [128, 64, 2, False, 0.25]

# 步骤5：创建模块（最终参数对应）
# C3k2(c1=128, c2=64, n=2, c3k=False, e=0.25, g=1, shortcut=True)

例子2：复杂模式（yolo11n）

# 配置文件
[-1, 2, C3k2, [512, True]]

解析过程：

# 初始状态
args = [512, True]

# 步骤1-2：计算c2
c2 = make_divisible(min(512, 1024) * 0.25, 8) = 128

# 步骤3：重新组织参数
args = [c1, 128, True]  # 注意：没有e参数

# 步骤4：插入n
args = [c1, 128, 2, True]

# 步骤5：创建模块（最终参数对应）
# C3k2(c1=c1, c2=128, n=2, c3k=True, e=0.5, g=1, shortcut=True)
# 注意：e使用默认值0.5，因为配置中没有提供

例子3：M/L/X尺寸自动启用c3k

# 配置文件（yolo11m/l/x，scale in "mlx"）
[-1, 2, C3k2, [512, False]]

解析过程：

# 步骤1-4：正常解析
args = [c1, c2, 2, False]

# 步骤5：特殊处理 - 自动将c3k设置为True
if m is C3k2 and scale in "mlx":
    args[3] = True  # False → True

# 最终：C3k2(c1=c1, c2=c2, n=2, c3k=True, ...)

参数映射关系

配置文件	解析后位置	C3k2参数	说明
args[0]	args[1]	c2	输出通道数（经过width缩放）
args[1]	args[3]	c3k	模式选择（False/True）
args[2]	args[4]	e	扩展系数（可选，默认0.5）
-	args[0]	c1	输入通道数（自动获取）
-	args[2]	n	重复次数（从配置文件第二个参数获取）

Q6: C3k和C3有什么区别？

A: 主要区别在于卷积核大小：

模块	第一个卷积	第二个卷积
C3	1×1	3×3
C3k	k×k	k×k（默认k=3）

C3k的优势是可以自定义卷积核大小，提供更高的灵活性。

---

---

📁 相关文件位置

• C3k2定义：ultralytics/nn/modules/block.py:723-731
• C3k定义：ultralytics/nn/modules/block.py:734-742
• C2f定义：ultralytics/nn/modules/block.py:224-245
• C3定义：ultralytics/nn/modules/block.py:248-262
• Bottleneck定义：ultralytics/nn/modules/block.py:333-346
• parse_model函数：ultralytics/nn/tasks.py:933-1070（C3k2相关处理在1000-1029行）
• 配置文件：ultralytics/cfg/models/11/yolo11.yaml

---