YOLOv9【第四章：训练调参与性能优化篇·第8节】YOLOv9 断点续训 resume 与 last.pt、best.pt 管理！

🏆 本文收录于 《YOLOv9实战：从入门到深度优化》 专栏。

该专栏系统复现并深度梳理全网主流 YOLOv9 改进方法与工程实战案例，覆盖分类、目标检测、实例分割、多目标追踪、关键点检测、旋转目标检测等多个方向，坚持 持续更新 + 深度解析 + 工程验证。

专栏将围绕 YOLOv9 的网络结构、训练策略、损失函数、数据增强、模型压缩、推理加速与部署落地等内容展开，重点分析 Programmable Gradient Information（PGI）、GELAN 等核心设计思想，并结合实际项目讲解其改进方式与应用价值。

部分章节还会结合国内外前沿论文与 AIGC 大模型技术，对主流改进方案进行重构与再设计，使内容更加贴近真实业务场景，适合希望深入研究 YOLOv9 或具有工程落地需求的开发者学习与参考。

🎯限时特惠：当前活动一折秒杀，一次订阅，终身有效，后续所有更新章节全部免费解锁 👉 传送门 👈️   🎉本专栏还不够过瘾？别急，好戏才刚刚开始！我已经为你准备了一整套 YOLO 进阶实战大礼包🎁：

👉《YOLOv8实战》 👉《YOLOv9实战》 👉《YOLOv10实战》 👉《YOLOv11实战》 👉《YOLOv12实战》 👉以及最新上线的 《YOLOv26实战》

想一次搞定所有版本？直接冲 《YOLO全栈实战合集》，一站式涵盖 YOLO 各版本实战教学！

🚀想学哪个版本？直接找 bug 菌“许愿”，安排！必须安排！🚀

🎯 本文定位：计算机视觉 × YOLOv9 训练调参与性能优化篇 📅 预计阅读时间：约 45～60 分钟 🏷️ 难度等级：⭐⭐⭐☆☆（进阶级） 🔧 技术栈：Python 3.9+ · PyTorch 2.0+ · YOLOv9 · ByteTrack · OpenCV · NumPy

全文目录：

• • 📖 上期回顾
  • 🎯 本节主题：YOLOv9 断点续训 resume 与 last.pt、best.pt 管理
  • • 一、理解 YOLOv9 的权重保存机制
    • • 1.1 PyTorch 检查点（Checkpoint）的本质
      • 1.2 last.pt 与 best.pt 的区别
      • 1.3 权重文件的目录结构
    • 二、断点续训的正确姿势
    • • 2.1 最简单的续训命令
      • 2.2 续训参数恢复的内部机制
      • 2.3 续训时的特殊情况处理
    • 三、权重文件管理的工程实践
    • • 3.1 实验命名规范
      • 3.2 定期备份策略
      • 3.3 实验管理数据库
    • 四、深入理解 EMA 与 best.pt 的关系
    • • 4.1 什么是 EMA
      • 4.2 EMA 对续训的影响
      • 4.3 best.pt 的选取逻辑详解
    • 五、常见的续训陷阱与解决方案
    • • 5.1 陷阱一：学习率调度的续训问题
      • 5.2 陷阱二：–resume 路径中包含空格或特殊字符
      • 5.3 陷阱三：多次实验导致 exp 目录混乱
      • 5.4 陷阱四：在云平台上续训时的路径问题
    • 六、权重文件的加载与使用
    • • 6.1 推理时加载 best.pt
      • 6.2 比较 last.pt 与 best.pt 的性能
    • 七、断点续训的完整工作流
    • 八、自动化续训脚本：应对云平台限时中断
    • 九、完整知识体系总结
    • 十、本节实践清单
  • 🔮 下期预告
  • 📌 附录
  • 🧧🧧 文末福利，等你来拿！🧧🧧
  • 🫵 Who am I?

写在前面：如果你曾经在服务器上跑了整整一夜的训练，结果早上来发现进程被意外Kill掉，那种感觉真的是——心如死灰。或者你在 Colab 上训练，免费额度用完了，任务强制中断，几个小时的计算就这么没了。断点续训这个功能，就是专门为我们这些"踩过坑"的人设计的。这一节，我们把这个问题彻底讲透。

📖 上期回顾

在上期《YOLOv9【第四章：训练调参与性能优化篇·第7节】从零训练 vs 预训练微调——不同数据规模下的选择策略！》内容中，我们深入探讨了从零训练 vs 预训练微调：不同数据规模下的选择策略，这是一个在实际项目中极其重要、却经常被新手忽视的决策问题。

我们从数据量的角度出发，建立了一套系统性的判断框架：

核心结论回顾：

当你面对一个新的目标检测任务时，数据规模是第一决策变量。我们给出了三个典型区间：

• 小数据集（< 1000张）：几乎没有选择余地，必须使用预训练微调。从零训练不仅收敛困难，过拟合风险极高，模型最终在验证集上的表现往往惨不忍睹。这种情况下，COCO预训练权重就是你的"救命稻草"，它携带了大量通用视觉特征，只需要在最后几层做领域适配即可。

• 中等数据集（1000～10000张）：这是一个"两可"区间，但我们的建议仍然是优先选择预训练微调。理由很简单：预训练起点更高，收敛更快，最终精度通常也更好。除非你的目标域与COCO差异极大（比如医学影像、卫星图像），否则迁移学习的正向效果是有据可查的。

• 大数据集（> 10000张，甚至百万级）：此时从零训练开始变得有意义。数据本身足以驱动模型学习到足够的特征表示，而且避免了预训练偏见。工业级大规模训练通常走这条路。

我们还深入分析了冻结层策略——在微调时，到底应该冻结哪些层、解冻哪些层，这不是一个拍脑袋的决定，而是有着清晰的梯度流动逻辑支撑的。Backbone的浅层学习的是边缘、纹理等低级特征，这些特征是高度通用的；深层和Head学习的是任务相关的高级语义，这才是微调的主战场。

此外，我们还讨论了学习率的继承问题：微调时的初始学习率应该比从零训练小一个数量级，否则预训练权重的精细结构会被"大步伐"的梯度更新直接破坏掉，这种破坏在损失曲线上会表现为训练初期剧烈震荡。

如果你对上一节的内容还有疑问，建议回头再巩固一下，因为"从哪里开始训练"和"如何管理训练进度"这两个问题是密切相关的——微调时你可能更希望保留某个精确时刻的权重，而不是简单地用最后一个epoch的结果。这，正是本节的主题。

🎯 本节主题：YOLOv9 断点续训 resume 与 last.pt、best.pt 管理

训练中断是工程实践中的常态，不是例外。电源故障、云平台超时、显存OOM崩溃、误操作Ctrl+C……各种原因都会打断你的训练进程。如何在中断后无缝恢复、如何管理训练过程中生成的权重文件，如何在多次实验中保留最有价值的检查点——这些都是本节要解决的实际问题。

一、理解 YOLOv9 的权重保存机制

在深入讲解断点续训之前，我们需要先搞清楚一个基础问题：YOLOv9在训练过程中究竟保存了什么？

很多人在刚上手YOLOv9时，对 runs/train/exp/weights/ 目录里的文件感到困惑——为什么只有 last.pt 和 best.pt？有时候还有 last_epoch_X.pt？这些文件有什么区别？哪个才是"真正好用"的权重？

让我们从源码层面理解这个问题。

1.1 PyTorch 检查点（Checkpoint）的本质

在 PyTorch 中，一个完整的训练检查点不仅仅包含模型权重，它是一个包含训练全状态的字典。YOLOv9沿用了这一机制，其保存的 .pt 文件本质上是一个 Python 字典，包含以下核心字段：

# YOLOv9 保存检查点时的核心逻辑（简化版）
checkpoint = {
'epoch': epoch, # 当前已完成的epoch数
'best_fitness': best_fitness, # 历史最佳fitness值
'model': deepcopy(de_parallel(model)).half(), # 模型权重（半精度）
'ema': deepcopy(ema.ema).half(), # EMA模型权重
'updates': ema.updates, # EMA更新次数
'optimizer': optimizer.state_dict(), # 优化器状态（含动量、自适应学习率等）
'opt': vars(opt), # 训练参数配置
'git': GIT_INFO, # git版本信息
'date': datetime.now().isoformat() # 保存时间
}
torch.save(checkpoint, last)

这里有几个细节非常重要，值得我们逐一分析：

'epoch' 字段：记录的是已完成的epoch索引。如果你训练了50个epoch后中断，这里存储的就是49（0-indexed）。续训时，程序会从第50个epoch开始，而不是重新从0开始。这是断点续训能够无缝衔接的关键之一。

'optimizer' 字段：这是很多人容易忽视的核心字段。优化器状态包含了每个参数的动量（momentum）和自适应学习率缩放因子（对于Adam/AdamW来说还有二阶矩估计）。如果续训时只恢复了模型权重而没有恢复优化器状态，那相当于优化器"失忆"了，它会把当前位置当作全新起点，动量信息清零，接下来几个epoch的训练会非常不稳定，损失可能出现明显的"跌落后回升"现象。

'ema' 字段：EMA（Exponential Moving Average，指数移动平均）是YOLOv9默认启用的一个技巧。它维护了一个"平滑版"的模型权重，通过对历史权重的加权平均来降低训练波动对最终模型的影响。EMA模型通常比"原始"模型在验证集上表现更稳定。best.pt 保存的正是EMA模型权重，而不是原始模型权重。这是一个常被忽视的细节，但它解释了为什么 best.pt 往往比 last.pt 在推理时表现更好。

'best_fitness' 字段：这是一个综合评分，用于判断当前保存的是不是"最佳"模型。YOLOv9中，fitness的计算公式为：

fitness = 0.1 * mAP@0.5 + 0.9 * mAP@0.5:0.95

这个加权设计体现了YOLOv9对严格IoU匹配的重视——它不满足于"大致对上"（mAP@0.5），而是追求精确定位（mAP@0.5:0.95）。每个epoch结束后，如果当前epoch的fitness超过历史最优，则更新 best.pt。

1.2 last.pt 与 best.pt 的区别

现在我们可以清晰地给出定义：

