YOLOE: Real-Time Seeing Anything

来源: https://arxiv.org/abs/2503.07465
本地Markdown: ../raw/2025-03-10-yoloe.md
日期: 2025-03-10
标签: open-vocabulary detection, open-vocabulary segmentation, YOLO, visual prompt, prompt-free, re-parameterization
研究方向: 2D Object Detection → 开放词汇检测 → 统一多提示范式
作者: Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han, Guiguang Ding（清华大学）
代码: https://github.com/THU-MIG/yoloe
会议: ICCV 2025
引用: 72

摘要

问题：YOLO-World 仅支持文本提示，且直接使用 CLIP 文本嵌入未做精炼，视觉-语义对齐不够好。视觉提示方法（T-Rex2）依赖重量级 transformer，prompt-free 方法（GenerateU）依赖大语言模型（FlanT5-base 250M 参数），都不适合边缘部署。缺乏一个统一支持三种提示范式的高效模型。

方案：YOLOE——基于 YOLOv8/YOLO11 的统一开放词汇检测+分割框架，支持三种提示范式：

RepRTA（Re-parameterizable Region-Text Alignment）：轻量辅助网络精炼 CLIP 文本嵌入，推理时重参数化为零开销
SAVPE（Semantic-Activated Visual Prompt Encoder）：解耦语义分支+激活分支，轻量编码视觉提示
LRPC（Lazy Region-Prompt Contrast）：专用提示嵌入找目标 + 内置大词表检索类别名，无需语言模型

核心结果：

YOLOE-v8-S 在 LVIS 上超过 YOLO-Worldv2-S 3.5 AP，训练成本仅 1/3，推理快 1.4×
视觉提示：YOLOE-v8-L 超过 T-Rex2 3.3 APr，训练数据少 2×
Prompt-free：YOLOE-v8-L 超过 GenerateU 0.4 AP，参数少 6.3×
迁移 COCO：YOLOE-v8-L 比 YOLOv8-L 高 0.6 AP^b / 0.4 AP^m，训练时间仅 1/4

1. Introduction

现有方法的局限：

提示范式	代表方法	问题
文本提示	YOLO-World	直接用 CLIP 嵌入，未精炼；RepVL-PAN 融合开销大；仅文本提示
视觉提示	T-Rex2	transformer-heavy 设计，依赖额外视觉编码器，边缘部署困难
Prompt-free	GenerateU / DINO-X	依赖大语言模型（FlanT5-base 250M / OPT-125M），显存和延迟高
统一多提示	DINO-X	训练成本高，推理开销大，不适合边缘部署

YOLOE 的解法：

文本提示：不搞复杂跨模态融合（RepVL-PAN 那种），而是用轻量辅助网络精炼文本嵌入，推理时重参数化
视觉提示：解耦语义+激活，不用 heavy transformer
Prompt-free：将生成问题转为检索问题，用专用嵌入找目标+内置词表检索，无需 LLM

2.1 文本提示检测

GLIP：region-text 预训练；Grounding DINO：深度融合；YOLO-World：轻量级但 CLIP 嵌入未精炼
YOLOE 的改进：RepRTA 精炼文本嵌入 + 重参数化零开销

2.2 视觉提示检测

OWL-ViT / OV-DETR：用 CLIP 编码图像提示
T-Rex2：region-level 对比，但依赖重量级架构
YOLOE 的改进：SAVPE 轻量编码，解耦设计

2.3 Prompt-free 检测

GRiT：文本 decoder 生成描述；DetCLIPv3：object captioner
GenerateU：LLM 生成类别名
YOLOE 的改进：LRPC 将生成转检索，无需 LLM

3. Method

3.1 整体架构

