---

前言

Hello，大家好，我是GISer Liu😁，一名热爱AI技术的GIS开发者。本系列是作者参加DataWhale 2025年6月份Yolo原理组队学习的技术笔记文档，这里整理为博客，希望能帮助Yolo的开发者少走弯路！

🚀 欢迎来到YOLO进阶系列教程的核心，也是最后一篇文章——模型“魔改”！在目标检测领域，YOLO系列凭借其卓越的速效平衡成为了标杆。然而，无论是为了发表学术论文，还是应对复杂多变的业务场景，仅仅满足于使用官方模型、调整参数是远远不够的。我们需要的，是突破“调参工程师”的局限，真正深入模型内部，进行结构级的创新。

这正是Datawhale YOLO Master项目的初衷。它提供了一套即插即用的先进模块和一套系统性的魔改方法论，旨在帮助开发者：

1. 系统性理解YOLO架构：拆解模型为Backbone、Neck、Head等核心组件。
2. 掌握模块化创新：像搭乐高一样，将前沿的模块（如SwinTransformer, CBAM等）无缝集成到YOLOv8/v10/v11中。
3. 提升工程与科研能力：从源码层面理解并改造SOTA模型，为自己的项目或研究注入创新力。

本教程将手把手带你走完从环境准备到模型改造、训练的全过程。无论你是希望在CV领域深造的大学生，还是寻求技术突破的开发者，相信本教程都能为你提供坚实的起点。OK,让我们开始“造”自己的YOLO吧！

---

更新记录：(本文随时更新)

20250709：本文当前只是理论的堆砌，阅读感觉并不好；不够直观；后续我作者通过一个具体的需求，例如遥感影像目标识别去魔改我们的yolo模型结构；测试性能的变化；

---

一、YOLO“魔改”：从“调参”到“改结构”

1. 为什么要“魔改”YOLO？

标准的YOLO模型虽然强大，但在特定任务上未必是最优解。例如，在遥感影像中检测微小目标，或是在工业流水线上识别密集物体，都对模型的特征提取能力、多尺度融合等方面提出了更高的要求。此时，仅仅调整学习率、优化器等超参数，带来的性能提升是有限的。

真正的突破来自于对网络结构的创新——也就是我们常说的“魔改”。这好比我们不是简单地调整一辆车的悬挂软硬（调参），而是给它换上一台更强劲的发动机或者更先进的空气动力学套件（魔改）。

模型魔改是网络结构上的修改和替换，而非简单调参；这需要开发者对模型组成和原理有深刻的理解🤔

2. “魔改”的哲学：像搭乐高一样构建网络

YOLO Master项目的核心思想是将复杂的神经网络解构成一系列可插拔的、标准化的“积木块”。YOLO模型经典的三段式结构（主干、颈部、头部）为这种模块化改造提供了完美的框架。

• 主干网络 (Backbone)：负责从输入图像中提取基础特征，是模型的“地基”。我们可以将其替换为更先进的结构，如SwinTransformer、ConvNeXtV2等，以获取更强的特征表达能力。
• 颈部网络 (Neck)：负责融合主干网络在不同阶段提取出的特征图，增强模型对不同尺寸目标的感知能力。可以引入GFPN等结构进行优化。
• 检测头 (Head)：根据融合后的特征进行最终的边界框回归和类别预测。我们可以尝试DyHead等动态头部来提升检测性能。
• 注意力机制 (Attention)：像“插件”一样，可以插入到网络中的任何位置，让模型“关注”到最重要的特征区域。CBAM和SE是常用的选择。

---

二、准备工作：搭建你的“魔改”基础环境

在开始之前，我们需要准备好两个核心的代码库：ultralytics官方库和yolo-master魔改项目库。

1. 克隆项目仓库

我们提供三种下载方式，推荐使用git clone，如果遇到网络问题，可以尝试国内的GitCode镜像。

① 下载 ultralytics 源码

# 方法一：从GitHub直接克隆 (推荐)
git clone https://github.com/ultralytics/ultralytics.git# 方法二：从国内镜像GitCode克隆
git clone https://gitcode.com/gh_mirrors/ul/ultralytics.git

其中，我们要对ultralytics文档目录结构有个相对完整的了解：

ultralytics/​​​​
​assets:静态资源：测试图像、预训练模型等示例文件
cfg:配置文件中心​​
- datasets/：数据集定义（路径、类别、预处理）
- models/：模型架构配置（YOLOv8n/v8s/v8m等）
- trackers/：跟踪算法参数
- default.yaml：全局默认配置（训练/推理/导出参数）
​data/​:数据预处理与增强逻辑
engine/​:核心功能引擎
- exporter.py：模型导出（ONNX/TensorRT等）
- model.py：模型生命周期管理
- predictor.py：推理接口
- trainer.py：训练流程控制
- validator.py：验证指标计算
​hub/​​:PyTorch Hub 集成接口
models/​​:模型架构实现
- yolo/：YOLO系列主代码
- detect/：检测任务
- segment/：分割任务
- pose/：姿态估计
- classify/：分类任务
- model.py：模型构建核心
- rtdetr/：实时DETR架构
- nas/：神经架构搜索
- sam/：SAM优化策略
- fastsam/：快速分割模型
​nn/​​:神经网络组件：自定义层/激活函数等
​solutions/​​:高级应用模块:线计数/热力图生成等场景化解决方案
trackers/​​:多目标跟踪（MOT）算法实现
utils/​​:工具库
- callbacks/：训练回调函数
- metrics.py：性能评估指标
- plotting.py：可视化工具
- torch_utils.py：PyTorch扩展功能
- downloads.py：资源下载管理
- ops.py：张量操作扩展
​init.py​:包初始化入口（版本/API暴露）

② 下载 yolo-master 魔改教程源码

git clone https://github.com/datawhalechina/yolo-master.git

2. 环境配置

进入yolo-master目录，其中包含了requirements.txt文件，我们可以使用pip进行安装。为了加速下载，建议使用国内的清华镜像。

# 进入yolo-master项目目录
cd yolo-master# 安装依赖，-e . 表示以可编辑模式安装ultralytics
# 假设你的ultralytics目录与yolo-master在同一级
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install -e ../ultralytics