从这个角度理解，两个文件承担的职责是完全不同的：

• last.pt 是"进度存档"，保证你不会从零开始
• best.pt 是"成果存档"，保存你训练过程中最好的那个时刻

一个常见的误解是认为训练结束后 last.pt 就等于 best.pt。这是不对的。如果你的训练最后几个epoch出现了过拟合（验证集性能下滑），那么 last.pt 的性能反而不如中间某个epoch保存的 best.pt。

下图展示了两者的保存逻辑：

#mermaid-svg-LgzhbGQ4wUr6IV1H{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-LgzhbGQ4wUr6IV1H .error-icon{fill:#552222;}#mermaid-svg-LgzhbGQ4wUr6IV1H .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-LgzhbGQ4wUr6IV1H .marker{fill:#333333;stroke:#333333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .marker.cross{stroke:#333333;}#mermaid-svg-LgzhbGQ4wUr6IV1H svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-LgzhbGQ4wUr6IV1H p{margin:0;}#mermaid-svg-LgzhbGQ4wUr6IV1H .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .cluster-label text{fill:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .cluster-label span{color:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .cluster-label span p{background-color:transparent;}#mermaid-svg-LgzhbGQ4wUr6IV1H .label text,#mermaid-svg-LgzhbGQ4wUr6IV1H span{fill:#333;color:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .node rect,#mermaid-svg-LgzhbGQ4wUr6IV1H .node circle,#mermaid-svg-LgzhbGQ4wUr6IV1H .node ellipse,#mermaid-svg-LgzhbGQ4wUr6IV1H .node polygon,#mermaid-svg-LgzhbGQ4wUr6IV1H .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .rough-node .label text,#mermaid-svg-LgzhbGQ4wUr6IV1H .node .label text,#mermaid-svg-LgzhbGQ4wUr6IV1H .image-shape .label,#mermaid-svg-LgzhbGQ4wUr6IV1H .icon-shape .label{text-anchor:middle;}#mermaid-svg-LgzhbGQ4wUr6IV1H .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .rough-node .label,#mermaid-svg-LgzhbGQ4wUr6IV1H .node .label,#mermaid-svg-LgzhbGQ4wUr6IV1H .image-shape .label,#mermaid-svg-LgzhbGQ4wUr6IV1H .icon-shape .label{text-align:center;}#mermaid-svg-LgzhbGQ4wUr6IV1H .node.clickable{cursor:pointer;}#mermaid-svg-LgzhbGQ4wUr6IV1H .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .arrowheadPath{fill:#333333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LgzhbGQ4wUr6IV1H .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-LgzhbGQ4wUr6IV1H .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LgzhbGQ4wUr6IV1H .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-LgzhbGQ4wUr6IV1H .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .cluster text{fill:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H .cluster span{color:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-LgzhbGQ4wUr6IV1H .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-LgzhbGQ4wUr6IV1H rect.text{fill:none;stroke-width:0;}#mermaid-svg-LgzhbGQ4wUr6IV1H .icon-shape,#mermaid-svg-LgzhbGQ4wUr6IV1H .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LgzhbGQ4wUr6IV1H .icon-shape p,#mermaid-svg-LgzhbGQ4wUr6IV1H .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-LgzhbGQ4wUr6IV1H .icon-shape .label rect,#mermaid-svg-LgzhbGQ4wUr6IV1H .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LgzhbGQ4wUr6IV1H .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-LgzhbGQ4wUr6IV1H .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-LgzhbGQ4wUr6IV1H :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

否

是

开始训练 Epoch N

前向传播 + 反向传播

更新模型权重

更新EMA模型

Epoch结束，计算验证集指标

计算 fitness = 0.1×mAP50 + 0.9×mAP50-95

fitness > best_fitness?

更新 best_fitness保存 best.pt

跳过 best.pt 更新

保存 last.pt覆盖上一个last.pt

是否达到总Epochs?

训练结束

1.3 权重文件的目录结构

YOLOv9默认的权重保存路径遵循以下规则：

runs/
└── train/
├── exp/ # 第一次实验
│ ├── weights/
│ │ ├── last.pt # 最后一个epoch的完整状态
│ │ └── best.pt # 历史最佳fitness对应的模型
│ ├── results.csv # 每个epoch的详细指标
│ ├── hyp.yaml # 本次训练使用的超参数
│ ├── opt.yaml # 本次训练使用的命令行参数
│ └── …
├── exp2/ # 第二次实验（自动递增）
└── exp3/

这个自动递增的命名机制意味着：如果你不指定 –name 参数，每次运行 train.py 都会创建一个新的 expN 目录。断点续训时，你需要明确指向包含 last.pt 的那个具体目录。

二、断点续训的正确姿势

掌握了权重保存的内部机制后，我们来看断点续训的具体操作。

2.1 最简单的续训命令

YOLOv9提供了一个极其简洁的续训接口：

# 断点续训，只需要一个参数
python train.py —resume runs/train/exp/weights/last.pt

就这么简单。当你传入 –resume 参数时，YOLOv9会：

这里有一个值得注意的行为：续训时，你不需要也不应该重新指定其他训练参数（如 –batch-size、–img-size、–data 等）。为什么？因为这些参数都已经保存在 last.pt 的 'opt' 字段中了，续训时会自动读取。如果你在续训命令中再次指定这些参数，部分参数会被覆盖，可能导致训练不一致。

2.2 续训参数恢复的内部机制

让我们深入看看续训时的参数恢复逻辑：

# YOLOv9 train.py 中的 resume 处理逻辑（简化版）
def main(opt):
if opt.resume and not check_wandb_resume(opt):
# 找到 last.pt 的路径
ckpt = opt.resume if isinstance(opt.resume, str) else get_latest_run()
assert os.path.isfile(ckpt), 'ERROR: –resume checkpoint does not exist'

# 从检查点中读取原始训练参数
with open(Path(ckpt).parent.parent / 'opt.yaml', errors='ignore') as f:
opt = argparse.Namespace(**yaml.safe_load(f)) # 用保存的opt覆盖当前opt

# 强制设置 resume 和 weights 参数
opt.cfg, opt.weights, opt.resume = '', ckpt, True

LOGGER.info(f'Resuming training from {ckpt}')

从这段逻辑可以看出：续训时，程序实际上是读取了原始实验目录中保存的 opt.yaml 文件来恢复所有训练参数，然后只把 weights 替换为 last.pt 的路径。这保证了续训与原始训练的一致性。

2.3 续训时的特殊情况处理

情况一：想要增加总epoch数

假设你原计划训练100个epoch，但训到80个epoch时发现模型还在持续提升，想增加到200个epoch怎么办？

这种情况下，不能直接用 –resume，因为续训会读取原始的 –epochs 100 配置，到100个epoch就自动停止了。

正确做法是修改 opt.yaml 文件，然后再续训：

# 方法1：直接修改 opt.yaml 后续训
# 先编辑 runs/train/exp/opt.yaml，将 epochs: 100 改为 epochs: 200
vim runs/train/exp/opt.yaml

# 然后执行续训
python train.py –resume runs/train/exp/weights/last.pt

或者使用代码方式修改：

import yaml

# 修改 opt.yaml 中的 epochs 配置
opt_yaml_path = 'runs/train/exp/opt.yaml'

with open(opt_yaml_path, 'r') as f:
opt = yaml.safe_load(f)

print(f"原始 epochs 设置: {opt['epochs']}")
opt['epochs'] = 200 # 修改为新的目标epoch数
print(f"修改后 epochs 设置: {opt['epochs']}")

with open(opt_yaml_path, 'w') as f:
yaml.dump(opt, f, default_flow_style=False, allow_unicode=True)

print("opt.yaml 已更新，现在可以执行续训命令")

情况二：last.pt损坏或丢失

这是一个让人头疼的情况。有时候训练进程被强制终止恰好在写入 last.pt 的瞬间，导致文件损坏（大小为0或无法加载）。

YOLOv9有一个防护机制：在某些版本中，它会在保存 last.pt 之前先保存一个临时文件，完成后再重命名。但如果你的版本没有这个机制，可以考虑以下恢复策略：

import torch

def check_checkpoint_validity(ckpt_path):
"""
检查检查点文件的有效性
返回: (是否有效, 错误信息)
"""
try:
# 尝试加载检查点
ckpt = torch.load(ckpt_path, map_location='cpu')

# 检查必要字段是否存在
required_fields = ['epoch', 'model', 'optimizer']
missing_fields = [f for f in required_fields if f not in ckpt]

if missing_fields:
return False, f"缺少必要字段: {missing_fields}"

# 检查 epoch 值是否合理
if ckpt['epoch'] < 0:
return False, f"epoch值异常: {ckpt['epoch']}"

print(f"✅ 检查点有效")
print(f" – 已训练 epoch: {ckpt['epoch'] + 1}")
print(f" – 最佳 fitness: {ckpt.get('best_fitness', 'N/A'):.4f}")
print(f" – 保存时间: {ckpt.get('date', 'N/A')}")

return True, None

except Exception as e:
return False, f"加载失败: {str(e)}"

# 使用示例
last_pt_path = 'runs/train/exp/weights/last.pt'
best_pt_path = 'runs/train/exp/weights/best.pt'

print("检查 last.pt:")
valid, error = check_checkpoint_validity(last_pt_path)
if not valid:
print(f"❌ last.pt 损坏: {error}")
print("尝试使用 best.pt 作为续训起点…")
valid, error = check_checkpoint_validity(best_pt_path)
if valid:
print("✅ best.pt 有效，可用于续训（注意：会丢失部分进度）")
else:
print(f"❌ best.pt 也损坏: {error}")
print("无法续训，需要重新开始")

情况三：更换了硬件环境

有时候你在A机器上训练到一半，需要迁移到B机器继续训练（比如从本地迁移到云服务器）。这种情况下，续训通常是可以正常工作的，因为YOLOv9在保存检查点时使用了 map_location 机制来处理设备映射。

但有一个常见陷阱：如果原始训练在多GPU环境下进行，last.pt 中的模型权重可能包含了 module. 前缀（DataParallel或DistributedDataParallel的命名约定）。在单GPU环境下续训时，可能需要处理这个前缀。YOLOv9的 de_parallel() 函数处理了这个问题，但如果你在使用自定义加载逻辑时需要注意这一点。