┌─────────────────────────────────────────────────────────┐
│                      YOLOE 架构                         │
│                                                         │
│  ┌──────────────┐                                       │
│  │   Backbone   │  YOLOv8 / YOLO11 骨干网络            │
│  └──────┬───────┘                                       │
│         │                                               │
│  ┌──────┴───────┐                                       │
│  │     Neck     │  FPN + PAN 结构                      │
│  └──────┬───────┘                                       │
│         │                                               │
│  ┌──────┴──────────────────────────────────────┐        │
│  │          YOLOEDetect Head                    │        │
│  │                                              │        │
│  │  cv2: 边界框回归分支                         │        │
│  │  cv3: 分类特征分支 (输出 embed 维)            │        │
│  │  cv4: 对比学习头 (BNContrastiveHead)          │        │
│  │                                              │        │
│  │  ┌─────────────────────────────────────┐     │        │
│  │  │ 文本提示 → RepRTA (重参数化对齐)     │     │        │
│  │  │ 视觉提示 → SAVPE (语义激活编码器)    │     │        │
│  │  │ 无提示   → LRPC  (惰性区域-提示对比) │     │        │
│  │  └─────────────────────────────────────┘     │        │
│  └──────────────────────────────────────────────┘        │
│         │                                               │
│  ┌──────┴───────┐                                       │
│  │ YOLOESegment │  分割头 (Proto + mask coefficients)    │
│  └──────────────┘                                       │
└─────────────────────────────────────────────────────────┘

训练时前向流程（开放集）：

图像 → Backbone → Neck → x_i (多尺度特征图)
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
      cv2[i](x_i)    cv3[i](x_i)    (3个尺度)
      bbox回归        视觉嵌入         │
      [B,64,H,W]     [B,512,H,W]      │
                         │              │
                         ▼              │
               BNContrastiveHead       │
               ┌─────────────┐         │
               │ 1. BN(x)    │ ←── x (视觉嵌入 [B,512,H,W])
               │ 2. L2_norm(w)│ ←── w (文本嵌入，经RepRTA精炼+L2归一化)
               │ 3. einsum    │     w 形状: [B, C, 512]
               │    x·w^T    │
               │ 4. ×scale   │     logit_scale.exp()
               │ 5. +bias    │     bias = -10.0
               └──────┬──────┘
                      ▼
              分类分数 [B, C, H, W]    C=类别数(如LVIS 1203)
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
      cat(bbox, cls)          BCE Loss

推理时前向流程（fuse后，闭集等效）：

图像 → Backbone → Neck → x_i
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
      cv2[i](x_i)    cv3[i](x_i)    (3个尺度)
      bbox回归        [B,512,H,W]      │
                         │              │
                    Conv2d(512, C, 1)   │   ← 已经融合了BN+文本嵌入+scale+bias
                         │              │
                         ▼              │
                  分类分数 [B,C,H,W]    │
                         │             │
          ┌──────────────┴─────────────┘
          ▼
      cat(bbox, cls)  →  后处理(NMS等)

YOLOE 基于 YOLOv8/YOLO11 架构：

Backbone + PAN：提取多尺度特征
Regression Head（cv2）：边界框回归
Segmentation Head：原型+掩码系数（YOLACT 范式）
Object Embedding Head（cv3）：输出嵌入特征（维度=embed，如 512），而非固定类别 logits
Contrastive Head（cv4）：BNContrastiveHead，对象嵌入与提示嵌入的相似度匹配

与 YOLO-World Head 的对比：

	YOLO-World	YOLOE
cv2	bbox 回归	bbox 回归（相同）
cv3	特征投影到 embed 维	特征投影到 embed 维（相同）
cv4	BNContrastiveHead	BNContrastiveHead（相同）
文本嵌入来源	CLIP 直接输入 cv4	MobileCLIP → RepRTA 精炼 → cv4
提示类型	仅文本提示	文本(RepRTA) / 视觉(SAVPE) / 无提示(LRPC) 三统一

关键差异：YOLOE 在文本嵌入和 cv4 之间插了一个 RepRTA（Residual(SwiGLUFFN(embed, embed))），对 CLIP 嵌入做精炼对齐。YOLO-World 是 CLIP 嵌入直接进 cv4。这反映了两者对 CLIP 嵌入质量的不同判断：YOLO-World 认为够用直接用，YOLOE 认为存在对齐差距需要 RepRTA 修正。

核心公式：

Label = O · P^T : R^{N×D} × R^{D×C} → R^{N×C}

O：N 个 anchor point 的对象嵌入
P：C 个提示的嵌入
不同提示范式只改变 P 的来源

推理时 C 取决于提示类型：