pip install -e . 的 -e 代表 “editable”（可编辑）。这种方式安装后，你对 ultralytics 源码的任何修改（比如我们后续的“魔改”操作）会立刻生效，而无需重新安装。这对于模型开发和调试至关重要。

---

三、主干(BackBone)的替换

要实现真正的“即插即用”，我们需要对ultralytics的源码进行一些通用性的改造，让它能够识别并正确处理我们添加的自定义模块，特别是复杂的主干网络。修改的核心位于ultralytics/nn/tasks.py文件中，这个文件负责解析YAML配置文件并构建整个神经网络模型。

1. 魔改的挑战与思路

挑战：ultralytics原生的parse_model函数设计时，主要考虑的是构建由一系列“标准”层（如Conv、C2f、Concat）组成的网络。这些层有一个共同点：输入一个张量，输出一个张量。而我们想替换的先进主干网络（如RepViT, SwinTransformer等）通常是作为一个整体模块，它输入一个图像张量，一次性输出多个不同尺度的特征图（例如，同时输出P3, P4, P5三个层级的特征）。原生的解析和前向传播逻辑无法直接处理这种“一对多”的复杂模块。

解决思路：我们的魔改思路可以分为两步，就像进行一次精密的“外科手术”：

1. 改造parse_model函数（模型构建阶段）：让它在解析YAML时，能够“识别”出我们自定义的、作为整体的主干网络。识别后，它需要特殊处理：不再将它看作一个普通层，而是作为一个特殊的“多输出模块”，并正确记录下它所有输出头的通道信息。
2. 改造_predict_once函数（模型推理阶段）：让它在前向传播时，如果遇到这个被标记过的特殊主干网络，就执行特殊的传播逻辑。这个逻辑会一次性接收主干网络输出的多个特征图，并将它们正确地存放到一个列表中（y列表），以供后续的Neck网络层使用。

2. 实战：一步步改造YOLOv8主干

主干网络是决定模型性能的基石。YOLO Master提供了大量先进的Backbone供我们选择。

可选主干网络	核心思想
RepViT	融合CNN的效率和ViT的性能
StarNet	轻量级、高效的星状结构
EfficientViT	高效的Vision Transformer变体
FasterNet	极速推理，专注于硬件友好
ConvNeXtV2	现代化的纯卷积网络，性能媲美Transformer
SwinTransformer	经典的层级化窗口注意力Transformer
VanillaNet	极简主义设计，返璞归真但效果强大
…	(还有更多)

让我们以RepViT为例，演示完整的替换步骤。
接下来，我们将以RepViT为例，完整地展示如何实现这一“手术”。这个方法具有普适性，适用于本文中介绍的所有主干网络。

① 准备模块代码和配置文件

• 第一步：安放模块代码
  在ultralytics/ultralytics/nn/目录下，创建一个新文件夹new_modules。然后，将yolo-master项目中的Backbone_RepViT.py文件复制到这个新文件夹中，并重命名为repvit.py。
  
  

  • 目的：将我们自定义的模块代码与ultralytics的官方代码分离开，便于管理和维护。

• 第二步：安放YAML文件
  将yolo-master中的RepViT-P345.yaml文件复制到ultralytics/cfg/models/v8/（或者你指定的其他版本目录）下。这个YAML文件描述了使用RepViT作为主干的网络结构。
  

  • 目的：让YOLO的训练引擎能够找到并加载我们的新模型定义。

② 引用新模块

打开ultralytics/nn/tasks.py文件，在文件的开头部分，找到导入模块的区域，添加以下代码：

# ultralytics/nn/tasks.py# ... 其他 import 语句 ...
from ultralytics.utils.torch_utils import (fuse_conv_and_bn, fuse_deconv_and_bn, initialize_weights, intersect_dicts,make_divisible, model_info, scale_img, time_sync)# ==================== 在这里添加我们的新模块导入 ====================
from .new_modules.repvit import *
from .new_modules.starnet import * # 为后续其他模块预留
from .new_modules.efficientvit import * # 为后续其他模块预留
# ... 你可以继续添加其他自定义模块的导入 ...
# ===================================================================#LOGGER = logging.getLogger(__name__)
# ... 文件后续内容 ...

• 目的：将repvit.py中定义的所有类（如repvit_m2_3）导入到tasks.py的全局命名空间中，这样parse_model函数在解析YAML时才能通过字符串名字找到并实例化它们。

③ 核心改造一：parse_model函数

在tasks.py中，使用Ctrl+F找到parse_model函数。这是整个魔改工程的核心。我们将分三部分进行修改。

i) 修改读取模型参数部分（增强解析器的灵活性）

这部分修改的目的是让解析器更加健壮和灵活，能够处理更复杂的参数和模块名，为后续所有类型的魔改（包括主干、颈部等）打下基础。
原代码:

 for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, argsm = getattr(torch.nn, m[3:]) if 'nn.' in m else globals()[m]  # get modulefor j, a in enumerate(args):if isinstance(a, str):with contextlib.suppress(ValueError):args[j] = locals()[a] if a in locals() else ast.literal_eval(a)```* **修改后代码**：```pythonis_backbone = Falsefor i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args# ==================== 增强的模块获取逻辑 ====================# 原理：使用 try-except 块来优雅地处理模块查找。# 原生代码直接使用 globals()[m] 查找，如果m不是一个已知的模块名，程序会报错退出。# 修改后，我们尝试获取模块，如果失败（比如m是一个我们后续要特殊处理的字符串），# 就暂时跳过，给予后续代码处理它的机会。try:if m == 'node_mode':  # 为更复杂的颈部（如GFPN）预留的逻辑m = d[m]if len(args) > 0:if args[0] == 'head_channel':args[0] = int(d[args[0]])t = m # 临时保存模块名字符串，用于打印日志m = getattr(torch.nn, m[3:]) if 'nn.' in m else globals()[m]  # get moduleexcept:pass # 如果在globals()中找不到模块名，暂时忽略# ==========================================================# ==================== 增强的参数解析逻辑 ====================# 原理：同样使用 try-except 块增强鲁棒性。# 有些参数可能是字符串（如路径），ast.literal_eval 会解析失败。# 修改后，如果解析失败，就保持其原始的字符串类型。for j, a in enumerate(args):if isinstance(a, str):with contextlib.suppress(ValueError):try:args[j] = locals()[a] if a in locals() else ast.literal_eval(a)except:args[j] = a # 解析失败时，保留为字符串# ==========================================================