三、权重文件管理的工程实践

在长期的YOLO工程实践中，权重文件管理不善是一个非常普遍的问题。实验做多了之后，runs/train/ 目录下会堆积大量的 exp1、exp2…exp50，几十GB的存储空间就这么悄悄消耗掉了，而且你根本记不清哪个实验对应什么配置。

下面我们系统地介绍一套可行的权重管理方案。

3.1 实验命名规范

首先从命名开始。YOLOv9支持 –name 参数来自定义实验名称：

# 推荐的命名格式: 数据集_模型_特殊配置_日期
python train.py \\
–data coco128.yaml \\
–weights yolov9-c.pt \\
–cfg yolov9-c.yaml \\
–epochs 100 \\
–name coco128_yolov9c_bs16_20240615

一套我认为好用的命名规范：

{数据集简称}_{模型版本}_{关键配置}_{实验日期}

例如：
– voc_yolov9c_pretrain_20240615 # VOC数据集，yolov9–c，预训练微调
– custom_yolov9e_scratch_20240620 # 自定义数据集，yolov9–e，从零训练
– coco_yolov9c_aug_heavy_20240625 # COCO，重度数据增强

这样命名之后，哪怕过了三个月再回来看，你也能大概知道每个实验是干什么的。

3.2 定期备份策略

对于长时间训练的任务，仅依赖 last.pt 是有风险的。如果训练到第90个epoch时发生了严重过拟合，而此时 best.pt 已经是第30个epoch的结果了，你可能希望能恢复到第50、60、70个epoch的状态来做对比分析。

YOLOv9默认不支持按固定间隔保存检查点（不像某些框架有 save_period 参数），但我们可以通过回调或包装脚本来实现：

#!/usr/bin/env python3
"""
YOLOv9 训练包装脚本：支持定期备份检查点
文件名: train_with_backup.py
"""

import subprocess
import time
import shutil
import os
from pathlib import Path
from datetime import datetime
import threading
import yaml

def find_latest_exp(base_dir='runs/train'):
"""找到最新的实验目录"""
base_path = Path(base_dir)
if not base_path.exists():
return None

# 找到所有 exp 目录，按创建时间排序
exp_dirs = [d for d in base_path.iterdir() if d.is_dir()]
if not exp_dirs:
return None

return max(exp_dirs, key=lambda d: d.stat().st_mtime)

def backup_checkpoint(exp_dir, backup_dir, interval_minutes=30):
"""
定期备份 last.pt 到备份目录

参数:
exp_dir: 实验目录路径
backup_dir: 备份目录路径
interval_minutes: 备份间隔（分钟）
"""
exp_path = Path(exp_dir)
backup_path = Path(backup_dir)
backup_path.mkdir(parents=True, exist_ok=True)

last_pt = exp_path / 'weights' / 'last.pt'

while True:
time.sleep(interval_minutes * 60)

if last_pt.exists():
# 读取当前 epoch 信息
try:
import torch
ckpt = torch.load(last_pt, map_location='cpu')
current_epoch = ckpt.get('epoch', 0) + 1
fitness = ckpt.get('best_fitness', 0)

# 生成备份文件名：epoch_fitness_时间戳
timestamp = datetime.now().strftime('%H%M%S')
backup_name = f'epoch{current_epoch:03d}_fit{fitness:.4f}_{timestamp}.pt'
backup_file = backup_path / backup_name

shutil.copy2(last_pt, backup_file)
print(f"\\n💾 [备份] 已保存检查点: {backup_file}")
print(f" 当前 Epoch: {current_epoch}, Best Fitness: {fitness:.4f}")

# 清理过旧的备份（保留最近5个）
backups = sorted(backup_path.glob('*.pt'),
key=lambda f: f.stat().st_mtime)
if len(backups) > 5:
for old_backup in backups[:–5]:
old_backup.unlink()
print(f" 🗑️ 清理旧备份: {old_backup.name}")

except Exception as e:
print(f"\\n⚠️ 备份失败: {e}")

def train_with_backup(train_args, backup_interval=30, exp_name=None):
"""
启动训练并后台备份检查点

参数:
train_args: 传递给 train.py 的参数列表
backup_interval: 备份间隔（分钟）
exp_name: 实验名称（用于确定备份目录）
"""
# 构建训练命令
cmd = ['python', 'train.py'] + train_args
print(f"🚀 启动训练命令: {' '.join(cmd)}")

# 确定实验目录（训练开始后才能知道确切路径）
base_dir = 'runs/train'

# 启动训练进程
process = subprocess.Popen(cmd)

# 等待实验目录创建（最多等60秒）
exp_dir = None
for _ in range(60):
time.sleep(1)
exp_dir = find_latest_exp(base_dir)
if exp_dir and (exp_dir / 'weights').exists():
break

if exp_dir is None:
print("⚠️ 未找到实验目录，跳过备份功能")
process.wait()
return

print(f"📁 实验目录: {exp_dir}")

# 设置备份目录
backup_dir = exp_dir / 'checkpoints_backup'

# 在后台线程启动备份
backup_thread = threading.Thread(
target=backup_checkpoint,
args=(exp_dir, backup_dir, backup_interval),
daemon=True # 主进程结束时自动终止
)
backup_thread.start()
print(f"⏰ 备份线程已启动，每 {backup_interval} 分钟备份一次")

# 等待训练完成
process.wait()

return_code = process.returncode
if return_code == 0:
print(f"\\n✅ 训练完成！")
else:
print(f"\\n⚠️ 训练异常结束，退出码: {return_code}")
print(f" 可以使用以下命令续训:")
print(f" python train.py –resume {exp_dir}/weights/last.pt")

# ============ 使用示例 ============
if __name__ == '__main__':
# 定义训练参数（不需要 'python train.py' 前缀）
train_arguments = [
'–data', 'data/coco128.yaml',
'–weights', 'yolov9-c.pt',
'–cfg', 'models/detect/yolov9-c.yaml',
'–epochs', '100',
'–batch-size', '16',
'–img-size', '640',
'–name', 'my_experiment',
'–device', '0'
]

# 启动带备份功能的训练（每30分钟备份一次）
train_with_backup(
train_args=train_arguments,
backup_interval=30,
exp_name='my_experiment'
)

3.3 实验管理数据库

当你的实验数量积累到几十个后，仅靠命名还不够，你需要一个轻量级的实验记录系统。下面是一个基于 SQLite 的简单实现：

#!/usr/bin/env python3
"""
YOLOv9 实验记录与管理工具
文件名: experiment_manager.py
"""

import sqlite3
import json
import torch
import yaml
from pathlib import Path
from datetime import datetime
import os

class ExperimentManager:
"""
YOLOv9 实验管理器
使用 SQLite 存储实验元数据，便于查询和比较
"""

def __init__(self, db_path='experiments.db'):
"""
初始化实验管理器

参数:
db_path: SQLite 数据库文件路径
"""
self.db_path = db_path
self._init_db()

def _init_db(self):
"""初始化数据库表结构"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()

cursor.execute('''
CREATE TABLE IF NOT EXISTS experiments (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
exp_dir TEXT NOT NULL,
dataset TEXT,
model TEXT,
epochs_total INTEGER,
epochs_done INTEGER,
best_fitness REAL,
map50 REAL,
map50_95 REAL,
batch_size INTEGER,
img_size INTEGER,
pretrained INTEGER, — 0: 从零训练, 1: 预训练微调
status TEXT, — running, completed, interrupted
created_at TEXT,
updated_at TEXT,
notes TEXT — 实验备注
)
''')

conn.commit()
conn.close()

def register_experiment(self, exp_dir, notes=''):
"""
从实验目录读取信息并注册到数据库

参数:
exp_dir: 实验目录路径（如 runs/train/exp1）
notes: 实验备注

返回:
实验ID
"""
exp_path = Path(exp_dir)

# 读取 opt.yaml
opt_yaml = exp_path / 'opt.yaml'
opt = {}
if opt_yaml.exists():
with open(opt_yaml) as f:
opt = yaml.safe_load(f) or {}

# 读取 last.pt 中的训练状态
last_pt = exp_path / 'weights' / 'last.pt'
epochs_done = 0
best_fitness = 0.0

if last_pt.exists():
try:
ckpt = torch.load(last_pt, map_location='cpu')
epochs_done = ckpt.get('epoch', 0) + 1
best_fitness = float(ckpt.get('best_fitness', 0))
except:
pass

# 读取 results.csv 获取最新指标
map50, map50_95 = 0.0, 0.0
results_csv = exp_path / 'results.csv'
if results_csv.exists():
try:
import pandas as pd
df = pd.read_csv(results_csv)
df.columns = df.columns.str.strip()
if len(df) > 0:
last_row = df.iloc[–1]
# 列名可能因版本不同而变化
for col in df.columns:
if 'mAP50(' in col or 'metrics/mAP50' in col:
map50 = float(last_row[col])
if 'mAP50-95' in col or 'metrics/mAP50-95' in col:
map50_95 = float(last_row[col])
except Exception as e:
print(f"读取 results.csv 时出错: {e}")

# 判断实验状态
total_epochs = opt.get('epochs', 0)
if epochs_done >= total_epochs and total_epochs > 0:
status = 'completed'
elif epochs_done > 0:
status = 'interrupted'
else:
status = 'running'

# 判断是否使用预训练
weights = opt.get('weights', '')
pretrained = 1 if weights and not weights.endswith('.yaml') else 0

now = datetime.now().isoformat()

# 插入数据库
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()

cursor.execute('''
INSERT INTO experiments (
name, exp_dir, dataset, model, epochs_total, epochs_done,
best_fitness, map50, map50_95, batch_size, img_size,
pretrained, status, created_at, updated_at, notes
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
''', (
exp_path.name,
str(exp_path.absolute()),
opt.get('data', 'unknown'),
opt.get('cfg', 'unknown'),
total_epochs,
epochs_done,
best_fitness,
map50,
map50_95,
opt.get('batch_size', 0),
opt.get('imgsz', 0),
pretrained,
status,
now,
now,
notes
))

exp_id = cursor.lastrowid
conn.commit()
conn.close()

print(f"✅ 实验已注册 (ID: {exp_id})")
print(f" 名称: {exp_path.name}")
print(f" 状态: {status}")
print(f" 进度: {epochs_done}/{total_epochs} epochs")
print(f" 最佳 Fitness: {best_fitness:.4f}")

return exp_id

def list_experiments(self, status=None):
"""
列出所有实验