文本提示：用户自定义类别名 → C = 用户类别数（如 COCO 80、VisDrone 10）
视觉提示：提供的 exemplar 图像数量 → C = 图像提示数
无提示 (LRPC)：内置 LVIS 1203 类词表 → C = 1203
fuse 后 C 固定（编码时确定），如 COCO 推理 → Conv2d(512, 80, 1)

3.2 RepRTA：可重参数化区域-文本对齐

问题：YOLO-World 直接用冻结 CLIP 文本嵌入，视觉-语义对齐不够。但引入复杂融合（如 RepVL-PAN）又增加开销。

方案：用轻量辅助网络精炼 CLIP 文本嵌入，推理时重参数化为零开销。

流程：

用 CLIP 文本编码器（MobileCLIP-B/LT）编码文本 T → 预训练文本嵌入 P = TextEncoder(T)
训练前缓存所有数据集的文本嵌入，文本编码器可移除（零训练成本）
RepRTA 辅助网络精炼嵌入：P' = Normalize(Residual(SwiGLUFFN)(P))
P' 作为分类权重，与对象嵌入做对比匹配

SwiGLUFFN 辅助网络：

代码：head.py: SwiGLUFFN + Residual
结构：Linear(embed, 4*embed) → chunk 为两半 → SiLU(x1) * x2 → Linear(2*embed, embed)
残差连接：x + SwiGLUFFN(x)
关键：w3 的 weight 和 bias 初始化为 0，所以初始时 RepRTA 输出 = 原始输入（恒等映射），训练逐步学会精炼
参数量极小（相比 RepVL-PAN 的 C2fAttn）

重参数化（6 步详细流程）：

训练时分类路径：cv3(x) → BN → einsum(w) → ×logit_scale → +bias 推理时 fuse 后：cv3(x) → Conv2d(512, C, 1)

Step 1：文本嵌入精炼

txt_feats [C, 512] → RepRTA(txt_feats) → L2_norm → txt_feats' [C, 512]

Step 2：乘以 logit_scale

t = txt_feats' × logit_scale.exp()  → t [C, 512]

logit_scale 是可学习标量（所有类别共用），作为 nn.Parameter 训练中自动学习最优值
训练时：score = (x · w^T) × scale + bias → BCEWithLogitsLoss
scale 控制 sigmoid 前的 logit 幅度：大→输出更自信(接近0/1)，小→更模糊(接近0.5)
fuse 时利用点积线性性：(x · w^T) × s = x · (w × s)^T，将 scale 提前乘进文本嵌入
初始化 -1.0（exp≈0.368）的原因：BN 后特征数值范围更大，不需要 CLIP 的 ln(1/0.07)≈2.66；太大→梯度爆炸，太小→学不动

Step 3：BN 融入卷积（fuse_conv_and_bn）

cv3 最后一个 Conv2d(512, 512, 1) + BatchNorm2d(512) → 融合为 Conv2d(512, 512, 1)（带 bias）

标准 Conv+BN 融合：W_new = γ/σ × W，b_new = γ/σ × (b_conv - μ) + β

Step 4：文本嵌入矩阵乘入卷积权重 ← 核心步骤

conv.weight: [512, 512, 1, 1] → squeeze → W_conv [512, 512]
conv.bias:   [512]  ← Step 3 融合后已包含原始 conv bias + BN 参数

新权重: W_new = t @ W_conv = [C, 512] @ [512, 512] = [C, 512]
新偏置: b_new = t @ b_conv + bias = [C, 512] @ [512] + (-10.0) = [C]

bias 初始化为 -10.0：sigmoid(-10) ≈ 4.5e-5 ≈ 0，训练初始时模型对所有类输出"几乎不存在"，让分类损失与 bbox 损失量级匹配，防止分类损失过大主导梯度

Step 5：替换最后一层

cls_h[-1] = Conv2d(512, C, kernel_size=1)
cls_h[-1].weight = W_new.unsqueeze(-1).unsqueeze(-1)  # [C, 512, 1, 1]
cls_h[-1].bias   = b_new                               # [C]

Step 6：清理

BNContrastiveHead.fuse() → 删除 norm/bias/logit_scale，forward 变成 identity
del reprta → reprta = nn.Identity()

数学等价性：

