详解YOLOv13网络结构/改进/环境搭建/数据集获取/训练/推理/验证/导出/部署（含手绘网络结构图）
一、本文介绍
本文将系统地介绍YOLOv13的使用教程，包括网络结构的分析与优化、开发环境的配置、数据集的准备、模型训练和推理过程、结果的评估与验证、模型的导出以及实际部署，文中还配有手绘的网络结构图，帮助大家更直观地理解YOLOv13。
YOLOv13简单介绍：YOLOv13来源于清华大学、北京理工大学、香港科技大学（广州）、西安交通大学，相对于YOLOv12主要有三点创新：
1、引入了 HyperACE（Hypergraph-based Adaptive Correlation Enhancement）机制，用于捕捉全局高阶多对多语义关系，
2、提出 FullPAD（Full-Pipeline Aggregation-and-Distribution）架构，将增强特征贯穿于 backbone、neck、head 全流程，
3、采用 depthwise separable convolution 构建轻量模块，减少模型复杂度。
官方代码地址：官方代码地址点击此处即可跳转
官方论文地址：官方论文地址点击此处即可跳转
YOLOv13手绘网络结构图，图片较大如果文章展示不清楚可点击此处链接跳转原图地址：点击此处
专栏地址：YOLOv13有效涨点专栏 | 包含卷积、主干、检测头、注意力机制、Neck上百种创新机制
目录
一、本文介绍
二、YOLOv13原理解析
2.1 YOLOv13的yaml文件和创新点对应解析
2.2 YOLOv13主要创新点解析
2.2.1 HyperACE机制
2.2.2 FullPAD机制
2.2.3 DSC3k2模块
2.2.4 创新点总结
三、YOLOv13改进
四、环境搭建
五、数据集获取
六、模型获取
七、模型训练
7.1 训练的二种方式
7.1.1 方式一（个人不推荐）
7.1.2 方式二 （推荐，避免keyError错误.）
八、模型验证/测试
九、模型推理
十、模型输出
十一、全文总结
二、YOLOv13原理解析
在前面我们总结了YOLOv13的主要创新点为三点：
1、引入了 HyperACE（Hypergraph-based Adaptive Correlation Enhancement）机制，用于捕捉全局高阶多对多语义关系，
2、提出 FullPAD（Full-Pipeline Aggregation-and-Distribution）架构，将增强特征贯穿于 backbone、neck、head 全流程，
3、采用 depthwise separable convolution 构建轻量模块，减少模型复杂度。
2.2章节会针对这三点进行分别解析。
2.1 YOLOv13的yaml文件和创新点对应解析
下图是YOLOv13的yaml文件图，其中和YOLOv13创新点对应的部分我均已在图片中标出。
2.2 YOLOv13主要创新点解析
2.2.1 HyperACE机制
HyperACE核心代码.
class HyperACE(nn.Module): def __init__(self, c1, c2, n=1, num_hyperedges=8, dsc3k=True, shortcut=False, e1=0.5, e2=1, context=\"both\", channel_adjust=True): super().__init__() self.c = int(c2 * e1) self.cv1 = Conv(c1, 3 * self.c, 1, 1) self.cv2 = Conv((4 + n) * self.c, c2, 1) self.m = nn.ModuleList( DSC3k(self.c, self.c, 2, shortcut, k1=3, k2=7) if dsc3k else DSBottleneck(self.c, self.c, shortcut=shortcut) for _ in range(n) ) self.fuse = FuseModule(c1, channel_adjust) self.branch1 = C3AH(self.c, self.c, e2, num_hyperedges, context) self.branch2 = C3AH(self.c, self.c, e2, num_hyperedges, context) def forward(self, X): x = self.fuse(X) y = list(self.cv1(x).chunk(3, 1)) out1 = self.branch1(y[1]) out2 = self.branch2(y[1]) y.extend(m(y[-1]) for m in self.m) y[1] = out1 y.append(out2) return self.cv2(torch.cat(y, 1))
HyperACE 是 YOLOv13 提出的核心模块，旨在解决以往 YOLO 模型只能建模“局部 pairwise 关联”的问题，扩展为能建模全局高阶多对多语义关系（multi-to-multi high-order correlations）| 这样做的坏处是会增加计算开支。
它通过引入超图计算、自适应高阶建模、分支融合，实现更强大的特征增强和表达能力，提升目标检测在复杂场景下的准确性。
HyperACE 模块包含 三大处理分支，共同处理融合后的特征：
分支 模块 功能 高阶建模分支1 C3AH自适应超图建模，全局高阶语义增强 高阶建模分支2 C3AH与上分支结构一致但独立参数，增强多样性 低阶建模分支 DSC3k或DSBottleneck局部空间建模，补充低阶特征 Shortcut 通道 残差直连（图片上的Identity操作） 保留原始信息，便于梯度传播 从上面表格可以看到HyperACE主要的结构就是CSAH和DSC3k/DSBottleneck模块，下面继续分别解析。
C3AH高阶建模分支，高阶建模分支1和高阶建模分支2的为一区别是参数不一样增加建模多样性。C3AH 将 CSP 架构与自适应超图注意力机制相融合，实现在轻量条件下建模全局高阶语义关系。
上面提到了CSP结构， 我们先简单介绍一下什么是CSP架构：将特征图分成两部分，一部分不经过主干模块直接跳连，另一部分经过主干模块处理，然后两部分再融合（其实可以理解为残差结构的扩展，我们所谓C2f、C3、C3k2都是CSP架构下的衍生品）。 CSAH上的虚线标记的地方是一个整体（ AdaHGComputation ），又细分为两个模块
class AdaHGConv(nn.Module): def __init__(self, embed_dim, num_hyperedges=16, num_heads=4, dropout=0.1, context=\"both\"): super().__init__() self.edge_generator = AdaHyperedgeGen(embed_dim, num_hyperedges, num_heads, dropout, context) self.edge_proj = nn.Sequential( nn.Linear(embed_dim, embed_dim ), nn.GELU() ) self.node_proj = nn.Sequential( nn.Linear(embed_dim, embed_dim ), nn.GELU() ) def forward(self, X): A = self.edge_generator(X) He = torch.bmm(A.transpose(1, 2), X) He = self.edge_proj(He) X_new = torch.bmm(A, He) X_new = self.node_proj(X_new) return X_new + Xclass AdaHGComputation(nn.Module): def __init__(self, embed_dim, num_hyperedges=16, num_heads=8, dropout=0.1, context=\"both\"): super().__init__() self.embed_dim = embed_dim self.hgnn = AdaHGConv( embed_dim=embed_dim, num_hyperedges=num_hyperedges, num_heads=num_heads, dropout=dropout, context=context ) def forward(self, x): B, C, H, W = x.shape tokens = x.flatten(2).transpose(1, 2) tokens = self.hgnn(tokens) x_out = tokens.transpose(1, 2).view(B, C, H, W) return x_out
- AdaHyperedgeGen：根据上下文自适应生成超边
- AdaHGConv：高阶超图卷积（顶点→超边→顶点）
AdaHyperedgeGen和AdaHGConv核心代码
class AdaHyperedgeGen(nn.Module): def __init__(self, node_dim, num_hyperedges, num_heads=4, dropout=0.1, context=\"both\"): super().__init__() self.num_heads = num_heads self.num_hyperedges = num_hyperedges self.head_dim = node_dim // num_heads self.context = context self.prototype_base = nn.Parameter(torch.Tensor(num_hyperedges, node_dim)) nn.init.xavier_uniform_(self.prototype_base) if context in (\"mean\", \"max\"): self.context_net = nn.Linear(node_dim, num_hyperedges * node_dim) elif context == \"both\": self.context_net = nn.Linear(2*node_dim, num_hyperedges * node_dim) else: raise ValueError( f\"Unsupported context \'{context}\'. \" \"Expected one of: \'mean\', \'max\', \'both\'.\" ) self.pre_head_proj = nn.Linear(node_dim, node_dim) self.dropout = nn.Dropout(dropout) self.scaling = math.sqrt(self.head_dim) def forward(self, X): B, N, D = X.shape if self.context == \"mean\": context_cat = X.mean(dim=1) elif self.context == \"max\": context_cat, _ = X.max(dim=1) else: avg_context = X.mean(dim=1) max_context, _ = X.max(dim=1) context_cat = torch.cat([avg_context, max_context], dim=-1) prototype_offsets = self.context_net(context_cat).view(B, self.num_hyperedges, D) prototypes = self.prototype_base.unsqueeze(0) + prototype_offsets X_proj = self.pre_head_proj(X) X_heads = X_proj.view(B, N, self.num_heads, self.head_dim).transpose(1, 2) proto_heads = prototypes.view(B, self.num_hyperedges, self.num_heads, self.head_dim).permute(0, 2, 1, 3) X_heads_flat = X_heads.reshape(B * self.num_heads, N, self.head_dim) proto_heads_flat = proto_heads.reshape(B * self.num_heads, self.num_hyperedges, self.head_dim).transpose(1, 2) logits = torch.bmm(X_heads_flat, proto_heads_flat) / self.scaling logits = logits.view(B, self.num_heads, N, self.num_hyperedges).mean(dim=1) logits = self.dropout(logits) return F.softmax(logits, dim=1)class AdaHGConv(nn.Module): def __init__(self, embed_dim, num_hyperedges=16, num_heads=4, dropout=0.1, context=\"both\"): super().__init__() self.edge_generator = AdaHyperedgeGen(embed_dim, num_hyperedges, num_heads, dropout, context) self.edge_proj = nn.Sequential( nn.Linear(embed_dim, embed_dim ), nn.GELU() ) self.node_proj = nn.Sequential( nn.Linear(embed_dim, embed_dim ), nn.GELU() ) def forward(self, X): A = self.edge_generator(X) He = torch.bmm(A.transpose(1, 2), X) He = self.edge_proj(He) X_new = torch.bmm(A, He) X_new = self.node_proj(X_new) return X_new + X下面我们来逐个深入分析 两个核心的高阶建模组件：
开始之前简单介绍两个概念（节点和超边）：节点是图像中的位置特征，超边是可学习的语义组中心（两个节点之间的线）；通过动态学习每个节点对各个超边的参与度，模型能建模图像中多个区域之间的高阶语义关系，实现更强的上下文感知和目标检测能力。
🧩 1.
AdaHyperedgeGen：自适应超边生成模块📌 它的作用：
在传统图卷积中，边（连接）是静态、固定的，而
AdaHyperedgeGen实现了：✅ 根据输入特征动态生成每个超边与节点的关系（可学习的参与度）
✅ 自动发现图中潜在的高阶语义结构，而不是手工设定连接规则
📐 输入 & 输出：
输入：顶点特征
X ∈ (B, N, D)
B：batch size
N：顶点数量（flatten 的空间位置）
D：特征维度（通道数）
输出：参与度矩阵 A ∈ (B, N, M)
每个值
A[i,j]表示：第i个顶点在第j个超边中参与的权重（注意力权重）
🧠 模块结构拆解：
✅ Step 1：提取全局上下文
context_cat = torch.cat([X.mean(dim=1), X.max(dim=1)], dim=-1) # shape: (B, 2D)
全局平均池化 + 最大池化 → 提取整个图的“全局语义背景”
✅ Step 2：生成动态超边原型
prototype_offsets = self.context_net(context_cat) # (B, M, D)prototypes = self.prototype_base.unsqueeze(0) + prototype_offsets
每个样本生成
M个超边原型（prototype vectors）这些 prototype 是图中“潜在语义组”的中心表示
✅ Step 3：计算相似度（参与度）
logits = dot_product(X_heads, proto_heads) # shape: (B, N, M)A = softmax(logits, dim=1)
采用多头注意力机制：对每个顶点与每个超边原型进行点积相似度计算
用 softmax 得到 每个顶点对每个超边的参与度 A[i,j]
📌 关键特点：A 是 连续的、可学习的，不再是离散 {0,1} 的图连接结构。
🧩 2.
AdaHGConv：自适应超图卷积模块📌 它的作用：
通过
AdaHyperedgeGen得到参与度矩阵A后，AdaHGConv完成以下两个步骤：
从顶点聚合到超边（Vertex → Edge）
从超边再传播回顶点（Edge → Vertex）
残差连接 + 投影 → 输出增强后的顶点特征
📐 输入 & 输出：
输入：顶点特征
X ∈ (B, N, D)输出：增强后的顶点特征
X_out ∈ (B, N, D)
🧠 工作流程拆解：
✅ Step 1：获取参与度矩阵 A
A = self.edge_generator(X) # A: (B, N, M)
通过
AdaHyperedgeGen获取顶点对每个超边的参与度✅ Step 2：顶点 → 超边（特征聚合）
He = torch.bmm(A.transpose(1, 2), X) # (B, M, D)He = self.edge_proj(He)
使用 A 作为加权聚合矩阵，将顶点特征聚合到 M 个超边中
edge_proj: 是一个线性层 + GELU 激活✅ Step 3：超边 → 顶点（特征传播）
X_new = torch.bmm(A, He) # (B, N, D)X_new = self.node_proj(X_new)
再将超边的特征传播回各个顶点
注意：此处传播仍然基于参与度 A
✅ Step 4：残差连接
return X_new + X
增强后的特征与原始特征相加，保留原始信息通路，避免退化
🔍 总结两个模块的逻辑关系：
[顶点特征 X] ↓ ┌──────────────────────┐ │ AdaHyperedgeGen │ ← 提取上下文 → 生成超边原型 → 得到 A: (B, N, M) └──────────────────────┘ ↓ ┌──────────────────────┐ │ AdaHGConv │ │ Step1: A^T @ X → He│ ← 顶点 → 超边聚合 │ Step2: A @ He → X\' │ ← 超边 → 顶点更新 │ Step3: + Residual │ └──────────────────────┘ ↓[增强后的顶点特征 X\']
✅ 总结一句话：
AdaHyperedgeGen 自适应生成可学习的超边结构，AdaHGConv 则完成顶点和超边之间的高阶信息流动与增强。这一整套模块使得 YOLOv13 拥有了对图像区域间复杂、高阶语义关系的建模能力。
C3AH整体过程：
将 feature map (B, C, H, W) 展平为 (B, N, C)
超图建模建成邻接关系，提取跨区域语义关系
恢复到原来的形状 (B, C, H, W)
HyperACE在细节的部分就不多介绍了，大家有兴趣可以根据代码进行观看。
2.2.2 FullPAD机制
YOLOv13创新最大和最复杂的结构就是HyperACE，剩下的FullPAD和DSC3k2都是很简单的创新，我们接下来介绍FullPAD结构。
FullPAD核心代码.
class FullPAD_Tunnel(nn.Module): def __init__(self): super().__init__() self.gate = nn.Parameter(torch.tensor(0.0)) def forward(self, x): out = x[0] + self.gate * x[1] return out
大家从代码中就可以看出FullPad结构十分简单,我下面帮助大家来理解该结构.
🔍 一、FullPAD 本质上是什么？
FullPAD 的本质就是一个加权融合模块（大家记得BiFPN的加权模块这里和那个基本一致）：
将来自HyperACE的增强特征按比例注入到下游的原始特征中，形成新的语义更强的特征图。
🧪 二、
FullPAD_Tunnel是如何工作的？class FullPAD_Tunnel(nn.Module): def __init__(self): super().__init__() self.gate = nn.Parameter(torch.tensor(0.0)) # 初始为 0，可学习 def forward(self, x): out = x[0] + self.gate * x[1] return out🚦 输入：
x[0] = 原始特征 (比如来自 backbone 的 Bi)x[1] = 增强特征 (比如来自 HyperACE 的 Hi)⚙️ 处理：
输出 = 原始特征 + γ × 增强特征
γ = self.gate是一个可学习的比例参数；也就是说，模型可以自动学习在每个阶段应该注入多少“高阶增强信息”；
若 γ → 0，表示不注入；若 γ → 1，表示充分融合。
📌 三、这个结构为什么有效？
✅ 非常轻量（只有一个参数 γ）
✅ 适应性强：可以根据具体特征阶段学出不同融合强度
✅ 不会破坏原始结构：融合方式温和，残差式注入
✅ 避免信息冗余或过拟合：γ 可以调低，模型决定是否用
🎓 四、通过例子更好理解
假设我们在看一幅图像，原始 backbone 提取了它的基本纹理和结构信息，而 HyperACE 提供了这幅图像中“语义对象之间的高阶关系”。
FullPAD 就像是“在原始特征上撒点调味料”，调味多少由
gate参数决定，撒多撒少模型自己来学。所以：
gate = 0→ 你就吃原味（不加高阶语义）
gate = 1→ 你加了调料，风味更丰富
✅ 五、一句话总结：
FullPAD 是 YOLOv13 中用于“注入语义增强信息”的加权融合单元，其结构极其简单但机制灵活，借助可学习控制参数gate控制语义注入强度，实现高效的全流程特征共享与语义流动（后面改进专栏里我会将其升级为更高级的特征融合）
2.2.3 DSC3k2模块
DSC3k2模块其实相较于C3k2模块的创新很简单，就是用两个深度可分离卷积替换了普通的卷积（这么做的目的是为了弥补HyperACE和FullPAD机制增加的计算量和参数量），
下面这个是C3k2的网络结构图（注意不是DSC3k2）.
下面这个是DSC3k2的网络结构图，其实两者的区别就是在Bottleneck中的Conv换为了DSConv（不是蛇形卷积是深度可分离卷积）。
上面我们介绍了DSC3k2和C3k2的区别，主要区别是在DSConv，下面我们来仔细介绍一下DSConv的工作原理，在介绍DSConv之前需要先学习DWConv也就是深度卷积。
DWConv代表 Depthwise Convolution（深度卷积），是一种在卷积神经网络中常用的高效卷积操作。它主要用于减少计算复杂度和参数量，尤其在移动端或轻量化网络（如 MobileNet）中十分常见。1. 标准卷积的计算过程
在标准卷积操作中，对于一个输入张量（通常是一个多通道的特征图），卷积核的尺寸是
(h, w, C_in)，其中h和w是卷积核的空间尺寸，C_in是输入通道的数量。而卷积核与输入张量做的是完整的卷积运算，每个输出通道都与所有输入通道相连并参与卷积操作，导致计算量比较大。标准卷积的计算过程是这样的：
- 每个输出通道是所有输入通道的组合（加权求和），卷积核在每个位置都会计算与所有输入通道的点积。
- 假设有
C_in个输入通道和C_out个输出通道，那么卷积核的总参数量是C_in * C_out * h * w。2. Depthwise Convolution（DWConv）
与标准卷积不同，深度卷积将输入的每个通道单独处理，即每个通道都有自己的卷积核进行卷积，不与其他通道进行交互。它可以被看作是标准卷积的一部分，专注于空间维度上的卷积运算。
深度卷积的计算过程：
- 假设输入张量有
C_in个通道，每个通道会使用一个h × w的卷积核进行卷积操作。这个过程称为“深度卷积”，因为每个通道独立进行卷积运算。- 输出的通道数与输入通道数一致，每个输出通道只和对应的输入通道进行卷积，没有跨通道的组合。
- 参数量和计算量相比标准卷积大大减少，卷积核的参数量是
C_in * h * w。深度卷积的优点：
- 计算效率高：相对于标准卷积，深度卷积显著减少了计算量。它只处理空间维度上的卷积，不再处理通道间的卷积。
- 参数量减少：由于每个卷积核只对单个通道进行卷积，参数量大幅减少。例如，标准卷积的参数量为
C_in * C_out * h * w，而深度卷积的参数量为C_in * h * w。- 结合点卷积可提升效果：为了弥补深度卷积缺乏跨通道信息整合的问题，通常深度卷积后会配合
1x1的点卷积（Pointwise Convolution）使用，通过1x1的卷积核整合跨通道的信息。这种组合被称为深度可分离卷积（Depthwise Separable Convolution） | 这也是我们本文YOLOv11中的做法。3. 深度卷积与标准卷积的区别
操作类型 卷积核大小 输入通道数 输出通道数 参数量 标准卷积 h × wC_inC_outC_in * C_out * h * w深度卷积（DWConv） h × wC_inC_inC_in * h * w可以看出，深度卷积在相同的卷积核大小下，参数量减少了约
C_out倍 （细心的人可以发现用最新版本的ultralytics仓库运行YOLOv8参数量相比于之前的YOLOv8以及大幅度减少了这就是因为检测头改了的原因但是名字还是Detect，所以如果你想继续用YOLOv8发表论文做实验那么不要更新最近的ultralytics仓库）。4. 深度可分离卷积 (Depthwise Separable Convolution)
深度卷积常与
1x1的点卷积配合使用，这称为深度可分离卷积。其过程如下：
- 先对输入张量进行深度卷积，对每个通道独立进行空间卷积。
- 然后通过
1x1点卷积，对通道维度进行混合，整合不同通道的信息。这样既可以保证计算量的减少，又可以保持跨通道的信息流动。
5. 总结
DWConv是一种高效的卷积方式，通过单独处理每个通道来减少计算量，结合1x1的点卷积，形成深度可分离卷积，可以在保持网络性能的同时极大地减少模型的计算复杂度和参数量。
2.2.4 创新点总结
YOLOv13就是通过上面三点创新成为新的实时目标检测器SOTA，更多关于YOLO的基础知识大家可以看我往期教程，这里仅介绍YOLOv13相较于前身YOLOv12的创新.
三、YOLOv13改进
YOLOv13继续沿用了ultralytics仓库，所以其改进方式基本上和前几代YOLO的改进方式一致，YOLOv13具体可以改进的点可以分为主干卷积（特征提取作用）、DSC3k2、颈部（YOLOv13的颈部特殊不能沿用其他系列的颈部）、损失函数、检测头除此之外更为细节的改进比如修改FullPAD结构，HyperACE中的注意力机制。
具体的改进方式大家可以关注我的专栏后续会出的免费改进文字教程和视频讲解（入Qq群获得视频讲解）
四、环境搭建
大家如果没有搭建环境可以看我的另一篇博客，里面讲述了如何搭建pytorch环境。
Win12上Pytorch的安装并在Pycharm上调用PyTorch最新超详细过程并附详细的系统变量添加过程,可解决pycharm中pip不好使的问题
在我们配置好环境之后，在之后模型获取完成之后，我们可以进行配置的安装我们可以在命令行下输入如下命令进行环境的配置。
pip install -e .输入如上命令之后我们就可以看到命令行在安装模型所需的库了。
如果不会安装可以联系博主入群获得视频安装教程，不仅包含本地环境搭建视频教程，也有服务器环境搭建教程.
五、数据集获取
在我们开始训练之前，我们需要一份数据集,如何获取一个YOLOv13的数据集大家可以看我的另一篇博客从YOLO官方指定的数据集网站Roboflow下载数据模型训练
超详细教程YoloV13官方推荐免费数据集网站Roboflow一键导出Voc、COCO、Yolo、Csv等格式
我在上面随便下载了一个 数据集用它导出yolov13的数据集，以及自动给转换成txt的格式yaml文件也已经配置好了，我们直接用就可以。
值得注意的是YOLO系列的数据集是通用的，不具体区分YOLO的版本.
六、模型获取
官方模型下载地址（唯一推荐方法，不易报错）：模型下载地址点击此处即可跳转
点进去之后按照如下图所示的操作即可下载ultralytics仓库到本地.
七、模型训练
我们在训练过程中有一系列的参数（超参数）具体都存放在该目录下\'ultralytics/cfg/default.yaml\'
我门打开cfg目录下的default.yaml文件可以配置模型的参数，
在其中和模型训练有关的参数及其解释如下（其实大家改进发论文过程中这些参数不推荐大家修改因为要确保实验参数的统一）:
参数cache用于控制是否启用缓存机制。bool
rect 设置为 True 时，表示启用矩形训练或验证。矩形训练或验证是一种数据处理技术，其中在训练或验证过程中，输入数据会被调整为具有相同宽高比的矩形形状。cos_lr
n 层或指定层索引的列表，以防止它们的权重更新。这对于迁移学习或特定层的微调很有用。7.1 训练的二种方式
7.1.1 方式一（个人不推荐）
我们可以通过命令直接进行训练在其中指定参数，但是这样的方式，我们每个参数都要在其中打出来。命令如下:
yolo task=detect mode=train model=yaml文件地址 data=数据集地址 batch=16 epochs=100 imgsz=640 workers=0 device=0需要注意的是如果你是Windows系统的电脑其中的Workers最好设置成0否则容易报线程的错误。
最需要注意的是如果你通过pip下载的环境不是YOLOv13的则是无法通过上面的命令训练会报错寻找不到对应的模块.
7.1.2 方式二 （推荐，避免keyError错误.）
我们可以通过创建py文件来进行训练，这样的好处就是不用在终端上打命令，这也能省去一些工作量，我们在根目录下创建一个名字为train.py的文件，在其中输入代码。
import warningswarnings.filterwarnings(\'ignore\')from ultralytics import YOLOif __name__ == \'__main__\': model = YOLO(r\'yolov13.yaml\') # 续训yaml文件的地方改为lats.pt的地址,需要注意的是如果你设置训练200轮次模型训练了200轮次是没有办法进行续训的. # 如何切换模型版本, 上面的ymal文件可以改为 yolov13s.yaml就是使用的v13s, # 类似某个改进的yaml文件名称为yolov13-XXX.yaml那么如果想使用其它版本就把上面的名称改为yolov13l-XXX.yaml即可（改的是上面YOLO中间的名字不是配置文件的）！ # model.load(\'yolov13n.pt\') # 是否加载预训练权重,科研不建议大家加载否则很难提升精度 model.train(data=r\"本地数据集yaml文件地址\", # 数据集的地址也可以填写官方的但是会进行下载ultralytics/cfg/datasets/coco128.yaml # 如果大家任务是其它的\'ultralytics/cfg/default.yaml\'找到这里修改task可以改成detect, segment, classify, pose task=\'detect\', cache=False, imgsz=640, epochs=100, single_cls=False, # 是否是单类别检测 batch=1, close_mosaic=0, workers=0, device=\'0\', optimizer=\'SGD\', # using SGD 优化器 默认为auto建议大家使用固定的. # resume=, # 续训的话这里填写True amp=True, # 如果出现训练损失为Nan可以关闭amp project=\'runs/train\', name=\'exp\', )无论通过上述的哪一种方式在控制台输出如下图片的内容就代表着开始训练成功了！
八、模型验证/测试
验证我们划分的验证集/测试集的情况，也就是评估我们训练出来的best.pt模型好与坏
方法一：
yolo task=detect mode=val model=best.pt data=data.yaml device=0方法二（推荐）：
import warningswarnings.filterwarnings(\'ignore\')from ultralytics import YOLOif __name__ == \'__main__\': model = YOLO(\'替换大家想要训练的模型地址\') model.val(data=r\'替换大家自己的数据集文件的yaml文件地址\', split=\'val\', imgsz=640, batch=16, # rect=False, # save_json=True, # 这个保存coco精度指标的开关 project=\'runs/val\', name=\'exp\', )
九、模型推理
我们训练好自己的模型之后，都会生成一个模型文件,保存在你设置的目录下,当我们再次想要实验该模型的效果之后就可以调用该模型进行推理了，我们也可以用官方的预训练权重来进行推理。
推理的方式和训练一样我们这里就选一种来进行举例其它的两种方式都是一样的操作只是需要改一下其中的一些参数即可:
参数讲解
.txt 文件方法一：
yolo task=detect mode=predict model=best.pt source=images device=0方法二（推荐）：
import warningswarnings.filterwarnings(\'ignore\')from ultralytics import YOLOif __name__ == \'__main__\': model = YOLO(\'训练出来的权重文件地址\') # select your model.pt path model.predict(source=\'想要检测文件的地址\', imgsz=640, project=\'runs/detect\', name=\'exp\', save=True, classes=1, # 是否指定检测某个类别. )
这里需要需要注意的是我们用模型进行推理的时候可以选择照片也可以选择一个视频的格式都可以。支持的视频格式有 ：
MP4（.mp4）：这是一种常见的视频文件格式，通常具有较高的压缩率和良好的视频质量
AVI（.avi）：这是一种较旧但仍广泛使用的视频文件格式。它通常具有较大的文件大小
MOV（.mov）：这是一种常见的视频文件格式，通常与苹果设备和QuickTime播放器相关
MKV（.mkv）：这是一种开放的多媒体容器格式，可以容纳多个视频、音频和字幕轨道
FLV（.flv）：这是一种用于在线视频传输的流式视频文件格式
十、模型输出
当我们进行部署的时候可以进行文件导出，然后在进行部署。
1. ONNX（Open Neural Network Exchange）：ONNX 是一个开放的深度学习模型表示和转换的标准。它允许在不同的深度学习框架之间共享模型，并支持跨平台部署。导出为 ONNX 格式的模型可以在支持 ONNX 的推理引擎中进行部署和推理。
2. TensorFlow SavedModel：TensorFlow SavedModel 是 TensorFlow 框架的标准模型保存格式。它包含了模型的网络结构和参数，可以方便地在 TensorFlow 的推理环境中加载和使用。
3. PyTorch JIT（Just-In-Time）：PyTorch JIT 是 PyTorch 的即时编译器，可以将 PyTorch 模型导出为优化的 Torch 脚本或 Torch 脚本模型。这种格式可以在没有 PyTorch 环境的情况下进行推理，并且具有更高的性能。
4. Caffe Model：Caffe 是一个流行的深度学习框架，它使用自己的模型表示格式。导出为 Caffe 模型的文件可以在 Caffe 框架中进行部署和推理。
5. TFLite（TensorFlow Lite）：TFLite 是 TensorFlow 的移动和嵌入式设备推理框架，支持在资源受限的设备上进行高效推理。模型可以导出为 TFLite 格式，以便在移动设备或嵌入式系统中进行部署。
6. Core ML（Core Machine Learning）：Core ML 是苹果的机器学习框架，用于在 iOS 和 macOS 上进行推理。模型可以导出为 Core ML 格式，以便在苹果设备上进行部署。
这些格式都提供了不同的优势和适用场景。选择合适的导出格式应该考虑到目标平台和部署环境的要求，以及所使用的深度学习框架的支持情况。
模型输出的参数有如下
命令行命令如下:
yolo task=detect mode=export model=best.pt format=onnx
十一、全文总结
在末尾再给大家说一下，YOLO系列目前发展的比较快，大家可能会感到很迷茫不知道如何选择模型来作为改进的基准，其实更简易大家选择ultralytics出品的YOLOv11和YOLOv8，因为其结构更简单和纯粹更有利于改进。
到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv13有效涨点专栏，本专栏目前为新开的，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~
专栏地址：YOLOv13有效涨点专栏 | 包含卷积、主干、检测头、注意力机制、Neck上百种创新机制