参数:
status: 筛选状态 ('running', 'completed', 'interrupted', None=全部)
"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()

if status:
cursor.execute(
'SELECT * FROM experiments WHERE status=? ORDER BY created_at DESC',
(status,)
)
else:
cursor.execute('SELECT * FROM experiments ORDER BY created_at DESC')

rows = cursor.fetchall()
conn.close()

if not rows:
print("📭 暂无实验记录")
return

# 打印表格
print(f"\\n{'ID':>4} {'名称':<35} {'状态':<12} {'进度':>10} {'mAP50':>8} {'mAP50-95':>10}")
print("-" * 85)

for row in rows:
(id_, name, exp_dir, dataset, model, epochs_total, epochs_done,
best_fitness, map50, map50_95, batch_size, img_size,
pretrained, status_, created_at, updated_at, notes) = row

progress = f"{epochs_done}/{epochs_total}"
status_emoji = {'completed': '✅', 'interrupted': '⚠️', 'running': '🔄'}.get(status_, '❓')

print(f"{id_:>4} {name:<35} {status_emoji}{status_:<10} {progress:>10} "
f"{map50:>8.4f} {map50_95:>10.4f}")

def get_resume_command(self, exp_id):
"""
获取指定实验的续训命令

参数:
exp_id: 实验ID
"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()

cursor.execute('SELECT exp_dir, name, status FROM experiments WHERE id=?', (exp_id,))
row = cursor.fetchone()
conn.close()

if not row:
print(f"❌ 未找到 ID={exp_id} 的实验")
return

exp_dir, name, status = row
last_pt = Path(exp_dir) / 'weights' / 'last.pt'

if not last_pt.exists():
print(f"❌ last.pt 不存在: {last_pt}")
return

if status == 'completed':
print(f"ℹ️ 实验 '{name}' 已完成，无需续训")
return

print(f"\\n📋 实验 '{name}' 的续训命令:")
print(f"python train.py –resume {last_pt}")
return f"python train.py –resume {last_pt}"

def compare_experiments(self, exp_ids):
"""
比较多个实验的关键指标

参数:
exp_ids: 实验ID列表
"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()

placeholders = ','.join(['?' for _ in exp_ids])
cursor.execute(
f'SELECT * FROM experiments WHERE id IN ({placeholders})',
exp_ids
)
rows = cursor.fetchall()
conn.close()

if not rows:
print("❌ 未找到指定实验")
return

print(f"\\n{'='*90}")
print(f"{'实验对比报告':^90}")
print(f"{'='*90}")

for row in rows:
(id_, name, exp_dir, dataset, model, epochs_total, epochs_done,
best_fitness, map50, map50_95, batch_size, img_size,
pretrained, status_, created_at, updated_at, notes) = row

print(f"\\n[ID: {id_}] {name}")
print(f" 数据集: {dataset}")
print(f" 模型配置: {model}")
print(f" 训练进度: {epochs_done}/{epochs_total} epochs")
print(f" Batch Size: {batch_size}, Img Size: {img_size}")
print(f" 预训练: {'是' if pretrained else '否'}")
print(f" mAP@0.5: {map50:.4f}")
print(f" mAP@.5-.95:{map50_95:.4f}")
print(f" Fitness: {best_fitness:.4f}")
if notes:
print(f" 备注: {notes}")

# ============ 使用示例 ============
if __name__ == '__main__':
manager = ExperimentManager('my_yolov9_experiments.db')

# 注册实验
# manager.register_experiment('runs/train/exp1', notes='基线实验，预训练微调')
# manager.register_experiment('runs/train/exp2', notes='增大batch size到32')

# 列出所有实验
print("\\n所有实验:")
manager.list_experiments()

# 列出中断的实验
print("\\n需要续训的实验:")
manager.list_experiments(status='interrupted')

# 获取某个实验的续训命令
# manager.get_resume_command(1)

# 比较多个实验
# manager.compare_experiments([1, 2, 3])

四、深入理解 EMA 与 best.pt 的关系

前面我们提到 best.pt 保存的是EMA模型，这里我们详细展开讲讲，因为这对理解"为什么要用best.pt做推理"非常重要。

4.1 什么是 EMA

EMA（Exponential Moving Average）是一种平滑技术，其核心思想是：不直接使用当前batch更新后的权重，而是维护一个"影子"模型，其权重是历史权重的加权平均。

数学表达如下：

θ

E

M

A

(

t

)

=

α

⋅

θ

E

M

A

(

t

−

1

)

+

(

1

−

α

)

⋅

θ

m

o

d

e

l

(

t

)

\\theta_{EMA}^{(t)} = \\alpha \\cdot \\theta_{EMA}^{(t-1)} + (1-\\alpha) \\cdot \\theta_{model}^{(t)}

θEMA(t)​=α⋅θEMA(t−1)​+(1−α)⋅θmodel(t)​

其中

α

\\alpha

α 通常取0.9999，这意味着EMA模型的权重是一个对过去权重的"长记忆"平均，对单次更新非常不敏感。

为什么这有用？因为在训练过程中，随机梯度下降（SGD）或Adam的每一步更新都会引入一定的随机噪声（来自mini-batch的采样误差）。EMA通过平均这些噪声，得到一个"更稳定"的权重估计。这在测试集上通常能带来1~2个百分点的精度提升。

#mermaid-svg-FDzb9f803ffNMmLj{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-FDzb9f803ffNMmLj .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-FDzb9f803ffNMmLj .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-FDzb9f803ffNMmLj .error-icon{fill:#552222;}#mermaid-svg-FDzb9f803ffNMmLj .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-FDzb9f803ffNMmLj .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-FDzb9f803ffNMmLj .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-FDzb9f803ffNMmLj .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-FDzb9f803ffNMmLj .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-FDzb9f803ffNMmLj .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-FDzb9f803ffNMmLj .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-FDzb9f803ffNMmLj .marker{fill:#333333;stroke:#333333;}#mermaid-svg-FDzb9f803ffNMmLj .marker.cross{stroke:#333333;}#mermaid-svg-FDzb9f803ffNMmLj svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-FDzb9f803ffNMmLj p{margin:0;}#mermaid-svg-FDzb9f803ffNMmLj .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-FDzb9f803ffNMmLj .cluster-label text{fill:#333;}#mermaid-svg-FDzb9f803ffNMmLj .cluster-label span{color:#333;}#mermaid-svg-FDzb9f803ffNMmLj .cluster-label span p{background-color:transparent;}#mermaid-svg-FDzb9f803ffNMmLj .label text,#mermaid-svg-FDzb9f803ffNMmLj span{fill:#333;color:#333;}#mermaid-svg-FDzb9f803ffNMmLj .node rect,#mermaid-svg-FDzb9f803ffNMmLj .node circle,#mermaid-svg-FDzb9f803ffNMmLj .node ellipse,#mermaid-svg-FDzb9f803ffNMmLj .node polygon,#mermaid-svg-FDzb9f803ffNMmLj .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-FDzb9f803ffNMmLj .rough-node .label text,#mermaid-svg-FDzb9f803ffNMmLj .node .label text,#mermaid-svg-FDzb9f803ffNMmLj .image-shape .label,#mermaid-svg-FDzb9f803ffNMmLj .icon-shape .label{text-anchor:middle;}#mermaid-svg-FDzb9f803ffNMmLj .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-FDzb9f803ffNMmLj .rough-node .label,#mermaid-svg-FDzb9f803ffNMmLj .node .label,#mermaid-svg-FDzb9f803ffNMmLj .image-shape .label,#mermaid-svg-FDzb9f803ffNMmLj .icon-shape .label{text-align:center;}#mermaid-svg-FDzb9f803ffNMmLj .node.clickable{cursor:pointer;}#mermaid-svg-FDzb9f803ffNMmLj .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-FDzb9f803ffNMmLj .arrowheadPath{fill:#333333;}#mermaid-svg-FDzb9f803ffNMmLj .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-FDzb9f803ffNMmLj .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-FDzb9f803ffNMmLj .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-FDzb9f803ffNMmLj .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-FDzb9f803ffNMmLj .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-FDzb9f803ffNMmLj .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-FDzb9f803ffNMmLj .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-FDzb9f803ffNMmLj .cluster text{fill:#333;}#mermaid-svg-FDzb9f803ffNMmLj .cluster span{color:#333;}#mermaid-svg-FDzb9f803ffNMmLj div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-FDzb9f803ffNMmLj .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-FDzb9f803ffNMmLj rect.text{fill:none;stroke-width:0;}#mermaid-svg-FDzb9f803ffNMmLj .icon-shape,#mermaid-svg-FDzb9f803ffNMmLj .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-FDzb9f803ffNMmLj .icon-shape p,#mermaid-svg-FDzb9f803ffNMmLj .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-FDzb9f803ffNMmLj .icon-shape .label rect,#mermaid-svg-FDzb9f803ffNMmLj .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-FDzb9f803ffNMmLj .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-FDzb9f803ffNMmLj .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-FDzb9f803ffNMmLj :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

验证阶段 每个Epoch末

每个训练Step

是

否

Mini-batch 数据

计算梯度

更新模型权重 θ_model

更新EMA权重θ_EMA = α·θ_EMA + 1-α·θ_model

用 θ_EMA 在验证集推理

计算 mAP / fitness

fitness 创历史新高?

保存为 best.pt

丢弃

4.2 EMA 对续训的影响

理解了EMA后，我们来思考一个问题：如果续训时只恢复了模型权重（model字段），而没有恢复EMA状态（ema和updates字段），会发生什么？