训练时: score = (BN(cv3(x)) · L2_norm(RepRTA(w))^T) × scale + bias
       = BN(cv3(x)) · t^T + bias           (令 t = L2_norm(RepRTA(w)) × scale)

fuse后: score = Conv2d_fused(x)
       = (t @ W_conv) · x + (t @ b_conv) + bias
       = t · (W_conv · x + b_conv) + bias
       = t · BN(cv3(x)) + bias
       = BN(cv3(x)) · t^T + bias           (点积对称性)

关键对比：

	训练时（开放集）	推理时（fuse后，闭集等效）
分类路径	cv3 → BN → einsum(w) → ×scale → +bias	cv3 → 单个 Conv2d(512, C, 1)
文本编码器	需要（在线编码类别名）	不需要（已融入权重）
RepRTA	需要（精炼文本嵌入）	已删除（Identity）
BNContrastiveHead	需要	已融合（forward 变 identity）
类别数 C	动态（LVIS 1203 / COCO 80 / 自定义）	固定（编码时确定）
与闭集 YOLO 区别	完全不同	完全一致

与 YOLO-World RepVL-PAN 的本质区别：

YOLO-World：在 Neck 中融合图文特征（Max Sigmoid Attention），改变视觉特征
YOLOE：在 Head 中精炼文本嵌入，不改变视觉特征流
YOLOE 的方式更轻量，且视觉特征路径完全不变，无需 C2fAttn 这种特殊模块

为什么用 MobileCLIP 而不是 CLIP？（论文 Roadmap Table 5 因果链）：

YOLO-World 用跨模态融合（RepVL-PAN），精度高但推理慢
YOLOE 为了速度砍掉跨模态融合 → AP 掉 1.9，但推理加速 1.28×
需要更好的文本嵌入来弥补 → 换 MobileCLIP-B/LT（比 CLIP 更强）→ 恢复 1.5 AP
再加 RepRTA 精炼 → +2.3 AP，其中 APr 暴涨 9.3（20.2→29.5）

MobileCLIP 不是随意选择，而是砍掉跨模态融合后的必要补偿——用更强的预训练嵌入弥补缺少视觉-文本交互带来的对齐损失

APr 暴涨 9.3 的原因：Rare 类别训练样本少，CLIP 本身的文本嵌入偏离视觉特征空间。RepRTA 用 SwiGLUFFN 对文本嵌入做非线性变换，学会把"CLIP 空间"的嵌入映射到"视觉特征空间"——本质是一个 learned projection，对 rare 类修正最大。

Grounding 数据负类采样改进（论文 Roadmap Table 5）：

YOLO-World v2 对 grounding 数据用空字符串做负类填充
YOLOE 改为维护全局词典（训练数据中出现≥100次的类别名）采样更有语义的负样本，带来 +0.9 AP
Grounding 数据的漏标问题：Flickr30k/GQA 一个名词短语通常只标一个框，图中有 3 只猫但只标 1 个，其他猫成为"未标注区域"被 BCE 当负样本。影响有限因为 O365 混合训练提供梯度纠正

3.3 SAVPE：语义激活视觉提示编码器

问题：视觉提示需要将裁剪的区域图像编码为嵌入，但直接 mask pooling 忽略了区域内不同位置的语义重要性差异。

方案：解耦为语义分支和激活分支，分别提取 prompt-agnostic 语义特征和 prompt-aware 加权系数。

代码结构（head.py: SAVPE）：

输入: x = [P3, P4, P5]（多尺度特征）, vp = 视觉提示 mask [B, Q, 1, H, W]

语义分支:
  cv1[i](x[i]) → Conv3×3 + Conv3×3 (+ Upsample 对齐尺度)
  拼接 → cv3: Conv2d(3*c3, embed, 1) → x_semantic [B, C, H, W]
  reshape → [B, C, H*W]