ii) 添加自定义主干的参数接收逻辑

这是识别我们自定义主干的“秘密握手”。

• 实现思路：我们在parse_model函数的循环内部，计算每个模块的输出通道数c2之后，添加一个判断。如果m是我们自定义的主干网络类（如repvit_m2_3），我们就调用它特有的一个方法（我们约定所有自定义主干都实现一个名为channel的属性或方法）来获取它所有输出层的通道列表。

在c1, c2 = ch[f], args[0]这行代码之后，添加如下逻辑：

# ... 在 parse_model 函数的循环内 ...if m in (Classify, Detect, RTDETR, Segment):# ... 省略 ...elif m is nn.BatchNorm2d:# ... 省略 ...else:c2 = ch[f] if c2 == -1 else c2# ==================== 自定义主干接收参数部分 ====================# 原理：这是识别自定义主干的核心。# 我们约定，所有即插即用的主干网络模块，都会有一个名为 `channel` 的属性，# 这个属性返回一个列表，包含了它所有输出特征图的通道数。# 通过检查模块 m 是否有 'channel' 属性，我们就能识别出它。if hasattr(globals()[t], 'channel'): # 使用临时变量t（模块名字符串）来检查# 实例化主干网络。注意，这里的m是模块的类本身。m = m()# 获取输出通道列表，例如 [128, 256, 512]c2 = m.channel# ==============================================================m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module# ... 后续代码 ...

iii) 修改模型实例化部分

这部分是整个改造的“执行”阶段。在这里，我们将真正地区分处理标准层和我们的自定义主干。

原代码:

    # 原代码部分一m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # modulet = str(m)[8:-2].replace('__main__.', '')  # module typem_.np = sum(x.numel() for x in m_.parameters())  # number paramsm_.i, m_.f, m_.type = i, f, t  # attach index, 'from' index, typeif verbose:LOGGER.info(f'{i:>3}{str(f):>20}{n_:>3}{m_.np:10.0f}  {t:<45}{str(args):<30}')  # printsave.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist# 原代码部分二if i == 0:ch = []ch.append(c2)

修改后代码 (整合了ii和iii的逻辑)：

    # ... 在 c1, c2 = ch[f], args[0] 之后 ...# 这是更完整的逻辑，取代了ii)中的简单判断if m in (Conv, ConvTranspose, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, Focus,BottleneckCSP, C1, C2, C2f, C3, C3TR, C3Ghost, nn.Conv2d, DWConvTranspose, C3x, RepC3):c2 = m.get_nc(ch, f, args)  # get c2 output channels# ... (省略其他elif)# ==================== 修改后的模型实例化 ====================# --- 步骤 1: 实例化与识别 ---# 巧妙的识别方法：我们先按常规方式实例化模块。# 如果 m 是我们的自定义主干，它没有输入参数，直接 m() 即可。# 然后，我们检查它的 `channel` 属性，得到 `c2`。# 如果 `c2` 是一个列表，就说明这是一个自定义主干！if isinstance(c2, list):# 是自定义主干，is_backbone标志位设为Trueis_backbone = True# m_ 直接就是我们实例化的主干对象 m (在之前的步骤中已经 m=m() )m_ = m# 给模块实例动态添加一个 'backbone' 属性，值为 True。# 目的：这是一个“标记”，为了在后续的前向传播 `_predict_once` 函数中识别它。m_.backbone = Trueelse:# 是标准层，按原逻辑构建m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # modulet = str(m)[8:-2].replace('__main__.', '')  # module type# --- 步骤 2: 计算参数并附加信息 ---# 计算参数量m_.np = sum(x.numel() for x in m_.parameters())  # number params# 附加索引信息。注意这里的 `i+4`# 原理：我们的自定义主干会输出多个特征图，为了给这些特征图在内部留出索引位置（0,1,2,3），# 我们将主干模块本身的索引号人为地增加，例如 `0 -> 4`。# 这样，后续Neck部分的层索引就不会与Backbone的输出索引冲突。# 4是一个经验值，通常主干输出P2-P5四层特征，但只要比主干输出层数多即可。m_.i, m_.f, m_.type = i + 4 if is_backbone else i, f, t  # attach index, 'from' index, typeif verbose:LOGGER.info(f'{i:>3}{str(f):>20}{n_:>3}{m_.np:10.0f}  {t:<45}{str(args):<30}')  # print# 将需要保存的层的索引添加到 savelist。同样，对主干索引进行偏移。save.extend(x % (i + 4 if is_backbone else i) for x in ([f] if isinstance(f, int) else f) if x != -1)# --- 步骤 3: 追踪通道数 ---if i == 0:ch = []# 关键修改！if isinstance(c2, list):# 如果 c2 是列表 (我们的主干)，则用 extend 将所有输出通道加入 ch 列表ch.extend(c2)# 补位操作：确保 ch 列表的长度至少为5。# 目的：为了与 `_predict_once` 中的逻辑对齐，方便通过索引访问不同尺度的特征。# 即使某个主干不输出P1, P2层，也用0占位，避免索引错误。for _ in range(5 - len(ch)):ch.insert(0, 0)else:# 如果是标准层，按原逻辑 append 单个输出通道ch.append(c2)# ==============================================================

④ 核心改造二：_predict_once函数

这个函数负责执行模型的前向传播。我们需要修改它，以便能正确处理我们标记了backbone=True的特殊模块。

原代码:

    def _predict_once(self, x, profile=False, visualize=False, embed=None):y, dt, embeddings = [], [], []  # outputsfor m in self.model:if m.f != -1:  # if not from previous layerx = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layersif profile:self._profile_one_layer(m, x, dt)x = m(x)  # runy.append(x if m.i in self.save else None)  # save output# ... 省略 visualize 和 embed 的代码 ...return x