答案是：EMA会从当前模型权重重新初始化，之前积累的历史平均信息会全部丢失。接下来的训练中，EMA需要重新"预热"——在前几千个step里，EMA模型与实际模型的差异会比较大，这可能导致续训初期的验证指标出现一个小的下跌，然后随着EMA重新收敛而恢复。

这个现象在损失曲线上不明显，但在mAP曲线上可能会看到一个小的"跌落"。如果你用YOLOv9的标准 –resume 参数续训，这个问题不会发生，因为EMA状态被完整恢复了。只有在手动加载权重时才需要注意这一点。

4.3 best.pt 的选取逻辑详解

#!/usr/bin/env python3
"""
理解 best.pt 的选取机制
这个脚本模拟 YOLOv9 内部的 best.pt 更新逻辑
"""

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
matplotlib.rcParams['axes.unicode_minus'] = False

def simulate_fitness_curve(epochs=100, seed=42):
"""
模拟一条典型的训练fitness曲线
– 前期快速上升
– 中期平稳提升
– 后期可能出现过拟合下降
"""
np.random.seed(seed)

fitness_values = []
best_fitness = 0
best_epoch = 0
best_pt_updates = [] # 记录 best.pt 更新的时刻

for epoch in range(epochs):
# 模拟fitness变化
if epoch < 20:
# 快速上升阶段
base = 0.3 + epoch * 0.025
elif epoch < 60:
# 稳定提升阶段
base = 0.8 + (epoch – 20) * 0.003
elif epoch < 80:
# 平台期
base = 0.92 + (epoch – 60) * 0.0005
else:
# 轻微过拟合下降
base = 0.93 – (epoch – 80) * 0.002

# 添加随机噪声
noise = np.random.normal(0, 0.008)
fitness = np.clip(base + noise, 0, 1)
fitness_values.append(fitness)

# 模拟 best.pt 更新逻辑
if fitness > best_fitness:
best_fitness = fitness
best_epoch = epoch
best_pt_updates.append((epoch, fitness))

return fitness_values, best_pt_updates, best_epoch, best_fitness

# 运行模拟
fitness_curve, updates, best_epoch, best_fitness = simulate_fitness_curve()

# 绘图
fig, axes = plt.subplots(2, 1, figsize=(14, 10))

# 上图：fitness曲线
ax1 = axes[0]
epochs_range = range(len(fitness_curve))
ax1.plot(epochs_range, fitness_curve, color='#3498db', linewidth=1.5,
label='fitness per epoch', alpha=0.8)

# 标记 best.pt 更新点
update_epochs = [u[0] for u in updates]
update_values = [u[1] for u in updates]
ax1.scatter(update_epochs, update_values, color='#e74c3c', s=50, zorder=5,
label=f'best.pt saved ({len(updates)} times)', marker='*')

# 标记最终best.pt的位置
ax1.axvline(x=best_epoch, color='#27ae60', linestyle='–', linewidth=2,
label=f'Final best.pt (epoch {best_epoch+1})')
ax1.axhline(y=best_fitness, color='#27ae60', linestyle=':', linewidth=1.5,
label=f'Best fitness = {best_fitness:.4f}')

ax1.set_xlabel('Epoch', fontsize=12)
ax1.set_ylabel('Fitness (0.1×mAP50 + 0.9×mAP50-95)', fontsize=11)
ax1.set_title('YOLOv9 Training: Fitness Curve & best.pt Update Logic', fontsize=13)
ax1.legend(loc='lower right', fontsize=10)
ax1.grid(True, alpha=0.3)
ax1.set_xlim(0, len(fitness_curve)–1)

# 下图：best.pt 更新频率（累积次数）
ax2 = axes[1]
cumulative_updates = list(range(1, len(updates) + 1))
update_epoch_positions = [u[0] for u in updates]

ax2.step(update_epoch_positions, cumulative_updates, where='post',
color='#9b59b6', linewidth=2, label='Cumulative best.pt saves')
ax2.fill_between(update_epoch_positions, cumulative_updates,
step='post', alpha=0.2, color='#9b59b6')

# 添加不同阶段的注释
ax2.axvspan(0, 20, alpha=0.1, color='green', label='快速上升阶段 (0-20 epochs)')
ax2.axvspan(20, 60, alpha=0.1, color='blue', label='稳定提升阶段 (20-60 epochs)')
ax2.axvspan(60, 80, alpha=0.1, color='yellow', label='平台期 (60-80 epochs)')
ax2.axvspan(80, 100, alpha=0.1, color='red', label='过拟合阶段 (80-100 epochs)')

ax2.set_xlabel('Epoch', fontsize=12)
ax2.set_ylabel('Cumulative best.pt Saves', fontsize=11)
ax2.set_title('Cumulative best.pt Save Frequency by Training Phase', fontsize=13)
ax2.legend(loc='lower right', fontsize=9)
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('best_pt_update_analysis.png', dpi=150, bbox_inches='tight')
plt.show()

print(f"\\n📊 模拟结果分析:")
print(f" 总训练: 100 epochs")
print(f" best.pt 共更新: {len(updates)} 次")
print(f" 最终 best.pt 来自: Epoch {best_epoch+1}")
print(f" 最佳 Fitness: {best_fitness:.4f}")
print(f"\\n 更新频率分布:")
phase_counts = {
'快速上升(0-20)': sum(1 for e, _ in updates if e < 20),
'稳定提升(20-60)': sum(1 for e, _ in updates if 20 <= e < 60),
'平台期(60-80)': sum(1 for e, _ in updates if 60 <= e < 80),
'过拟合(80-100)': sum(1 for e, _ in updates if e >= 80)
}
for phase, count in phase_counts.items():
print(f" {phase}: {count} 次")

五、常见的续训陷阱与解决方案

这一部分来自真实的踩坑经历，相信很多人都遇到过其中的一个或几个问题。

5.1 陷阱一：学习率调度的续训问题

这是最隐蔽的一个问题。YOLOv9使用了学习率调度器（通常是余弦退火），学习率会随着训练进度动态变化。续训时，学习率调度器需要从正确的位置继续，而不是重新从初始学习率开始。

YOLOv9在续训时会正确恢复调度器状态，但如果你的续训涉及到修改 epochs（比如从100延长到200），调度器的行为需要特别注意：

#!/usr/bin/env python3
"""
分析续训时学习率调度的变化
展示不同续训方式对学习率曲线的影响
"""

import numpy as np
import matplotlib.pyplot as plt
import math

def cosine_lr_schedule(epoch, total_epochs, lr0, lrf):
"""
YOLOv9 默认的余弦退火学习率调度

参数:
epoch: 当前epoch（0-indexed）
total_epochs: 总epoch数
lr0: 初始学习率
lrf: 最终学习率（相对lr0的比例）

返回:
当前epoch的学习率
"""
# 余弦退火：从 lr0 退火到 lr0 * lrf
progress = epoch / total_epochs
lr_factor = lrf + (1 – lrf) * (1 + math.cos(math.pi * progress)) / 2
return lr0 * lr_factor

# 参数设置
lr0 = 0.01 # 初始学习率
lrf = 0.01 # 最终学习率比例（即最终LR = lr0 * lrf = 0.0001）

# 场景1：正常训练100个epoch
lr_normal = [cosine_lr_schedule(e, 100, lr0, lrf) for e in range(100)]

# 场景2：训练50个epoch后中断，正确续训到100
lr_resume_correct = (
[cosine_lr_schedule(e, 100, lr0, lrf) for e in range(50)] # 第一段
+ [cosine_lr_schedule(e, 100, lr0, lrf) for e in range(50, 100)] # 续训段
)

# 场景3：错误的续训方式（续训时重置了调度器）
lr_resume_wrong = (
[cosine_lr_schedule(e, 100, lr0, lrf) for e in range(50)] # 第一段
+ [cosine_lr_schedule(e, 50, lr0, lrf) for e in range(50)] # 错误：重新从头开始
)

# 场景4：续训并延长总epoch数（100 -> 200）
lr_extended = [cosine_lr_schedule(e, 200, lr0, lrf) for e in range(200)]

# 绘图
fig, axes = plt.subplots(2, 2, figsize=(16, 10))

# 图1：正常训练
ax = axes[0][0]
ax.plot(range(100), lr_normal, color='#2ecc71', linewidth=2)
ax.set_title('Scenario 1: Normal Training (100 epochs)', fontsize=12)
ax.set_xlabel('Epoch')
ax.set_ylabel('Learning Rate')
ax.grid(True, alpha=0.3)
ax.set_yscale('log')

# 图2：正确续训
ax = axes[0][1]
ax.plot(range(50), lr_resume_correct[:50], color='#3498db', linewidth=2, label='Phase 1')
ax.axvline(x=50, color='red', linestyle='–', linewidth=2, label='Resume point')
ax.plot(range(50, 100), lr_resume_correct[50:], color='#e67e22', linewidth=2, label='Phase 2 (resumed)')
ax.set_title('Scenario 2: Correct Resume (LR schedule preserved)', fontsize=12)
ax.set_xlabel('Epoch')
ax.set_ylabel('Learning Rate')
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_yscale('log')

# 图3：错误续训
ax = axes[1][0]
ax.plot(range(50), lr_resume_wrong[:50], color='#3498db', linewidth=2, label='Phase 1')
ax.axvline(x=50, color='red', linestyle='–', linewidth=2, label='Resume point')
ax.plot(range(50, 100), lr_resume_wrong[50:], color='#e74c3c', linewidth=2, label='Phase 2 (WRONG reset)')
ax.set_title('Scenario 3: WRONG Resume (LR schedule reset!)', fontsize=12)
ax.set_xlabel('Epoch')
ax.set_ylabel('Learning Rate')
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_yscale('log')
ax.annotate('⚠️ LR jumps back up!\\nThis damages trained weights',
xy=(50, lr_resume_wrong[50]), xytext=(60, 0.008),
arrowprops=dict(arrowstyle='->', color='red'),
fontsize=9, color='red')