激活分支:
  cv2[i](x[i]) → Conv1×1 (+ Upsample 对齐尺度)
  拼接 → cv4: Conv2d(3*c3, A, 3, padding=1) → y_act [B, A, H, W]
  A=16 (group 数)
  
  y_act reshape → [B*Q, A, H, W]
  vp reshape → [B*Q, 1, H, W]
  
  cv5(vp): Conv2d(1, A, 3) → [B*Q, A, H, W]
  cv6(cat(y_act, cv5(vp))): Conv → Conv2d(A, A, 3) → [B*Q, A, H, W]
  
  score = y * vp + (not vp) * (-inf)  ← mask 外区域设为 -inf
  score = softmax(score, dim=-1)       ← A 个 group 各自的空间注意力
  
  aggregated = score^T @ x_semantic    ← 加权聚合语义特征
  输出: L2 归一化的提示嵌入 [B, Q, embed]

核心思想：

语义分支（cv1+cv3）：提取与具体提示无关的通用语义特征（prompt-agnostic）
激活分支（cv2+cv4+cv5+cv6）：根据视觉提示 mask 生成 A=16 组空间注意力权重（prompt-aware）
两组特征相乘聚合 → 得到该视觉提示对应的嵌入
A=16 时 A 组注意力可以关注不同语义维度（颜色/形状/纹理等），类似 multi-head attention

消融：

方法	AP
Mask pool（直接 mask pooling 聚合语义特征）	30.4
+ SAVPE (A=1)	31.5
+ SAVPE (A=16)	31.9

A=1 已比 mask pool +1.1 AP，A=16 再 +0.4 AP，A 更大收益递减

与 YOLO-World v2.1 Image Prompt 的区别：

维度	YOLO-World Image Prompt	YOLOE SAVPE
编码方式	CLIP 视觉编码器 + MLP adapter	直接用 PAN 多尺度特征
提示输入	裁剪的目标图像	二值 mask
与文本嵌入对齐	MLP 适配	解耦语义+激活，无额外适配
额外编码器	需要 CLIP Image Encoder	不需要，用已有的 PAN 特征
训练成本	仅训练 adapter（轻）	仅训练 SAVPE（2 epochs，更轻）

为什么高效？：

语义分支不融合视觉提示，D=512 维的大特征图计算一次即可复用（所有 Q 个提示共享）
激活分支在 A=16 维度（远小于 D=512）做视觉-图像交互，计算量极低

视觉提示 mask 的来源：

训练时：当前图像的 GT bbox → make_mask 生成二值 mask
推理时两种模式：
- 同图提示：在 source_image 上标 bbox → SAVPE 编码 → 在同一张图上检测更多同类物体
- 跨图提示：source_image 上的 bbox → SAVPE 编码得到 vpe → 缓存 → 在 target_image 上直接用缓存的 vpe，不再调用 SAVPE
评估时：每个类别采样 N=16 张训练图的 GT bbox，各自经 SAVPE 编码后取平均作为该类的视觉提示嵌入

与文本提示的关系：视觉提示嵌入和文本提示嵌入格式完全一致（[B, C, D]），在 YOLOEDetect.forward 中 pe = cat(tpe, vpe) 一起送入 BNContrastiveHead 做对比。

3.4 LRPC：惰性区域-提示对比

问题：Prompt-free 场景需要"找出所有目标并给类别名"，现有方法用 LLM 生成（FlanT5 250M），开销大。

方案：将生成问题转为检索问题——用专用嵌入找目标，再用内置大词表检索类别名。

流程：

训练一个专用提示嵌入 P_s，将所有目标视为同一类（"有东西" vs "无东西"）
推理时，用 P_s 对所有 anchor point 做筛选：
```
O' = {o ∈ O | o · P_s^T > δ}
```
1
δ 是阈值超参，过滤掉无目标的 anchor point
只对 O' 中的 anchor point 与内置大词表做对比匹配，检索类别名
内置词表：收集的大规模类别名列表，用 CLIP 编码为嵌入

惰性（Lazy）的含义：不是对所有 anchor 都做词表匹配，而是先筛选出有目标的 anchor，再做检索——跳过大量无目标的 anchor，大幅降低计算量。

代码（head.py: LRPCHead）：

pf：专用 prompt-free 嵌入（cv3 后接一个 1×1 Conv → 单通道 → sigmoid → 阈值筛选）
vocab：内置词表的线性层（由 Conv2d(1×1) 转换而来）
loc：定位头
forward：先用 pf 筛选 mask，再只对 mask 内的 anchor 做 vocab 检索

效率：