修改后代码：

    def _predict_once(self, x, profile=False, visualize=False, embed=None):y, dt, embeddings = [], [], []  # outputsfor m in self.model:if m.f != -1:  # if not from previous layerx = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layersif profile:self._profile_one_layer(m, x, dt)# ==================== 自定义主干前向传播逻辑 ====================# 原理：检查在 parse_model 中添加的 'backbone' 标记。if hasattr(m, 'backbone'):# 如果是主干模块，直接调用它，它会返回一个特征图列表x = m(x)# 补位操作，与 parse_model 中的逻辑对应。# 目的：确保输出列表 x 的长度固定，即使主干输出的特征图数量不同，# 后续的层可以通过固定的索引（如 y[4]）来获取特征。for _ in range(5 - len(x)):x.insert(0, None) # 用 None 填充不存在的低层特征# 遍历主干输出的每一层特征图for i_idx, i in enumerate(x):# 根据 savelist 判断这一层是否需要保存给后续层使用if i_idx in self.save:y.append(i)else:y.append(None) # 如果不需要，用 None 占位# 将主干的最后一层输出作为下一个模块的输入x = x[-1]else:# 如果是标准层，执行原有的逻辑x = m(x)  # runy.append(x if m.i in self.save else None)  # save output# ==============================================================if visualize:feature_visualization(x, m.type, m.i, save_dir=visualize)if embed and m.i in embed:# ... (省略)return x

如此修改后，模型的网络结构就会发生变化：

---

四、颈部（Neck）的替换

我们已经成功地改造了tasks.py，建立了一个强大的、可兼容自定义主干的框架。现在，我们将利用这个框架，对模型的“颈部”进行替换。

1-GFPN (GiraffeDet FPN)

GFPN（长颈鹿特征金字塔网络）通过其独特的、类似长颈鹿脖子的交错连接方式，高效地融合深层语义信息和浅层空间信息。我们将用它来替换YOLOv8原生的PANet结构。

① 文件准备与引用（此步骤与之前一致）

1. 代码：Neck-GFPN.py -> new_modules/GFPN.py
2. 配置：GFPN-P345.yaml -> cfg/models/v8/
3. 引用：在 tasks.py 中添加 from .new_modules.GFPN import *

② GFPN的YAML配置与parse_model的联动

思考：GFPN是如何被我们的新parse_model函数解析的？

让我们深入GFPN-P345.yaml和tasks.py的代码；。

• 第一步：分析GFPN-P345.yaml的配置

  打开GFPN-P345.yaml，你会发现它巧妙地使用变量来定义网络结构，这是一种非常优雅的工程实践。

  # ultralytics/cfg/models/v8/GFPN-P345.yaml (内容示例)# ------------------ YAML 顶层参数定义 ------------------
  # 定义了颈部和头部的默认通道数
  widen_factor: 1.0
  head_channel: 256# 核心：定义了颈部中重复使用的核心模块的名称
  # 这样做的好处是，如果想把所有 CSPStage 换成其他模块，
  # 只需修改下面这一行，无需改动 head 中的每一处。
  node_mode: CSPStage# ... (nc, depth_multiple, width_multiple 等定义)# ------------------ Backbone (主干) ------------------
  backbone:- [-1, 1, Conv, [64, 3, 2]]              # 0-P1/2# ... (主干网络定义，这里可能是标准的YOLOv8主干，也可能是我们之前替换的RepViT等)# 假设主干的第4、6、9层分别输出P3, P4, P5 特征# ------------------ Head (颈部 + 头部) ------------------
  head:# in_channels: [256, 512, 1024] # 来自Backbone的 P3, P4, P5# out_channels: [256, 512, 1024]# --- GFPN 颈部结构 ---- [-1, 1, Conv, [256, 1, 1]]              # 10- [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 11- [[-1, 6], 1, Concat, [1]]               # 12 (Concat P4)- [-1, 3, node_mode, [head_channel, 3]]   # 13 <--- 关键！使用了node_mode- [-1, 1, Conv, [256, 1, 1]]              # 14- [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 15- [[-1, 4], 1, Concat, [1]]               # 16 (Concat P3)- [-1, 3, node_mode, [head_channel, 3]]   # 17 <--- 关键！使用了node_mode- [-1, 1, Conv, [256, 3, 2]]              # 18- [[-1, 14], 1, Concat, [1]]              # 19- [-1, 3, node_mode, [head_channel, 3]]   # 20 <--- 关键！使用了node_mode- [-1, 1, Conv, [256, 3, 2]]              # 21- [[-1, 10], 1, Concat, [1]]              # 22- [-1, 3, node_mode, [head_channel, 3]]   # 23 <--- 关键！使用了node_mode# --- Detect Head ---- [[17, 20, 23], 1, Detect, [nc]]        # Detect(P3, P4, P5)
  

• 第二步：追踪parse_model的执行流程

  当parse_model函数解析到第13层 [-1, 3, node_mode, [head_channel, 3]] 时，我们之前修改的代码开始发挥作用：

  # 在 ultralytics/nn/tasks.py 的 parse_model 中# 此时，循环变量的值为:
  # i = 13, f = -1, n = 3, m = 'node_mode', args = ['head_channel', 3]try:# 1. 检查到 m == 'node_mode'，条件成立if m == 'node_mode':# 2. 将 m 的值从字符串 'node_mode' 替换为 YAML 顶层定义的实际值# m = d['node_mode']  -->  m 变成了 'CSPStage'm = d[m]# 3. 检查 args 列表if len(args) > 0: # len(['head_channel', 3]) > 0, 成立# 4. 检查第一个参数是否为 'head_channel'if args[0] == 'head_channel': # 成立# 5. 将 args[0] 从字符串 'head_channel' 替换为 YAML 顶层定义的实际值# args[0] = int(d['head_channel']) --> args[0] 变成了整数 256args[0] = int(d[args[0]])# 经过处理后，模块定义从 'node_mode', ['head_channel', 3]# 变成了实际的 'CSPStage', [256, 3]t = m # t 被赋值为 'CSPStage'# 6. 最后，通过 globals()['CSPStage'] 找到我们导入的 CSPStage 类m = getattr(torch.nn, m[3:]) if 'nn.' in m else globals()[m]
  except:pass
  # ... 后续代码将使用 m = CSPStage 类, args = [256, 3] 来实例化模块
  

  结论：我们为parse_model添加的try-except和if m == 'node_mode'逻辑，本质上是创建了一个“宏替换”机制。它使得YAML的编写者可以像定义宏一样预设模块名和参数，极大地增强了配置文件的灵活性和复用性。

③ 魔改前后模型参数对比

我们可以通过打印模型结构来直观地看到变化。