# 图4：延长训练
ax = axes[1][1]
ax.plot(range(100), [cosine_lr_schedule(e, 100, lr0, lrf) for e in range(100)],
color='gray', linewidth=1.5, linestyle='–', label='Original 100 epochs')
ax.axvline(x=100, color='gray', linestyle=':', linewidth=1.5)
ax.plot(range(200), lr_extended, color='#9b59b6', linewidth=2, label='Extended to 200 epochs')
ax.axvline(x=100, color='red', linestyle='–', linewidth=2, label='Extension point')
ax.set_title('Scenario 4: Extended Training (100→200 epochs)', fontsize=12)
ax.set_xlabel('Epoch')
ax.set_ylabel('Learning Rate')
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_yscale('log')

plt.suptitle('Learning Rate Schedule: Impact of Different Resume Strategies',
fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('lr_resume_analysis.png', dpi=150, bbox_inches='tight')
plt.show()

print("✅ 学习率调度分析图已保存")
print("\\n📝 关键结论:")
print(" – 场景2（正确续训）：学习率曲线与正常训练完全一致，无任何跳变")
print(" – 场景3（错误续训）：第50个epoch时学习率从低点跳回高点，")
print(" 这会损坏已经精细训练好的权重，相当于重新开始了一轮粗糙训练")
print(" – 场景4（延长训练）：需要修改opt.yaml，学习率会重新规划为200epoch的退火曲线")

5.2 陷阱二：–resume 路径中包含空格或特殊字符

这个问题非常低级，但确实会让人困惑。在Windows系统上，路径中经常出现空格（比如 C:\\Users\\Zhang San\\Projects\\…），直接传给 –resume 会导致参数解析失败。

# ❌ 错误（路径含空格）
python train.py –resume C:\\Users\\Zhang San\\runs\\train\\exp\\weights\\last.pt

# ✅ 正确（用引号包裹）
python train.py –resume "C:\\Users\\Zhang San\\runs\\train\\exp\\weights\\last.pt"

# ✅ 更好的做法：使用相对路径或无空格的路径
python train.py –resume runs/train/exp/weights/last.pt

5.3 陷阱三：多次实验导致 exp 目录混乱

这是最常见的管理问题。你可能会发现自己面对这样的情况：

runs/train/
├── exp/ # 忘了是什么实验
├── exp2/ # 好像是改了batch size的版本
├── exp3/ # 这个是续训exp2的…吧？
├── exp4/ # 不记得了
└── exp5/ # 昨天新开的

解决这个问题的最佳实践是：永远使用 –name 参数，并且在训练开始前写下实验记录。

#!/usr/bin/env python3
"""
自动生成带时间戳的实验名称和记录
"""

from datetime import datetime
import subprocess
import yaml
import os

def generate_exp_name(dataset, model_size, mode='finetune', note=''):
"""
生成规范的实验名称

参数:
dataset: 数据集名称（如 'coco128', 'custom_v1'）
model_size: 模型大小（如 'c', 'e', 'gelan_c'）
mode: 训练模式（'finetune' 或 'scratch'）
note: 额外备注（如 'aug_heavy', 'lr_high'）

返回:
规范化的实验名称字符串
"""
date_str = datetime.now().strftime('%m%d')
parts = [dataset, f'yolov9{model_size}', mode]
if note:
parts.append(note)
parts.append(date_str)

return '_'.join(parts)

def launch_training(config):
"""
启动训练并自动记录实验信息

参数:
config: 实验配置字典
"""
exp_name = generate_exp_name(
dataset=config['dataset'],
model_size=config['model_size'],
mode=config['mode'],
note=config.get('note', '')
)

print(f"🚀 准备启动实验: {exp_name}")

# 写入实验记录文件
record = {
'exp_name': exp_name,
'start_time': datetime.now().isoformat(),
'config': config,
'status': 'planned'
}

record_file = f'experiment_records/{exp_name}.yaml'
os.makedirs('experiment_records', exist_ok=True)
with open(record_file, 'w', encoding='utf-8') as f:
yaml.dump(record, f, allow_unicode=True, default_flow_style=False)

print(f"📝 实验记录已写入: {record_file}")

# 构建训练命令
cmd = [
'python', 'train.py',
'–data', config['data_yaml'],
'–weights', config['weights'],
'–cfg', config['cfg'],
'–epochs', str(config['epochs']),
'–batch-size', str(config['batch_size']),
'–img-size', str(config['img_size']),
'–name', exp_name,
'–device', str(config['device']),
]

if config.get('project'):
cmd += ['–project', config['project']]

print(f"📋 训练命令:\\n{' '.join(cmd)}\\n")

return cmd, exp_name

# 使用示例
if __name__ == '__main__':
experiment_config = {
'dataset': 'coco128',
'model_size': 'c',
'mode': 'finetune',
'note': 'baseline',
'data_yaml': 'data/coco128.yaml',
'weights': 'yolov9-c.pt',
'cfg': 'models/detect/yolov9-c.yaml',
'epochs': 100,
'batch_size': 16,
'img_size': 640,
'device': 0,
'project': 'runs/train'
}

cmd, name = launch_training(experiment_config)
print(f"实验名称: {name}")
print("执行命令（实际训练时取消注释下面这行）:")
print(f"# subprocess.run(cmd)")

5.4 陷阱四：在云平台上续训时的路径问题

在 Colab 或 Kaggle 上训练时，每次会话重启后，本地存储会被清空。如果你把权重保存在 /content/ 或 /kaggle/working/ 下，重启后就找不到了。

正确做法是挂载持久化存储（Google Drive 或 Kaggle Dataset），并将权重保存到持久化目录：

# Colab 环境下的持久化训练设置
from google.colab import drive
import os
import subprocess

# 挂载 Google Drive
drive.mount('/content/drive')

# 设置持久化目录
PERSISTENT_DIR = '/content/drive/MyDrive/YOLOv9_Training'
os.makedirs(PERSISTENT_DIR, exist_ok=True)

# 检查是否有上次的训练记录
last_pt_path = f'{PERSISTENT_DIR}/last.pt'

if os.path.exists(last_pt_path):
print(f"✅ 找到上次的检查点: {last_pt_path}")
print("将从上次中断处继续训练")

# 续训命令
cmd = f'python train.py –resume {last_pt_path}'

else:
print("🆕 未找到检查点，开始新的训练")

# 新训练命令，指定保存路径到 Drive
cmd = (
'python train.py '
'–data data/coco128.yaml '
'–weights yolov9-c.pt '
'–epochs 100 '
f'–project {PERSISTENT_DIR} '
'–name exp '
'–device 0'
)

print(f"执行命令: {cmd}")
# subprocess.run(cmd, shell=True)

# 每次训练结束后，手动同步最新权重到 Drive（额外保险）
def sync_weights_to_drive(local_exp_dir, drive_dir):
"""同步权重文件到 Google Drive"""
import shutil

weights_dir = os.path.join(local_exp_dir, 'weights')
if os.path.exists(weights_dir):
target = os.path.join(drive_dir, 'weights')
os.makedirs(target, exist_ok=True)

for pt_file in ['last.pt', 'best.pt']:
src = os.path.join(weights_dir, pt_file)
dst = os.path.join(target, pt_file)
if os.path.exists(src):
shutil.copy2(src, dst)
print(f"📦 已同步: {pt_file} -> Drive")

六、权重文件的加载与使用

训练结束后（或者你想在中间某个checkpoint做推理测试时），如何正确加载权重也有几个需要注意的地方。

6.1 推理时加载 best.pt

#!/usr/bin/env python3
"""
YOLOv9 权重加载与推理完整示例
演示如何正确加载 best.pt 并进行推理
"""

import torch
from pathlib import Path

def load_yolov9_for_inference(weights_path, device='cpu'):
"""
为推理加载 YOLOv9 权重

参数:
weights_path: 权重文件路径（通常是 best.pt）
device: 推理设备

返回:
模型对象
"""
weights_path = Path(weights_path)

if not weights_path.exists():
raise FileNotFoundError(f"权重文件不存在: {weights_path}")

# 加载检查点
ckpt = torch.load(weights_path, map_location=device)

print(f"📦 权重文件信息:")
print(f" 文件: {weights_path.name}")
print(f" 大小: {weights_path.stat().st_size / 1024 / 1024:.1f} MB")

# 检查是否是完整的训练检查点（包含训练状态）
if 'epoch' in ckpt:
print(f" 类型: 训练检查点")
print(f" 训练Epoch: {ckpt['epoch'] + 1}")
print(f" 最佳Fitness: {ckpt.get('best_fitness', 'N/A')}")
print(f" 保存时间: {ckpt.get('date', 'N/A')}")

# 推理时优先使用 EMA 模型（best.pt 中的 'ema' 字段）
if 'ema' in ckpt and ckpt['ema'] is not None:
model = ckpt['ema']
print(f" 模型来源: EMA 模型（推荐）")
else:
model = ckpt['model']
print(f" 模型来源: 原始模型")
else:
# 纯模型文件（通过 export 导出的）
model = ckpt
print(f" 类型: 纯模型文件")

# 设置为浮点精度（检查点通常以半精度存储）
model = model.float()
model.eval()
model.to(device)

print(f" 设备: {device}")
print(f"✅ 模型加载完成")

return model

def inspect_checkpoint(ckpt_path):
"""
详细检查一个检查点文件的内容
适合用来调试和理解权重文件结构
"""
print(f"\\n{'='*60}")
print(f"检查点详细分析: {ckpt_path}")
print(f"{'='*60}")

ckpt = torch.load(ckpt_path, map_location='cpu')

print(f"\\n📋 顶层字段:")
for key, value in ckpt.items():
if isinstance(value, torch.nn.Module):
# 计算参数量
params = sum(p.numel() for p in value.parameters())
print(f" {key:<20}: <Module> ({params/1e6:.1f}M params)")
elif isinstance(value, dict):
print(f" {key:<20}: <dict> ({len(value)} items)")
elif isinstance(value, (int, float)):
print(f" {key:<20}: {value}")
elif isinstance(value, str):
print(f" {key:<20}: '{value[:50]}{'…' if len(value) > 50 else ''}'")
else:
print(f" {key:<20}: {type(value).__name__}")

# 分析模型结构（如果存在）
if 'model' in ckpt:
model = ckpt['model']
if hasattr(model, 'yaml'):
print(f"\\n📐 模型配置:")
print(f" YAML: {model.yaml.get('yaml_file', 'N/A')}")

if hasattr(model, 'names'):
names = model.names
print(f"\\n🏷️ 类别信息:")
print(f" 类别数: {len(names)}")
if len(names) <= 10:
print(f" 类别名: {list(names.values()) if isinstance(names, dict) else names}")
else:
items = list(names.items()) if isinstance(names, dict) else enumerate(names)
first_5 = list(items)[:5]
last_5 = list(items)[–5:]
print(f" 前5类: {[v for _, v in first_5]}")
print(f" 后5类: {[v for _, v in last_5]}")

# 检查优化器状态
if 'optimizer' in ckpt and ckpt['optimizer']:
opt_state = ckpt['optimizer']
param_groups = opt_state.get('param_groups', [])
print(f"\\n⚙️ 优化器状态:")
print(f" 参数组数: {len(param_groups)}")
if param_groups:
for i, pg in enumerate(param_groups):
print(f" 组{i}: lr={pg.get('lr', 'N/A'):.6f}, "
f"weight_decay={pg.get('weight_decay', 0):.4f}, "
f"params={len(pg.get('params', []))}")

# ============ 使用示例 ============
if __name__ == '__main__':
# 检查检查点内容
# inspect_checkpoint('runs/train/exp/weights/best.pt')

# 加载模型用于推理
# model = load_yolov9_for_inference('runs/train/exp/weights/best.pt', device='cuda:0')

print("权重管理工具已就绪")
print("请取消注释相应函数调用来使用")

6.2 比较 last.pt 与 best.pt 的性能

在实际使用中，我们经常需要比较同一次训练的 last.pt 和 best.pt 的性能差异，来判断训练是否出现了过拟合：

#!/usr/bin/env python3
"""
比较 last.pt 与 best.pt 的训练状态信息
帮助判断是否出现过拟合
"""

import torch
from pathlib import Path
import json

def compare_last_and_best(exp_dir):
"""
比较 last.pt 和 best.pt 的关键指标

参数:
exp_dir: 实验目录路径
"""
exp_path = Path(exp_dir)
last_pt = exp_path / 'weights' / 'last.pt'
best_pt = exp_path / 'weights' / 'best.pt'

print(f"\\n{'='*65}")
print(f"{'last.pt vs best.pt 对比分析':^65}")
print(f"{'='*65}")

results = {}

for name, pt_path in [('last.pt', last_pt), ('best.pt', best_pt)]:
if not pt_path.exists():
print(f"⚠️ {name} 不存在: {pt_path}")
continue

try:
ckpt = torch.load(pt_path, map_location='cpu')

info = {
'file_size_mb': pt_path.stat().st_size / 1024 / 1024,
'epoch': ckpt.get('epoch', –1) + 1,
'best_fitness': float(ckpt.get('best_fitness', 0)),
'save_date': ckpt.get('date', 'N/A'),
}

# 尝试读取 EMA 更新次数
if 'updates' in ckpt:
info['ema_updates'] = ckpt['updates']

results[name] = info

except Exception as e:
print(f"❌ 加载 {name} 失败: {e}")

# 读取 results.csv 获取更详细的指标
results_csv = exp_path / 'results.csv'
if results_csv.exists():
try:
import pandas as pd
df = pd.read_csv(results_csv)
df.columns = df.columns.str.strip()

if len(df) > 0:
# 获取最后一个epoch的指标（对应 last.pt）
last_row = df.iloc[–1]

# 找 mAP 列名（不同版本可能不同）
map50_col = None
map50_95_col = None
for col in df.columns:
col_stripped = col.strip()
if 'metrics/mAP50(' in col_stripped or col_stripped == 'metrics/mAP50':
map50_col = col
if 'metrics/mAP50-95' in col_stripped:
map50_95_col = col

if 'last.pt' in results:
if map50_col:
results['last.pt']['map50_last_epoch'] = float(last_row[map50_col])
if map50_95_col:
results['last.pt']['map50_95_last_epoch'] = float(last_row[map50_95_col])

# 找到 best fitness 对应的行
fitness_col = None
for col in df.columns:
if 'fitness' in col.lower():
fitness_col = col
break

if fitness_col and 'best.pt' in results:
best_fitness = results['best.pt']['best_fitness']
# 找到最接近 best_fitness 的行
idx = (df[fitness_col] – best_fitness).abs().idxmin()
best_row = df.iloc[idx]
if map50_col:
results['best.pt']['map50_at_best'] = float(best_row[map50_col])
if map50_95_col:
results['best.pt']['map50_95_at_best'] = float(best_row[map50_95_col])

except Exception as e:
print(f"读取 results.csv 时出错: {e}")

# 打印对比结果
if 'last.pt' in results and 'best.pt' in results:
last = results['last.pt']
best = results['best.pt']

print(f"\\n{'指标':<30} {'last.pt':>15} {'best.pt':>15} {'差异':>10}")
print(f"{'-'*70}")
print(f"{'文件大小 (MB)':<30} {last['file_size_mb']:>15.1f} {best['file_size_mb']:>15.1f}")
print(f"{'对应 Epoch':<30} {last['epoch']:>15} {best['epoch']:>15}")
print(f"{'Best Fitness (记录值)':<30} {last['best_fitness']:>15.4f} {best['best_fitness']:>15.4f}")

fitness_diff = last['best_fitness'] – best['best_fitness']
if 'map50_last_epoch' in last and 'map50_at_best' in best:
map50_diff = last['map50_last_epoch'] – best['map50_at_best']
print(f"{'mAP@0.5':<30} {last['map50_last_epoch']:>15.4f} {best['map50_at_best']:>15.4f} "
f"{map50_diff:>+10.4f}")

if 'map50_95_last_epoch' in last and 'map50_95_at_best' in best:
map50_95_diff = last['map50_95_last_epoch'] – best['map50_95_at_best']
print(f"{'mAP@0.5:0.95':<30} {last['map50_95_last_epoch']:>15.4f} "
f"{best['map50_95_at_best']:>15.4f} {map50_95_diff:>+10.4f}")

print(f"\\n📊 分析结论:")

if best['epoch'] == last['epoch']:
print(" ✅ last.pt 和 best.pt 对应同一个 epoch，训练结束时仍在提升")
elif best['epoch'] < last['epoch']:
gap = last['epoch'] – best['epoch']
print(f" ⚠️ best.pt 来自 Epoch {best['epoch']}，最后 {gap} 个 epoch 性能有所下降")
if gap > 10:
print(f" 💡 建议：考虑使用 Early Stopping 或调低总 epoch 数")
print(f" 推理时请务必使用 best.pt 而非 last.pt")

print(f"\\n 推荐使用: {'best.pt' if best['best_fitness'] > last['best_fitness'] * 0.999 else 'last.pt'}")

return results

# 使用示例
if __name__ == '__main__':
# 分析实验结果
# compare_last_and_best('runs/train/exp')

print("请传入你的实验目录路径来运行分析")
print("例如: compare_last_and_best('runs/train/exp1')")

七、断点续训的完整工作流

将前面的内容综合起来，下面给出一个完整的断点续训工作流程图，覆盖从训练开始到最终部署的全流程：

#mermaid-svg-KNUde2SnD3cehW1D{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-KNUde2SnD3cehW1D .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-KNUde2SnD3cehW1D .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-KNUde2SnD3cehW1D .error-icon{fill:#552222;}#mermaid-svg-KNUde2SnD3cehW1D .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-KNUde2SnD3cehW1D .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-KNUde2SnD3cehW1D .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-KNUde2SnD3cehW1D .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-KNUde2SnD3cehW1D .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-KNUde2SnD3cehW1D .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-KNUde2SnD3cehW1D .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-KNUde2SnD3cehW1D .marker{fill:#333333;stroke:#333333;}#mermaid-svg-KNUde2SnD3cehW1D .marker.cross{stroke:#333333;}#mermaid-svg-KNUde2SnD3cehW1D svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-KNUde2SnD3cehW1D p{margin:0;}#mermaid-svg-KNUde2SnD3cehW1D .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-KNUde2SnD3cehW1D .cluster-label text{fill:#333;}#mermaid-svg-KNUde2SnD3cehW1D .cluster-label span{color:#333;}#mermaid-svg-KNUde2SnD3cehW1D .cluster-label span p{background-color:transparent;}#mermaid-svg-KNUde2SnD3cehW1D .label text,#mermaid-svg-KNUde2SnD3cehW1D span{fill:#333;color:#333;}#mermaid-svg-KNUde2SnD3cehW1D .node rect,#mermaid-svg-KNUde2SnD3cehW1D .node circle,#mermaid-svg-KNUde2SnD3cehW1D .node ellipse,#mermaid-svg-KNUde2SnD3cehW1D .node polygon,#mermaid-svg-KNUde2SnD3cehW1D .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-KNUde2SnD3cehW1D .rough-node .label text,#mermaid-svg-KNUde2SnD3cehW1D .node .label text,#mermaid-svg-KNUde2SnD3cehW1D .image-shape .label,#mermaid-svg-KNUde2SnD3cehW1D .icon-shape .label{text-anchor:middle;}#mermaid-svg-KNUde2SnD3cehW1D .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-KNUde2SnD3cehW1D .rough-node .label,#mermaid-svg-KNUde2SnD3cehW1D .node .label,#mermaid-svg-KNUde2SnD3cehW1D .image-shape .label,#mermaid-svg-KNUde2SnD3cehW1D .icon-shape .label{text-align:center;}#mermaid-svg-KNUde2SnD3cehW1D .node.clickable{cursor:pointer;}#mermaid-svg-KNUde2SnD3cehW1D .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-KNUde2SnD3cehW1D .arrowheadPath{fill:#333333;}#mermaid-svg-KNUde2SnD3cehW1D .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-KNUde2SnD3cehW1D .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-KNUde2SnD3cehW1D .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-KNUde2SnD3cehW1D .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-KNUde2SnD3cehW1D .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-KNUde2SnD3cehW1D .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-KNUde2SnD3cehW1D .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-KNUde2SnD3cehW1D .cluster text{fill:#333;}#mermaid-svg-KNUde2SnD3cehW1D .cluster span{color:#333;}#mermaid-svg-KNUde2SnD3cehW1D div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-KNUde2SnD3cehW1D .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-KNUde2SnD3cehW1D rect.text{fill:none;stroke-width:0;}#mermaid-svg-KNUde2SnD3cehW1D .icon-shape,#mermaid-svg-KNUde2SnD3cehW1D .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-KNUde2SnD3cehW1D .icon-shape p,#mermaid-svg-KNUde2SnD3cehW1D .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-KNUde2SnD3cehW1D .icon-shape .label rect,#mermaid-svg-KNUde2SnD3cehW1D .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-KNUde2SnD3cehW1D .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-KNUde2SnD3cehW1D .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-KNUde2SnD3cehW1D :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

否

是

损坏/不存在

有效

是

否

中断

完成

OOM/显存溢出

SIGKILL/超时

NaN 损失

是，性能相近

否，last.pt 更差

否，last.pt 更好

开始

是否有 last.pt?

新训练python train.py–data … –weights … –name EXP_NAME

检查 last.pt 有效性

文件是否有效?

尝试加载 best.pt作为备用起点

执行续训–resume path/to/last.pt

best.pt 有效?

从 best.pt 续训注意：会丢失 last→best 之间的进度

训练进行中

训练是否中断?

记录中断原因

训练正常结束

中断类型?

减小 batch_size或开启梯度累积再续训

直接续训无需修改参数

检查数据质量调低初始学习率再续训

比较 last.pt 与 best.pt

last.pt ≈ best.pt?

使用 best.pt 部署训练收敛良好

使用 best.pt 部署训练后期出现过拟合下次减少 epochs

使用 last.pt 部署异常情况，检查代码逻辑

八、自动化续训脚本：应对云平台限时中断

云平台（如Colab免费版12小时、AutoDL按时计费）是训练的常见场景。面对这些限时或高中断风险的环境，我们需要一个更健壮的自动化方案：

#!/usr/bin/env python3
"""
YOLOv9 智能续训管理器
适用于云平台等高中断风险环境
文件名: smart_resume_trainer.py
"""

import os
import sys
import time
import subprocess
import shutil
import signal
import torch
import yaml
import logging
from pathlib import Path
from datetime import datetime, timedelta

# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s [%(levelname)s] %(message)s',
handlers=[
logging.FileHandler('smart_trainer.log', encoding='utf-8'),
logging.StreamHandler()
]
)
logger = logging.getLogger('SmartTrainer')