默认 8400 个 anchor point，LRPC(δ=1e-3) 后仅保留 ~20%，推理加速 1.7×（v8-S）
δ 可调节性能-效率 trade-off：
- δ=1e-2：加速 1.9×，仅 -0.2 AP
- δ=1e-3：加速 1.7×，AP 不变

与 GenerateU 的对比：

维度	GenerateU	YOLOE LRPC
范式	生成（LLM 生成类别名）	检索（内置词表匹配）
额外模型	FlanT5-base（250M）	无
延迟	高	低
灵活性	可生成任意描述	只能检索词表内类别

3.5 训练目标

分类：BCE loss，task-aligned label assignment
回归：IoU loss + DFL
分割：BCE loss 优化 mask
在线词表：与 YOLO-World 相同，每个 Mosaic 样本构建正+负类词表

4. Experiments

4.1 实现细节

模型：YOLOv8 + YOLO11 两种架构，S/M/L 三个尺度

文本编码器：MobileCLIP-B/LT（比 YOLO-World 用的 CLIP ViT-B/32 更轻量）

数据：

数据集	类型	图像数	标注数
Objects365V1	检测	609k	8,530k
GQA	Grounding	621k	3,662k
Flickr30k	Grounding	149k	638k

无 CC3M†：YOLOE 没有使用 YOLO-World 的伪标注图文数据
分割数据：用 SAM-2.1-Hiera-Large 从 GT 框生成伪实例 mask，高斯平滑+轮廓简化去噪
视觉提示数据：用 GT 框作为视觉提示区域
Prompt-free 数据：复用相同数据，但所有目标标注为同一类

训练（三阶段）：

文本提示训练：30 epochs（YOLO-World 训练 100 epochs，YOLOE 仅 1/3）
视觉提示训练：冻结其他部分，仅训练 SAVPE，2 epochs
Prompt-free 训练：训练专用提示嵌入，1 epoch

三阶段训练方式对比：

模块	训练阶段	是否冻结其余部分	训练量级
RepRTA	阶段1（和检测器一起训练 30 epochs）	否，全部一起优化	重（和检测器同等训练量）
SAVPE	阶段2（2 epochs）	是，冻结 backbone/neck/检测头	轻（2 epochs，只训练 SAVPE）
LRPC (pf)	阶段3（1 epoch）	是，冻结其余部分	极轻（1 epoch，只训练 pf 嵌入）

RepRTA 在阶段1和检测器一起训练，能学到很强的对齐能力（+2.3 AP，APr +9.3），代价是训练成本高
SAVPE 和 LRPC 采用冻结+独立训练，不影响已学到的检测能力，训练成本极低

训练资源：8×RTX4090，YOLOE-v8-S/M/L 分别 12.0/17.0/22.5 小时

与 YOLO-World 的训练成本对比：YOLO-World 在 32×V100 上训练 100 epochs，YOLOE 在 8×RTX4090 上训练 30 epochs，总成本约 1/3

4.2 Zero-Shot LVIS（文本提示）

方法	骨干	LVIS AP	AP_r	AP_c	AP_f
YOLO-Worldv2-S	YOLOv8-S	24.5	19.1	23.6	26.2
YOLOE-v8-S	YOLOv8-S	28.0	23.6	27.3	29.4
YOLO-Worldv2-M	YOLOv8-M	30.0	24.6	29.3	32.5
YOLOE-v8-M	YOLOv8-M	31.9	26.9	31.3	33.4
YOLO-Worldv2-L	YOLOv8-L	33.0	27.1	33.1	35.3
YOLOE-v8-L	YOLOv8-L	34.4	28.6	34.3	36.2

YOLOE-v8-S 比 YOLO-Worldv2-S 高 3.5 AP，训练成本仅 1/3
所有尺度均有提升，尤其在 rare 类别（AP_r）提升显著

YOLO11 骨干：

方法	LVIS AP
YOLOE-11-S	29.2
YOLOE-11-M	33.1
YOLOE-11-L	35.0

模型规模：

骨干	S	M	L
YOLOE-v8	12M/13M (T/V)	27M/30M	45M/50M
YOLOE-11	10M/12M	21M/27M	26M/32M

4.3 Zero-Shot LVIS（视觉提示）