魔改前模型结构 (标准 YOLOv8 Neck)

    # yolov8.yaml summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs... (backbone)10  -1  1  ultralytics.nn.modules.conv.Conv         [512, 1, 1]11  -1  1  torch.nn.modules.upsampling.Upsample     [None, 2, 'nearest']12  [-1, 6]  1  ultralytics.nn.modules.container.Concat  [1]13  -1  3  ultralytics.nn.modules.block.C2f         [512, True]14  -1  1  ultralytics.nn.modules.conv.Conv         [256, 1, 1]15  -1  1  torch.nn.modules.upsampling.Upsample     [None, 2, 'nearest']16  [-1, 4]  1  ultralytics.nn.modules.container.Concat  [1]17  -1  3  ultralytics.nn.modules.block.C2f         [256, True]18  -1  1  ultralytics.nn.modules.conv.Conv         [256, 3, 2]19  [-1, 14] 1  ultralytics.nn.modules.container.Concat  [1]20  -1  3  ultralytics.nn.modules.block.C2f         [512, True]21  -1  1  ultralytics.nn.modules.conv.Conv         [512, 3, 2]22  [-1, 10] 1  ultralytics.nn.modules.container.Concat  [1]23  -1  3  ultralytics.nn.modules.block.C2f         [1024, True]24  [17, 20, 23] 1 ultralytics.nn.modules.head.Detect [80]

魔改后模型结构 (GFPN-P345 Neck)

    # GFPN-P345.yaml summary: 237 layers, 3348644 parameters, 3348628 gradients, 9.2 GFLOPs... (backbone)10  -1  1  ultralytics.nn.modules.conv.Conv         [256, 1, 1]11  -1  1  torch.nn.modules.upsampling.Upsample     [None, 2, 'nearest']12  [-1, 6]  1  ultralytics.nn.modules.container.Concat  [1]13  -1  3  new_modules.GFPN.CSPStage                [256, 3]  # <-- 核心模块被替换14  -1  1  ultralytics.nn.modules.conv.Conv         [256, 1, 1]15  -1  1  torch.nn.modules.upsampling.Upsample     [None, 2, 'nearest']16  [-1, 4]  1  ultralytics.nn.modules.container.Concat  [1]17  -1  3  new_modules.GFPN.CSPStage                [256, 3]  # <-- 核心模块被替换18  -1  1  ultralytics.nn.modules.conv.Conv         [256, 3, 2]19  [-1, 14] 1  ultralytics.nn.modules.container.Concat  [1]20  -1  3  new_modules.GFPN.CSPStage                [512, 3]  # <-- 核心模块被替换21  -1  1  ultralytics.nn.modules.conv.Conv         [512, 3, 2]22  [-1, 10] 1  ultralytics.nn.modules.container.Concat  [1]23  -1  3  new_modules.GFPN.CSPStage                [1024, 3] # <-- 核心模块被替换24  [17, 20, 23] 1 ultralytics.nn.modules.head.Detect [80]

通过对比可以清晰地看到，原生的C2f模块被我们自定义的CSPStage（来自GFPN.py）所取代，这证明我们的魔改成功了。

---

五、头部（Head）的革新

1-DyHead (Dynamic Head)

DyHead通过统一的注意力机制，动态地选择最重要的特征，极大地提升了检测头的表征能力。

① 文件准备与引用（同上）

1. 代码: Head-DyHead.py -> new_modules/DyHead.py
2. 配置: DyHead-P345.yaml -> cfg/models/v8/
3. 引用: tasks.py 中添加 from .new_modules.DyHead import *

② 核心解析：DyHead的“无缝”集成

思考：DyHead为什么不需要对tasks.py做任何新的修改？

答案在于，DyHead的设计模式与YOLO原生Detect头高度兼容，并且我们之前对parse_model的通用化改造已经能够处理它。

第一步：分析DyHead-P345.yaml的结构
DyHead模块将替换掉原Detect层以及之前的一些卷积层。

    # DyHead-P345.yaml (head部分示例)head:# ... (颈部融合层)# 假设颈部输出三层特征分别在索引 17, 20, 23# 原生YOLOv8中，这里会有一系列解耦的卷积层，最后连接Detect层# 使用DyHead后，直接将三层特征输入给DyHead模块- [[17, 20, 23], 1, DyHead, [nc]] # <--- 直接替换

第二步：追踪_predict_once的执行流程
当模型前向传播到DyHead层时：

    # 在 ultralytics/nn/tasks.py 的 _predict_once 中# 此时，m 是实例化的 DyHead 对象，m.f 是 [17, 20, 23]# 1. 进入获取输入的逻辑if m.f != -1:  # 成立# 2. m.f 是一个列表, 执行 else 分支#    这行代码会从 y 列表中，根据索引 17, 20, 23,#    取出对应的三层特征图张量，并打包成一个新的列表 `x`#    x = [y[17], y[20], y[23]]x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]# 3. 检查 'backbone' 属性, DyHead没有这个标记, 跳过if hasattr(m, 'backbone'):...else:# 4. 执行常规的前向传播#    将包含三个特征图的列表 x, 整体传递给 DyHead 模块#    x = m(x)  等价于  outputs = dyhead_instance([feature_p3, feature_p4, feature_p5])x = m(x)y.append(x if m.i in self.save else None)

结论：DyHead模块本身被设计为接收一个特征图列表作为输入。而YOLO的_predict_once函数中，处理多输入的from（如[-1, 6]或[17, 20, 23]）的逻辑，天然地就会将多个来源的特征图打包成一个列表。两者一拍即合，实现了无缝对接。我们不需要为DyHead编写任何特殊的解析或执行代码。

---

六、注意力机制（Attention）的融合

欢迎来到“魔改”系列中最灵活、最有趣的部分——集成注意力机制。

核心思想与类比：想象一下，当您在一张杂乱的桌面上寻找钥匙时，您的大脑并不会平均地扫描每一个平方厘米。相反，您的目光会自动聚焦于桌面上的高亮区域，比如金属反光处、颜色鲜艳的物体旁。注意力机制（Attention Mechanism）赋予了神经网络类似的能力。它让模型在处理海量信息时，能够智能地“聚焦”于最关键的特征，并“忽略”次要或无关的背景，从而用有限的计算资源做出更精准的判断。