class SmartResumeTrainer:
"""
智能续训管理器

功能：
1. 自动检测是否需要续训
2. 训练过程中定期备份检查点
3. 训练结束前自动保存到持久化存储
4. 支持多轮次自动重启（应对OOM等临时性错误）
"""

def __init__(self, config_path='smart_train_config.yaml'):
"""
参数:
config_path: 配置文件路径
"""
self.config = self._load_config(config_path)
self.exp_dir = None
self.process = None
self._setup_signal_handlers()

def _load_config(self, config_path):
"""加载训练配置"""
default_config = {
# 基本训练参数
'data': 'data/coco128.yaml',
'weights': 'yolov9-c.pt',
'cfg': 'models/detect/yolov9-c.yaml',
'epochs': 100,
'batch_size': 16,
'img_size': 640,
'device': '0',
'exp_name': f'auto_{datetime.now().strftime("%m%d_%H%M")}',
'project': 'runs/train',

# 续训管理
'persistent_dir': None, # 持久化目录（如 Google Drive 路径）
'backup_interval_minutes': 30, # 备份间隔
'max_retries': 3, # 最大自动重试次数
'retry_batch_reduction': 0.75, # OOM时 batch_size 缩减比例

# 超时管理
'max_training_hours': None, # 最大训练时长（None=不限制）
'save_before_timeout': True, # 超时前是否保存
}

