YOLO 的实例分割（Instance Segmentation）其实是在YOLO 检测（Object Detection）的基础上增加了一条Mask 分支。

很多人学习 YOLO Seg 的时候容易陷入代码（Segment Head、Proto、Coeff），但是如果没有理解整个思想，看源码会很痛苦。

建议按照下面这个顺序理解：

图像分割是什么 → 为什么YOLO能够做分割 → YOLO Seg整体结构 → Mask如何生成 → Loss如何训练 → 推理过程 → 与Mask R-CNN区别 → YOLOv8/YOLO11源码分析

一、先理解什么叫实例分割

我们先看看几个任务：

输入图片 ↓ Classification（分类） ↓ 猫 ------------------------------------ Detection（检测） ↓ ┌─────────┐ │ 猫 │ └─────────┘ ------------------------------------ Semantic Segmentation（语义分割） ↓ ██████████ ██████████ 所有猫都是同一种颜色 ------------------------------------ Instance Segmentation（实例分割） ↓ ██ ████ ██ ████ 每只猫都是一个独立mask

YOLO Seg做的是：

Instance Segmentation（实例分割）

输出：

类别 bbox score mask

例如

person bbox confidence mask dog bbox confidence mask

所以：

一个目标 =

bbox + mask

二、为什么YOLO能够做分割？

YOLO本来就是：

Backbone ↓ Neck ↓ Detection Head

输出：

类别 位置 置信度

那如果要做分割怎么办？

答案非常简单：

再预测一个Mask。

所以YOLO Seg变成：

Backbone │ Neck(PAFPN) ┌──────────────┐ │ │ Detection Head Mask Head

检测Head负责：

bbox cls score

Mask Head负责：

mask

但是问题来了。

如果每个目标直接预测：

640×640 = 409600个像素

假设：

100个目标

就是

409600 ×100 ≈4000万个数

太大了。

所以YOLO采用了一种非常聪明的方法。

三、YOLO Seg最大的创新——Prototype Mask

YOLO Seg并不是：

每个目标预测一个完整Mask。

而是：

所有目标共享一套Mask模板（Prototype），每个目标只预测组合系数（Coefficient）。

这就是论文最大的思想。

可以理解成：

先生成 32张基础Mask 然后每个目标告诉你： 这些Mask怎么组合。

举个例子。

网络输出：

Prototype 32 × 160 × 160

可以理解成：

Proto1 Proto2 Proto3 ... Proto32

例如：

Proto1

████ ████

Proto2

■■■■

Proto3

▒▒▒▒

…

这些Mask没有任何意义。

它们不是：

人 车 狗

而是：

一些基础纹理。

有点像：

PCA里的基。

或者：

神经网络自动学习出来的Basis。

四、每个目标只预测32个系数

例如：

检测Head输出：

bbox cls score coeff

coeff就是：

32维 例如 [ 0.2 -1.1 0.5 ... ]

那么最终Mask就是：

Mask = Coeff × Prototype

数学表达：

M = Σ ci × Proto_i

例如：

Mask = 0.2×Proto1 + 1.5×Proto2 - 0.8×Proto3 ...

于是：

32张模板

组合出来

这一只狗。

另一只狗：

coeff 不同

所以：

生成另一张Mask。

五、整个网络结构

YOLO Seg可以画成：

输入640×640 │ Backbone │ Neck(FPN) ┌──────────────┐ │ │ Detection Head Proto Head

Detection Head输出：

每个Anchor Point：

bbox cls score 32 coeff

Proto Head输出：

32 × 160 × 160

注意：

Proto只有一份。

所有目标共享。

六、为什么Proto只有160×160？

640输入：

YOLO一般：

Stride=4

所以：

640 ↓ 160

Proto大小：

160×160

为什么不用：

640×640？

原因就是：

计算太大。

160×160：

25600

640×640：

409600

差了：

16倍。

所以：

YOLO最后：

Mask生成以后：

再Upsample回：

原图大小。

七、Mask是怎么生成的？

假设：

Proto：

32 × 160 × 160

Coeff：

32

首先：

把Proto展开：

32 × 25600

Coeff：

1 × 32

矩阵乘法：

1×32 × 32×25600 ↓ 1×25600

恢复：

160×160

就是：

Mask。

最后：

Sigmoid

得到：

0~1

每个像素：

都是：

概率。

八、为什么还要Crop？

生成出来Mask以后：

其实：

是整个图片的Mask。

例如：

████████████ ████████████ ████████████

但是：

检测框只有：

□□□□

于是：

YOLO：

只保留BBox内部。

外面全部：

0