本节，我们将以CBAM (Convolutional Block Attention Module) 为例，进行一次完整、详尽的“即插即用”式集成。我们将一起分析其代码原理，选择合适的插入位置，完成一次无死角的YAML文件修改，并最终验证我们的工作。

1. 深入理解CBAM模块

在动手之前，我们先快速理解CBAM的工作原理，这将有助于我们决定将它放在网络中的哪个位置。

CBAM由两个串联的子模块组成：

1. 通道注意力模块 (Channel Attention)：它回答的问题是“什么特征更重要？”。比如，在一个人像识别任务中，包含“眼睛”、“鼻子”等信息的特征通道，其重要性就应该高于包含“背景墙壁”信息的通道。该模块会学习一个权重，对各个通道进行加权，增强重要特征，抑制次要特征。
2. 空间注意力模块 (Spatial Attention)：它回答的问题是“特征图的哪个位置更重要？”。在识别出一张人脸后，其五官所在的位置显然比背景区域更关键。该模块会生成一个空间“热力图”，告诉网络应该重点关注特征图上的哪些像素区域。

最重要的特性：CBAM模块的forward函数接收一个张量x，经过内部一系列计算后，输出一个与x 尺寸完全相同 的张量。这正是它能被“即插即用”的关键。

2. 集成CBAM

① 准备工作

1. 代码: 将 yolo_master/.../Attention-CBAM.py 复制到 ultralytics/ultralytics/nn/new_modules/ 并重命名为 CBAM.py。
2. 引用: 在 ultralytics/nn/tasks.py 的顶部添加 from .new_modules.CBAM import *。

② CBAM应该放在哪里？

这是一个开放性问题，但有一些常用的策略：

• 放在特征提取之后：通常将注意力模块放置在核心特征提取块（如C2f）之后。这样做的好处是，C2f已经产生了丰富的特征组合，此时使用CBAM可以立刻对这些新特征进行“精炼”和“筛选”，让最有用的信息传递给下一层。
• 放在下采样之前：在网络通过步进卷积（Conv）进行下采样、缩小特征图尺寸之前，使用CBAM可以确保在信息被压缩前，关键特征已经被充分“关注”，减少重要信息的丢失。

本教程决策：我们将遵循以上策略，选择在Backbone的第4个模块（一个C2f层）之后，第5个模块（一个Conv下采样层）之前插入CBAM。这个位置非常理想，它能精炼P3级别的特征，再将其传递给更深的网络。

③ YAML修改

这是最关键的一步。我们将以yolov8n.yaml为蓝本，创建yolov8n-CBAM.yaml。

• 第一步：复制并重命名yolov8n.yaml为yolov8n-CBAM.yaml。

• 第二步：进行修改。 下面是完整的修改前后对比，所有改动都用注释明确标出。

yolov8n.yaml (原始文件)