方法	AP	AP_r	AP_c	AP_f
T-Rex2	26.3	21.4	25.9	28.2
YOLOE-v8-L	30.5	24.7	30.2	32.7
YOLOE-v8-L (seg)	33.5	27.8	33.5	35.7

YOLOE-v8-L 超过 T-Rex2 3.3 APr，训练数据少 2×

零样本分割机制：

训练数据：O365 和 GoldG 的 bbox 标注都用 SAM-2.1 自动生成伪 mask
分割架构：YOLACT 式（原型 + mask 系数），同时计算检测+分割损失
零样本泛化机制：YOLACT 中 mask = 原型 × mask系数，原型和系数的学习与具体类别无关——模型学会的是"给定区域画轮廓"，可从 A 类迁移到 B 类，只要分类对（零样本分类），分割就能泛化（零样本分割）

4.4 Zero-Shot LVIS（Prompt-free）

方法	AP	额外模型
GenerateU	27.5	FlanT5-base (250M)
YOLOE-v8-L	27.9	无

YOLOE 超过 GenerateU 0.4 AP，参数少 6.3×

4.5 COCO 迁移

Linear probing（仅训练分类头，10 epochs）：

方法	AP^b	AP^m
YOLOv8-M	49.7	42.4
YOLOE-v8-M	50.1	42.8
YOLOv8-L	52.9	47.3
YOLOE-v8-L	53.5	47.7

Full tuning（160 epochs）：

方法	AP^b	AP^m
YOLOv8-L	52.9	47.3
YOLOE-v8-L	53.5	47.7

开放词汇预训练后微调，检测和分割均超过从零训练的 YOLOv8
训练时间约为 YOLOv8 的 1/4

4.6 消融实验

RepRTA 消融

配置	LVIS AP
无 RepRTA（直接用 CLIP 嵌入）	26.6
+ RepRTA	28.0 (+1.4)

轻量辅助网络带来 1.4 AP 提升，推理时重参数化零开销

SAVPE 消融

方法	AP
Mask pool	30.4
SAVPE (A=1)	31.5
SAVPE (A=16)	31.9

LRPC 消融

δ	AP	AP_r	加速比
✗（全量匹配）	21.0	19.1	1.0×
1e-3	21.0	19.1	1.7×
1e-2	20.8	19.1	1.9×

5. YOLOE vs YOLO-World 对比

维度	YOLO-World v2	YOLOE
文本嵌入精炼	无（直接用 CLIP 嵌入）	RepRTA（SwiGLUFFN 辅助网络）
图文融合位置	Neck（RepVL-PAN，C2fAttn）	Head（仅精炼文本嵌入，不改变视觉特征）
视觉提示	v2.1 Image Prompt（CLIP 视觉编码器+MLP）	SAVPE（解耦语义+激活，无需额外编码器）
Prompt-free	不支持	LRPC（检索式，无需 LLM）
分割	不原生支持	原生支持（YOLACT 范式 + SAM 伪 mask）
文本编码器	CLIP ViT-B/32	MobileCLIP-B/LT
训练 epochs	100	30（文本）+ 2（视觉）+ 1（prompt-free）
重参数化	RepVL-PAN 中 C2fAttn→C2f + BN 融合	RepRTA 精炼后嵌入融入 cv3 权重 + reprta→Identity
推理架构	标准卷积 YOLO	标准卷积 YOLO（文本/视觉提示时保留辅助网络）

核心区别：

融合 vs 精炼：YOLO-World 在 Neck 中深度融合图文特征（改变视觉特征流），YOLOE 在 Head 中仅精炼文本嵌入（视觉特征流不变）
三统一：YOLOE 是首个在单一模型中统一三种提示范式的高效检测器
训练成本：YOLOE 训练成本仅 1/3，性能反而更好
跨模态融合取舍：YOLOE 砍掉跨模态融合 → AP 掉 1.9，但推理加速 1.28×；用 MobileCLIP+RepRTA 补偿回来 → 最终反超 YOLO-World

6. 关键代码位置