if Path(config_path).exists():
with open(config_path, 'r', encoding='utf-8') as f:
user_config = yaml.safe_load(f) or {}
default_config.update(user_config)
logger.info(f"已加载配置文件: {config_path}")
else:
logger.warning(f"配置文件不存在，使用默认配置: {config_path}")

return default_config

def _setup_signal_handlers(self):
"""设置信号处理器，确保在被Kill时也能保存进度"""
def graceful_shutdown(signum, frame):
logger.warning(f"收到信号 {signum}，正在安全关闭…")
self._emergency_backup()
if self.process:
self.process.terminate()
sys.exit(0)

signal.signal(signal.SIGTERM, graceful_shutdown)
signal.signal(signal.SIGINT, graceful_shutdown)

def _find_existing_checkpoint(self):
"""
查找现有的检查点
搜索顺序: 持久化目录 > 本地实验目录

返回:
检查点路径 或 None
"""
exp_name = self.config['exp_name']
project = self.config['project']

# 首先检查持久化目录
if self.config.get('persistent_dir'):
persistent_last = Path(self.config['persistent_dir']) / exp_name / 'weights' / 'last.pt'
if persistent_last.exists():
logger.info(f"在持久化目录找到检查点: {persistent_last}")
return str(persistent_last)

# 检查本地目录
local_exp = Path(project) / exp_name
local_last = local_exp / 'weights' / 'last.pt'

if local_last.exists():
logger.info(f"在本地找到检查点: {local_last}")
return str(local_last)

logger.info("未找到现有检查点，将开始新训练")
return None

def _validate_checkpoint(self, ckpt_path):
"""
验证检查点文件是否有效

返回:
(是否有效, 已训练epoch数)
"""
try:
ckpt = torch.load(ckpt_path, map_location='cpu')
epoch = ckpt.get('epoch', –1) + 1

if epoch <= 0:
return False, 0

total_epochs = self.config['epochs']

if epoch >= total_epochs:
logger.info(f"检查点显示训练已完成 ({epoch}/{total_epochs} epochs)")
return False, epoch # 返回False表示不需要续训（已完成）

logger.info(f"检查点有效，已训练 {epoch}/{total_epochs} epochs")
return True, epoch

except Exception as e:
logger.error(f"检查点验证失败: {e}")
return False, 0

def _build_train_command(self, resume_path=None):
"""构建训练命令"""
cfg = self.config

if resume_path:
cmd = ['python', 'train.py', '–resume', resume_path]
else:
cmd = [
'python', 'train.py',
'–data', cfg['data'],
'–weights', cfg['weights'],
'–cfg', cfg['cfg'],
'–epochs', str(cfg['epochs']),
'–batch-size', str(cfg['batch_size']),
'–img-size', str(cfg['img_size']),
'–device', str(cfg['device']),
'–name', cfg['exp_name'],
'–project', cfg['project'],
]

return cmd

def _emergency_backup(self):
"""紧急备份：在训练被强制中断时调用"""
if not self.exp_dir:
return

persistent_dir = self.config.get('persistent_dir')
if not persistent_dir:
return

try:
exp_path = Path(self.exp_dir)
target = Path(persistent_dir) / exp_path.name
target.mkdir(parents=True, exist_ok=True)

# 备份权重
weights_dir = exp_path / 'weights'
if weights_dir.exists():
target_weights = target / 'weights'
target_weights.mkdir(exist_ok=True)

for pt_file in weights_dir.glob('*.pt'):
shutil.copy2(pt_file, target_weights / pt_file.name)
logger.info(f"紧急备份: {pt_file.name}")

# 备份日志
for log_file in ['results.csv', 'opt.yaml', 'hyp.yaml']:
src = exp_path / log_file
if src.exists():
shutil.copy2(src, target / log_file)

logger.info(f"✅ 紧急备份完成: {target}")

except Exception as e:
logger.error(f"紧急备份失败: {e}")

def run(self):
"""
执行智能训练流程
"""
logger.info("="*60)
logger.info("YOLOv9 智能续训管理器启动")
logger.info("="*60)

retry_count = 0
current_batch_size = self.config['batch_size']

while retry_count <= self.config['max_retries']:

# 查找检查点
ckpt_path = self._find_existing_checkpoint()

if ckpt_path:
valid, epochs_done = self._validate_checkpoint(ckpt_path)

if not valid and epochs_done >= self.config['epochs']:
logger.info("训练已完成，无需续训")
return True

if valid:
logger.info(f"🔄 从 Epoch {epochs_done+1} 继续训练")
cmd = self._build_train_command(resume_path=ckpt_path)
else:
logger.warning("检查点无效，重新开始训练")
cmd = self._build_train_command()
else:
logger.info("🚀 开始新训练")
cmd = self._build_train_command()

# 更新batch size（可能因为重试而减小）
if current_batch_size != self.config['batch_size']:
cmd_str = ' '.join(cmd)
cmd_str = cmd_str.replace(
f"–batch-size {self.config['batch_size']}",
f"–batch-size {current_batch_size}"
)
cmd = cmd_str.split()

logger.info(f"执行命令: {' '.join(cmd)}")

# 设置超时
timeout = None
if self.config.get('max_training_hours'):
timeout = self.config['max_training_hours'] * 3600

# 启动训练进程
start_time = time.time()
self.process = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True, bufsize=1)

# 更新实验目录
time.sleep(5) # 等待实验目录创建
project_path = Path(self.config['project'])
if project_path.exists():
exp_dirs = sorted(project_path.iterdir(), key=lambda d: d.stat().st_mtime)
if exp_dirs:
self.exp_dir = str(exp_dirs[–1])

# 实时读取输出并检测OOM
oom_detected = False
nan_detected = False

while True:
line = self.process.stdout.readline()
if not line and self.process.poll() is not None:
break
if line:
line = line.rstrip()
print(line) # 实时打印

# 检测 OOM
if 'CUDA out of memory' in line or 'RuntimeError: CUDA' in line:
oom_detected = True
logger.warning("🔴 检测到 CUDA OOM!")

# 检测 NaN
if 'nan' in line.lower() and ('loss' in line.lower() or 'Loss' in line):
nan_detected = True
logger.warning("🔴 检测到 NaN 损失!")

# 检查超时
if timeout and (time.time() – start_time) > timeout:
logger.warning(f"⏰ 达到最大训练时长 {self.config['max_training_hours']}h，保存并退出")
self._emergency_backup()
self.process.terminate()
return False