# ultralytics/cfg/models/v8/yolov8n.yamlnc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple# anchors
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# YOLOv8.0n backbone
backbone:# [from, number, module, args]- [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2- [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4- [-1, 3, C2f, [128, True]]  # 2- [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8- [-1, 6, C2f, [256, True]]  # 4- [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16- [-1, 6, C2f, [512, True]]  # 6- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32- [-1, 3, C2f, [1024, True]] # 8- [-1, 1, SPPF, [1024, 5]]   # 9# YOLOv8.0n head
head:- [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 10- [[-1, 6], 1, Concat, [1]]  # 11- [-1, 3, C2f, [512, False]] # 12- [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 13- [[-1, 4], 1, Concat, [1]]  # 14- [-1, 3, C2f, [256, False]] # 15- [-1, 1, Conv, [256, 3, 2]] # 16- [[-1, 12], 1, Concat, [1]] # 17- [-1, 3, C2f, [512, False]] # 18- [-1, 1, Conv, [512, 3, 2]] # 19- [[-1, 9], 1, Concat, [1]]  # 20- [-1, 3, C2f, [1024, False]]# 21- [[15, 18, 21], 1, Detect, [nc]]  # Detect(P3, P4, P5)

yolov8n-CBAM.yaml (修改后的文件)

# ultralytics/cfg/models/v8/yolov8n-CBAM.yaml# ... (nc, depth_multiple, width_multiple, anchors 定义与上面完全相同) ...# YOLOv8.0n backbone with CBAM
backbone:# [from, number, module, args]- [-1, 1, Conv, [64, 3, 2]]      # 0- [-1, 1, Conv, [128, 3, 2]]     # 1- [-1, 3, C2f, [128, True]]      # 2- [-1, 1, Conv, [256, 3, 2]]     # 3- [-1, 6, C2f, [256, True]]      # 4- [-1, 1, CBAM, [256]]           # 5  <--- 新增CBAM层. 它接收第4层的256通道输出- [-1, 1, Conv, [512, 3, 2]]     # 6 (原索引为5)- [-1, 6, C2f, [512, True]]      # 7 (原索引为6)- [-1, 1, Conv, [1024, 3, 2]]    # 8 (原索引为7)- [-1, 3, C2f, [1024, True]]     # 9 (原索引为8)- [-1, 1, SPPF, [1024, 5]]       # 10 (原索引为9)# YOLOv8.0n head with updated indices
head:- [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 11# Concat 融合 Neck P5 和 Backbone P4. Backbone P4 现在是第7层- [[-1, 7], 1, Concat, [1]]      # 12 (原为[-1, 6]) <--- 索引更新!- [-1, 3, C2f, [512, False]]     # 13- [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 14# Concat 融合 Neck P4 和 Backbone P3. Backbone P3 的输出现在经过了第4层的C2f和第5层的CBAM，所以我们从第5层引出- [[-1, 5], 1, Concat, [1]]      # 15 (原为[-1, 4]) <--- 索引更新!- [-1, 3, C2f, [256, False]]     # 16- [-1, 1, Conv, [256, 3, 2]]     # 17# Concat 融合 Neck P3 和 Neck P4(第13层)- [[-1, 13], 1, Concat, [1]]     # 18 (原为[-1, 12]) <--- 索引更新!- [-1, 3, C2f, [512, False]]     # 19- [-1, 1, Conv, [512, 3, 2]]     # 20# Concat 融合 Neck P4 和 Backbone P5(第10层)- [[-1, 10], 1, Concat, [1]]     # 21 (原为[-1, 9]) <--- 索引更新!- [-1, 3, C2f, [1024, False]]    # 22# Detect 层的输入来自第16, 19, 22层- [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5) (原为[15, 18, 21]) <--- 索引更新!

(4) 追踪parse_model如何处理CBAM

让我们看看parse_model解析新增的第5层[-1, 1, CBAM, [256]]时，发生了什么。

1. 确定输入通道 c1：from是-1，所以 c1 来自上一层（第4层）的输出。我们知道第4层C2f的输出通道是256，所以 c1 = 256。
2. 确定模块 m：m 是我们导入的 CBAM 类。
3. 确定参数 args：args 是列表 [256]。
4. 实例化模块 m_：对于CBAM这样的通用模块，parse_model会执行 m(c1, *args) 来实例化。这会调用 CBAM(256, 256)。
5. 确定输出通道 c2：对于通用模块，parse_model会默认将args[0]作为输出通道数，即c2 = 256。
6. 更新通道列表 ch：执行 ch.append(c2)，将256添加到通道列表中。

结论：由于CBAM输入和输出通道数相同（c1=c2=256），它完美地融入了网络的数据流，对后续层的通道数计算没有任何影响。唯一的、也是最容易出错的复杂性，在于手动更新所有后续层（尤其是Concat和Detect层）的from索引。

(5) 可视化对比：魔改前后的模型结构

下面是模拟model.info()命令输出的文本，可以清晰地看到变化。
魔改前模型结构 (yolov8n.yaml)

      # ... (层 0-3)4  -1  6       ultralytics.nn.modules.block.C2f  119296    (256, 128, 6, True, False, 1, 0.5)5  -1  1       ultralytics.nn.modules.conv.Conv  147968    (512, 256, 3, 2)6  -1  6       ultralytics.nn.modules.block.C2f  476160    (512, 256, 6, True, False, 1, 0.5)# ...11  [-1, 6]  1  ultralytics.nn.modules.container.Concat  0         (1)# ...14  [-1, 4]  1  ultralytics.nn.modules.container.Concat  0         (1)# ...22  [15, 18, 21]  1  ultralytics.nn.modules.head.Detect  649920    (80, (256, 512, 1024))

魔改后模型结构 (yolov8n-CBAM.yaml)

      # ... (层 0-3)4  -1  6       ultralytics.nn.modules.block.C2f  119296    (256, 128, 6, True, False, 1, 0.5)+  5  -1  1            new_modules.CBAM.CBAM  704       (256, None) # <--- 新增层，参数量极小6  -1  1       ultralytics.nn.modules.conv.Conv  147968    (512, 256, 3, 2)7  -1  6       ultralytics.nn.modules.block.C2f  476160    (512, 256, 6, True, False, 1, 0.5)# ...- 11  [-1, 6]  1  ultralytics.nn.modules.container.Concat  0         (1)+ 12  [-1, 7]  1  ultralytics.nn.modules.container.Concat  0         (1) # <--- 索引更新# ...- 14  [-1, 4]  1  ultralytics.nn.modules.container.Concat  0         (1)+ 15  [-1, 5]  1  ultralytics.nn.modules.container.Concat  0         (1) # <--- 索引更新# ...- 22  [15, 18, 21]  1  ultralytics.nn.modules.head.Detect  649920    (80, (256, 512, 1024))+ 23  [16, 19, 22]  1  ultralytics.nn.modules.head.Detect  649920    (80, (256, 512, 1024)) # <--- 索引更新

通过这个对比，我们可以百分之百地确认，我们的CBAM模块已成功插入，并且整个模型的后续连接也已正确更新。对于SE模块的集成，过程与此完全相同，不再赘述。

---

七、核心组件的优化

在掌握了对Backbone、Neck、Head三大件的“大刀阔斧”式改造后，我们再来学习如何对网络中的基础“零件”——如上下采样和卷积模块——进行“精雕细琢”的单元。这要求我们更深入地理解YOLO的parse_model函数是如何处理标准模块的。

1. 上下采样模块：EUCB (Efficient Up-sampling with Channel Balancing)

背景与目的：在特征金字塔网络（FPN）中，上采样负责将高层（小尺寸、强语义）的特征图放大，以便与低层（大尺寸、强细节）的特征图融合。YOLOv8默认使用的nn.Upsample（配合mode='nearest'）虽然速度极快，但它是一种固定的、非学习性的插值方法，仅仅是简单地复制像素，可能会在放大过程中产生伪影或丢失细节。

EUCB (Efficient Up-sampling with Channel Balancing) 旨在解决这个问题。它是一种可学习的上采样模块。这意味着网络可以通过反向传播，学习到如何以最优的方式从低分辨率特征中“生成”高分辨率特征，同时还能调整通道数量，从而可能带来更平滑、更有效的特征融合效果。

① 集成步骤

1. 代码: 将 yolo_master/.../Upsample-EUCB.py 复制到 ultralytics/ultralytics/nn/new_modules/ 并重命名为 EUCB.py。
2. 引用: 在tasks.py的顶部添加 from .new_modules.EUCB import *。

② 核心解析：EUCB的参数与parse_model的自动适配

思考：nn.Upsample 和 EUCB 在参数上有何不同？parse_model如何处理这种不同？

• 第一步：分析模块的__init__签名

  • torch.nn.Upsample的定义很简单，它只关心缩放因子和模式，不改变通道数。其YAML中的args为 [None, 2, 'nearest']，None代表输出尺寸（由scale_factor=2决定），通道数保持不变。

  • 我们打开new_modules/EUCB.py文件（或根据其用法推断），可以发现EUCB模块的定义更像一个卷积层。一个合理的__init__签名应该是：def __init__(self, c1, c2, scale_factor=2):。

    • c1: 输入通道数。
    • c2: 输出通道数。这是与nn.Upsample最大的不同。
    • scale_factor: 缩放因子。

• 第二步：修改YAML文件并追踪解析过程

  现在，我们在yolov8.yaml的head部分进行替换。

  # yolov8-EUCB.yaml (head 部分示例)head:# ...# 假设解析到第14层，其输入来自第13层(C2f)，输出通道数为512# ch = [..., 512]# 第15层: 上采样层# --- 原代码 ---# - [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 15# --- 修改后 ---# 我们希望上采样后，通道数从512变为256- [-1, 1, EUCB, [256, 2]] # 15. args为[输出通道数, 缩放因子]# 第16层: Concat层# 它的输入来自上一层(第15层)和主干的第4层 (假设通道数为256)- [[-1, 4], 1, Concat, [1]] # 16# 第17层: C2f层# 它的输入来自第16层的Concat。Concat后的通道数 = 256(来自EUCB) + 256(来自Backbone) = 512- [-1, 3, C2f, [256, False]] # 17. 该C2f层输出通道数为256# ...
  

  当parse_model解析到我们修改的第15层 [-1, 1, EUCB, [256, 2]] 时，其标准模块处理逻辑会执行以下操作：

  # 在 ultralytics/nn/tasks.py 的 parse_model 中# 此时: m = EUCB 类, args = [256, 2]
  # 假设上一层的输出通道数 ch[-1] 是 512# 1. 获取输入通道数 c1
  # c1 = ch[f] --> c1 = ch[-1] --> c1 = 512
  c1 = ch[f]# 2. 获取输出通道数 c2
  # c2 = args[0] if isinstance(args[0], int) else ...
  # 这里的 args[0] 是 256, 是整数。所以 c2 被赋值为 256
  c2 = args[0] # 3. 实例化模块
  # m_ = m(*args) 等价于 m_ = EUCB(512, 256, 2)
  # 注意！这里的`*args`展开会把所有参数传进去，所以我们的模块定义要与之匹配
  # 一个更严谨的写法是在YAML中只写输出通道数，让模块内部处理
  # 假设YAML为 [-1, 1, EUCB, [256]]
  # 那么实例化将是 m_ = EUCB(c1, *args) --> EUCB(512, 256)
  m_ = nn.Sequential(...) if n > 1 else m(c1, *args) # 注意这里隐式的 c1 参数# 4. 更新通道列表 ch
  # ch.append(c2) --> ch.append(256)
  # 现在 ch 列表的最后一个元素是 256，供下一层使用
  ch.append(c2)
  

  结论：我们不需要为EUCB编写任何特殊解析代码。只要一个模块遵循“接收输入通道c1，并通过args接收其他参数（包括输出通道c2）”这一标准模式，parse_model的通用逻辑就能自动完成输入/输出通道的推断和模块的正确实例化。

③ 魔改前后模型结构对比

魔改前 (使用 nn.Upsample)

    # ...# 假设第14层输出512通道14 ... [..., 512, True]15  -1  1  torch.nn.modules.upsampling.Upsample     [None, 2, 'nearest']# 第15层输出通道仍为512# ...

魔改后 (使用 EUCB)

    # ...# 第14层输出512通道14 ... [..., 512, True]15  -1  1  new_modules.EUCB.EUCB                    [512, 256, 2]# 第15层输出通道变为256，参数量增加，因为它有可学习的权重# ...

2. 卷积模块：C2f_CMUNeXtBlock

这是对YOLOv8中最重要的特征提取单元C2f的直接替换。CMUNeXtBlock可能借鉴了ConvNeXt的设计，例如使用更大的卷积核、深度可分离卷积等，旨在用相似的参数量换取更强的特征表达能力。

① 集成步骤（同上）

1. 代码: C2f_CMUNeXtBlock.py -> new_modules/C2f_CMUNeXtBlock.py。
2. 引用: 在 tasks.py 中添加 from .new_modules.C2f_CMUNeXtBlock import *。

② 实现“无痛”替换

思考：为什么C2f_CMUNeXtBlock可以如此轻易地替换C2f？

答案在于接口兼容性。C2f_CMUNeXtBlock在设计时，刻意模仿了C2f的__init__参数签名，使得它可以直接使用C2f在YAML文件中的参数定义。

• 第一步：对比__init__签名

  • C2f的签名（简化后）：__init__(self, c1, c2, n=1, shortcut=False, ...)
  • C2f_CMUNeXtBlock的签名（推断）：__init__(self, c1, c2, n=1, shortcut=False, ...)

  只要两者都接收相同的核心参数（输入通道c1，输出通道c2，重复次数n，快捷连接shortcut），它们在YAML层面就是可互换的。

• 第二步：修改YAML
  这个修改是最简单的，只需更换模块名即可。

  # yolov8-CMUNeXt.yaml (backbone 部分示例)backbone:- [-1, 1, Conv, [64, 3, 2]]  # 0- [-1, 1, Conv, [128, 3, 2]]  # 1# --- 原代码 ---# - [-1, 3, C2f, [128, True]]  # 2# --- 修改后 ---- [-1, 3, C2f_CMUNeXtBlock, [128, True]] # 2. 参数完全相同！
  

• 第三步：追踪parse_model的执行流程
  这个流程与解析C2f时完全一样。

  1. parse_model获取模块名C2f_CMUNeXtBlock。
  2. 它从ch列表获取输入通道c1。
  3. 它从args（[128, True]）中获取输出通道c2=128以及其他参数。
  4. 它根据n=3，循环3次来实例化模块。
  5. 它将输出通道c2=128添加到ch列表中。
     整个过程行云流水，因为C2f_CMUNeXtBlock完美地扮演了C2f的角色。

结论：对于想要替换现有标准模块的自定义模块，最佳实践就是让新模块的参数接口与旧模块保持高度一致。这样就能实现“无痛”替换，将修改成本降至最低，仅需更改YAML中的一个字符串。

---

OK，今天我们就学习到这里🏆🎉👌！

---

文章参考

• YOLO系列官方论文：
  • YOLOv8 by Ultralytics
  • YOLOv1: You Only Look Once: Unified, Real-Time Object Detection
• 核心项目与代码：
  • YOLO Master GitHub by DataWhale
  • Ultralytics YOLOv8 Documentation

---

拓展阅读

• Ultralytics GitHub 仓库 (YOLOv3/v5/v8 的主流实现)
• 作者的算法专栏 (包含更多YOLO技术文章)

---

💖 感谢您的耐心阅读！

如果您觉得本文对您理解和实践YOLO模型改造有所帮助，请考虑点赞、收藏或分享给更多有需要的朋友。您的支持是我持续创作优质内容的动力！欢迎在评论区交流讨论，共同进步。