就是：

Crop Mask。

这一步：

非常重要。

否则：

不同目标：

Mask会互相污染。

九、推理全过程

整个推理：

图片 ↓ Backbone ↓ Neck ↓ Detection Head ↓ bbox cls score coeff ↓ Proto Head ↓ Prototype ↓ Coeff×Prototype ↓ Mask ↓ Crop ↓ Upsample ↓ 最终Mask

整个过程就是：

BBox + Coeff + Prototype

十、Loss如何计算？

YOLO Seg总Loss：

Loss = Box Loss + Cls Loss + DFL Loss + Mask Loss

其中前三项与检测模型完全一致。

新增的是：

Mask Loss。

Mask Loss通常使用：

BCE Loss

即：

预测Mask VS GT Mask

逐像素计算：

Binary Cross Entropy。

有些版本也可以结合：

• Dice Loss
• Focal Loss

不过在 Ultralytics 的 YOLOv8/YOLO11 实现中，默认实例分割训练主要采用BCE 风格的 Mask Loss，检测部分仍然使用 Box、Classification 和 DFL 等损失。

十一、为什么Prototype方案这么优秀？

假设：

每个目标直接预测Mask：

100个目标 × 160×160 = 256万个像素

如果采用Prototype：

Proto： 32×160×160 = 819200 Coeff： 100×32 = 3200

总量约：

82万

相比直接预测：

减少了约3 倍以上的输出，而且目标越多优势越明显。

Prototype 只计算一次，后续每个目标只需要预测少量系数，因此：

• 内存占用更低
• 推理速度更快
• 更适合实时检测

这也是 YOLO Seg 能够保持实时性的关键原因之一。

十二、与 Mask R-CNN 的区别

Mask R-CNN的思路是：每个检测框都裁剪出一个 ROI，再单独预测一个小尺寸 Mask，因此计算量会随着目标数量增加而增加。

YOLO Seg则只生成一套共享 Prototype，每个目标预测一组系数进行线性组合，因此更高效。

十三、YOLOv8/YOLO11 分割 Head 的输出

以 640×640 输入为例，YOLOv8/YOLO11 的分割模型通常包含三个检测尺度（P3、P4、P5）以及一个 Prototype 分支。

大致输出如下（具体通道数会随类别数变化）：

Detection Head P3 bbox cls 32 coeff P4 bbox cls 32 coeff P5 bbox cls 32 coeff Proto Head 32×160×160

因此，每个候选目标最终都会拥有：

• 边界框（bbox）
• 类别（class）
• 置信度（score）
• 32 维 Mask 系数（coeff）

这些系数与共享的 Prototype 相乘后即可恢复该目标的实例 Mask。

十四、学习源码时建议重点关注的几个模块

如果你准备深入阅读 Ultralytics YOLOv8/YOLO11 的源码，建议重点理解下面几个模块，它们构成了整个实例分割流程：

1. Segment Head：在检测 Head 基础上增加 Mask Coefficient 的预测。
2. Proto Module（Proto Head）：生成共享的 Prototype Masks。
3. Mask 组合过程：将coeff × proto得到目标 Mask。
4. Crop Mask：依据预测框裁剪 Mask，仅保留目标区域。
5. Mask Loss：训练阶段计算预测 Mask 与真实 Mask 的误差。
6. 推理后处理：Mask 上采样到原图尺寸，并与检测结果一起输出。

十五、一张图总结整个 YOLO Seg 流程

输入图片 │ Backbone + Neck │ ┌────────────┴────────────┐ │ │ Detection Head Proto Head (bbox/cls/score/coeff) (32×160×160) │ │ └──────────┬──────────────┘ │ coeff × Prototype（矩阵乘法） │ 得到目标 Mask │ Crop 到预测框区域 │ Upsample 到原图尺寸 │ 输出 bbox + class + mask

核心总结

理解 YOLO 分割最重要的是把握三个核心思想：

1. 实例分割 = 检测 + Mask：YOLO 保留检测框预测，同时为每个目标增加一个实例 Mask。
2. 共享 Prototype + 每目标 Coefficient：网络只生成一套共享的 Prototype，每个目标只预测一组系数，通过线性组合得到自己的 Mask。这是 YOLO 实时实例分割的核心设计。
3. 推理流程：Backbone → Detection Head + Proto Head → coeff × proto → Crop → Upsample → 最终 Mask。

只要真正理解了Prototype、Coefficient 和线性组合这三个概念，再去阅读 Ultralytics 的Proto、SegmentHead 以及ops.process_mask()等源码，就会发现代码基本就是上述流程的工程化实现。