模块	文件	关键类/函数
YOLOE 检测头	`ultralytics/nn/modules/head.py`	`YOLOEDetect`
YOLOE 分割头	`ultralytics/nn/modules/head.py`	`YOLOESegment`
RepRTA	`ultralytics/nn/modules/head.py`	`SwiGLUFFN` + `Residual`
SAVPE	`ultralytics/nn/modules/head.py`	`SAVPE`
LRPC	`ultralytics/nn/modules/head.py`	`LRPCHead`
重参数化 fuse	`ultralytics/nn/modules/head.py`	`YOLOEDetect.fuse()`
BNContrastiveHead	`ultralytics/nn/modules/block.py`	`BNContrastiveHead`
文本编码器	`ultralytics/nn/text_model.py`	MobileCLIP 封装

核心代码结构：

ultralytics/
├── nn/
│   ├── modules/
│   │   ├── head.py     ← YOLOEDetect, YOLOESegment, SAVPE, LRPCHead, SwiGLUFFN, Residual
│   │   └── block.py    ← ContrastiveHead, BNContrastiveHead
│   ├── tasks.py        ← YOLOEModel, YOLOESegModel
│   └── text_model.py   ← MobileCLIP 封装
├── models/yolo/yoloe/
│   ├── train_seg.py    ← 阶段1: 文本提示+分割训练
│   ├── train_vp.py     ← 阶段2: 视觉提示训练（冻结其余，2 epochs）
│   └── train_pe_free.py← 阶段3: prompt-free 训练（1 epoch）
├── cfg/models/v8/yoloe-v8-seg.yaml
└── cfg/models/11/yoloe-11-seg.yaml

工具: tools/generate_sam_masks.py, generate_label_embedding.py, convert_segm2det.py

7. YOLOE → YOLOE-26 的演进

YOLOE (ICCV 2025) 定义了三种提示范式的统一框架。后续 YOLOE-26 将其与 YOLO26 的 NMS-Free 端到端架构结合：

YOLO26 的 one-to-one 匹配 + NMS-Free 推理
YOLOE 的 RepRTA / SAVPE / LRPC 三种提示范式
统一 Object Embedding 空间，三种模式无缝切换
内置 4585 类别词表

详见YOLOE-26 笔记

8. 个人评价

最大贡献：证明开放词汇检测可以统一三种提示范式（文本/视觉/prompt-free）而不牺牲效率，且每种范式都有专门的高效设计
RepRTA 精炼而非融合：比 RepVL-PAN 更优雅——不改视觉特征流，仅精炼文本嵌入，推理零开销
SAVPE 的解耦设计：语义+激活解耦，比 YOLO-World v2.1 的 Image Prompt Adapter 更高效（不需要 CLIP 视觉编码器）
LRPC 将生成转检索：巧妙地绕开了 LLM 依赖，用"先找目标再检索类别"的方式实现 prompt-free
训练成本极低：30+2+1 epochs vs YOLO-World 的 100 epochs，性能反而更好
局限：
1. LRPC 的内置词表有覆盖范围限制，无法检索词表外的类别
2. SAVPE 输入是 mask 而非裁剪图像，需要用户画 mask（不如"裁剪图像"直观）
3. 分割依赖 SAM 伪标注，质量有上限
4. RepRTA 辅助网络虽然轻量，但仍有额外参数（SwiGLUFFN 约 embed×4×embed 参数）

YOLOE: Real-Time Seeing Anything ​

摘要 ​

1. Introduction ​

2. Related Work ​

2.1 文本提示检测 ​

2.2 视觉提示检测 ​

2.3 Prompt-free 检测 ​

3. Method ​

3.1 整体架构 ​

3.2 RepRTA：可重参数化区域-文本对齐 ​

3.3 SAVPE：语义激活视觉提示编码器 ​

3.4 LRPC：惰性区域-提示对比 ​

3.5 训练目标 ​

4. Experiments ​

4.1 实现细节 ​

4.2 Zero-Shot LVIS（文本提示） ​

4.3 Zero-Shot LVIS（视觉提示） ​

4.4 Zero-Shot LVIS（Prompt-free） ​

4.5 COCO 迁移 ​

4.6 消融实验 ​

RepRTA 消融 ​

SAVPE 消融 ​

LRPC 消融 ​

5. YOLOE vs YOLO-World 对比 ​

6. 关键代码位置 ​

7. YOLOE → YOLOE-26 的演进 ​

8. 个人评价 ​