跳转至内容

YOLOE：实时感知一切

简介

YOLOE Prompting 选项

YOLOE (Real-Time Seeing Anything) 是零样本、可提示 YOLO 模型的一项新进展，专为 开放词汇表 检测和分割而设计。 与之前仅限于固定类别的 YOLO 模型不同，YOLOE 使用文本、图像或内部词汇表提示，从而能够实时检测任何对象类别。 YOLOE 基于 YOLOv10 构建，并受到 YOLO-World 的启发，以最小的速度和准确性影响实现了 最先进的零样本性能。



观看： 如何将 YOLOE 与 Ultralytics python 包一起使用：开放词汇和实时识别任何事物 🚀

与早期的 YOLO 模型相比，YOLOE 显著提高了效率和准确性。在 LVIS 上，它比 YOLO-Worldv2 提高了 +3.5 AP，同时仅使用了三分之一的训练资源，并实现了 1.4 倍的更快推理速度。在 COCO 上进行微调后，YOLOE-v8-large 比 YOLOv8-L 高出 0.1 mAP，而训练时间减少了近 4 倍。这证明了 YOLOE 在准确性、效率和多功能性方面的卓越平衡。以下部分将探讨 YOLOE 的架构、基准比较以及与 Ultralytics 框架的集成。

架构概览

YOLOE 架构

YOLOE 保留了标准的 YOLO 结构：一个用于特征提取的卷积 backbone（例如，CSP-Darknet），一个用于多尺度融合的 neck（例如，PAN-FPN），以及一个 anchor-free, decoupled 检测 head（如 YOLOv8/YOLO11 中所示），独立预测目标、类别和框。YOLOE 引入了三个新模块，实现了开放词汇检测：

  • 可重参数化的区域-文本对齐 (RepRTA): 通过一个小型的辅助网络细化文本 嵌入（例如，来自 CLIP），从而支持 文本提示检测。在推理时，此网络被折叠到主模型中，从而确保零开销。因此，YOLOE 可以检测任意文本标记的对象（例如，未见过的“交通灯”），而不会产生运行时损失。

  • 语义激活视觉提示编码器 (SAVPE)：通过轻量级嵌入分支实现视觉提示检测。给定参考图像，SAVPE 编码语义和激活特征，调节模型以检测视觉上相似的对象——一种对徽标或特定部分有用的一键式检测功能。

  • 惰性区域提示对比 (LRPC)：在无提示模式下，YOLOE使用在大型词汇表（来自LVIS和Objects365的1200+类别）上训练的内部嵌入执行开放集识别。无需外部提示或编码器，YOLOE通过嵌入相似性查找来识别对象，从而有效地处理推理时的大型标签空间。

此外，YOLOE 通过使用掩码预测分支（类似于 YOLACT 或 YOLOv8-Seg）扩展检测头，集成了实时实例分割，从而最大限度地减少了开销。

至关重要的是，YOLOE 的开放世界模块在用作常规封闭集 YOLO 时，不会引入推理成本。训练后，YOLOE 参数可以重新参数化为标准 YOLO head，从而保持相同的 FLOPs 和速度（例如，与 YOLO11 完全匹配）。

可用模型、支持的任务和操作模式

本节详细介绍了可用的模型及其特定的预训练权重、它们支持的任务以及它们与各种操作模式（如推理、验证、训练和导出）的兼容性，✅表示支持的模式，❌表示不支持的模式。

文本/视觉提示模型

模型类型 预训练权重 支持的任务 推理 验证 训练 导出
YOLOE-11S yoloe-11s-seg.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-11M yoloe-11m-seg.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-11L yoloe-11l-seg.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-v8S yoloe-v8s-seg.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-v8M yoloe-v8m-seg.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-v8L yoloe-v8l-seg.pt 实例分割 ✅ ✅ ✅ ✅

无提示词模型

模型类型 预训练权重 支持的任务 推理 验证 训练 导出
YOLOE-11S-PF yoloe-11s-seg-pf.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-11M-PF yoloe-11m-seg-pf.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-11L-PF yoloe-11l-seg-pf.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-v8S-PF yoloe-v8s-seg-pf.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-v8M-PF yoloe-v8m-seg-pf.pt 实例分割 ✅ ✅ ✅ ✅
YOLOE-v8L-PF yoloe-v8l-seg-pf.pt 实例分割 ✅ ✅ ✅ ✅

使用示例

YOLOE 模型可以轻松集成到您的 Python 应用程序中。Ultralytics 提供了用户友好的 Python API 和 CLI 命令，以简化开发流程。

训练用法

在自定义数据集上进行微调

您可以针对检测和实例分割任务，在您的自定义 YOLO 数据集上微调任何预训练的 YOLOE 模型。

示例

实例分割

微调 YOLOE 预训练检查点主要遵循 标准的 YOLO 训练流程。关键区别在于显式传递 YOLOEPESegTrainer 作为 trainer 参数设置为 model.train():

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer

model = YOLOE("yoloe-11s-seg.pt")

# Fine-tune on your segmentation dataset
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
)

对象检测

全部 预训练的 YOLOE 模型 默认执行实例分割。要使用这些预训练检查点来训练检测模型，请使用 YAML 配置文件从头开始初始化一个检测模型，然后加载相同规模的预训练分割检查点。请注意，我们使用 YOLOEPETrainer 代替 YOLOEPESegTrainer 由于我们正在训练一个检测模型：

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPETrainer

# Initialize a detection model from a config
model = YOLOE("yoloe-11s.yaml")

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-11s-seg.pt")

# Fine-tune on your detection dataset
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
)

线性探测仅微调分类分支，同时冻结模型的其余部分。这种方法在处理有限数据时非常有用，因为它通过利用先前学习的特征来防止过度拟合，同时仅调整分类头。

实例分割

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer

# Load a pretrained segmentation model
model = YOLOE("yoloe-11s-seg.pt")

# Identify the head layer index
head_index = len(model.model.model) - 1

# Freeze all backbone and neck layers (i.e. everything before the head)
freeze = [str(i) for i in range(0, head_index)]

# Freeze parts of the segmentation head, keeping only the classification branch trainable
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

# Freeze detection branch components
freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

# Train only the classification branch
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
    freeze=freeze,
)

对象检测

对于目标检测任务，训练过程与上面的实例分割示例几乎相同，但我们使用 YOLOEPETrainer 代替 YOLOEPESegTrainer，并使用 YAML 初始化目标检测模型，然后从预训练的实例分割检查点加载权重。

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPETrainer

# Initialize a detection model from a config
model = YOLOE("yoloe-11s.yaml")

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-11s-seg.pt")

# Identify the head layer index
head_index = len(model.model.model) - 1

# Freeze all backbone and neck layers (i.e. everything before the head)
freeze = [str(i) for i in range(0, head_index)]

# Freeze parts of the segmentation head, keeping only the classification branch trainable
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

# Freeze detection branch components
freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

# Train only the classification branch
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
    freeze=freeze,
)

预测用法

YOLOE 支持基于文本和视觉的提示。使用提示非常简单，只需通过 predict 方法，如下所示：

示例

通过文本提示，您可以指定希望通过文本描述检测的类别。以下代码展示了如何使用 YOLOE 检测图像中的人和公共汽车：

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Set text prompt to detect person and bus. You only need to do this once after you load the model.
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

通过展示目标类别的视觉示例（而不是用文字描述），视觉提示允许您引导模型。

字段 visual_prompts 参数，该参数接受一个包含两个键的字典： bboxes 和 cls。中的每个边界框 bboxes 应该紧密地包含您希望模型检测的对象的示例，以及相应的条目 cls 指定该框的类别标签。这种配对告诉模型，“这就是 X 类的样子——现在找到更多类似的。”

类别 ID (cls）在 visual_prompts 用于将每个边界框与提示中的特定类别相关联。它们不是固定的标签，而是您分配给每个示例的临时标识符。唯一的要求是类 ID 必须是连续的，从 0 开始。这有助于模型正确地将每个框与其相应的类相关联。

您可以直接在要运行推理的同一图像中提供视觉提示。例如：

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=np.array(
        [
            [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
            [120, 425, 160, 445],  # Box enclosing glasses
        ],
    ),
    cls=np.array(
        [
            0,  # ID to be assigned for person
            1,  # ID to be assigned for glassses
        ]
    ),
)

# Run inference on an image, using the provided visual prompts as guidance
results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

或者，您可以使用单独的参考图像来提供示例，使用 refer_image 参数。在这种情况下， bboxes 和 cls 在 visual_prompts 应该描述参考图像中的对象，而不是您要进行预测的目标图像：

注意

可视化参数： source 是视频或流，模型会自动使用第一帧作为 refer_image。这意味着您的 visual_prompts 会应用于初始帧，以帮助模型理解在视频的其余部分中要寻找的内容。或者，您可以显式地将任何特定帧作为 refer_image 用于控制模型使用哪些视觉示例作为参考。

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts based on a separate reference image
visual_prompts = dict(
    bboxes=np.array([[221.52, 405.8, 344.98, 857.54]]),  # Box enclosing person
    cls=np.array([0]),  # ID to be assigned for person
)

# Run prediction on a different image, using reference image to guide what to look for
results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image for detection
    refer_image="ultralytics/assets/bus.jpg",  # Reference image used to get visual prompts
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

使用 refer_image 还会永久设置类别，因此您可以运行预测，而无需再次提供相同的视觉提示，并且可以在导出后导出模型，同时仍保留检测相同类别的能力： 

# After making prediction with `refer_image`, you can run predictions without passing visual_prompts again and still get the same classes back
results = model("ultralytics/assets/bus.jpg")

# Or export it to a different format while retaining the classes
model.export(format="onnx")

您还可以传递多个目标图像以运行预测：

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=[
        np.array(
            [
                [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
                [120, 425, 160, 445],  # Box enclosing glasses
            ],
        ),
        np.array([[150, 200, 1150, 700]]),
    ],
    cls=[
        np.array(
            [
                0,  # ID to be assigned for person
                1,  # ID to be assigned for glasses
            ]
        ),
        np.array([0]),
    ],
)

# Run inference on multiple image, using the provided visual prompts as guidance
results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

YOLOE 还包括带有内置词汇表的免提示变体。这些模型不需要任何提示，并且像传统的 YOLO 模型一样工作。它们不依赖于用户提供的标签或视觉示例，而是根据 Recognize Anything Model Plus (RAM++) 使用的标签集，从预定义的 4,585 个类别列表中检测对象。

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")

# Run prediction. No prompts required.
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

验证用法

在数据集上进行模型验证的流程如下：

示例

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml")

默认情况下，它使用提供的的数据集来提取每个类别的视觉嵌入。

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml", load_vp=True)

或者，我们可以使用另一个数据集作为参考数据集，以提取每个类别的视觉嵌入。 请注意，此参考数据集应与提供的数据集具有完全相同的类别。

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml", load_vp=True, refer_data="coco.yaml")

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")  # or select yoloe-11s/m-seg-pf.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml", single_cls=True)

导出用法

导出过程与其他 YOLO 模型类似，但增加了处理文本和视觉提示的灵活性：

示例

from ultralytics import YOLOE

# Select yoloe-11s/m-seg.pt for different sizes
model = YOLOE("yoloe-11l-seg.pt")

# Configure the set_classes() before exporting the model
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

export_model = model.export(format="onnx")
model = YOLOE(export_model)

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

训练官方模型

准备数据集

注意

训练官方 YOLOE 模型需要训练数据的分割注释，这里是 官方团队提供的脚本 将数据集转换为分割注释，由以下技术驱动 SAM2.1 模型。或者您可以直接下载提供的 Processed Segment Annotations 在官方团队提供的下表中。

  • 训练数据
数据集 类型 示例 边界框 原始检测标注 已处理的分割标注
Objects365v1 检测 609k 9621k objects365_train.json objects365_train_segm.json
GQA 定位 621k 3681k final_mixed_train_no_coco.json final_mixed_train_no_coco_segm.json
Flickr30k 定位 149k 641k final_flickr_separateGT_train.json final_flickr_separateGT_train_segm.json
  • 验证数据
数据集 类型 标注文件
LVIS minival 检测 minival.txt

从头开始启动训练

注意

Visual Prompt 模型基于训练良好的模型进行微调 Text Prompt 模型。

示例

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOESegTrainerFromScratch

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.yaml")
model.train(
    data=data,
    batch=128,
    epochs=30,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegTrainerFromScratch,
    device="0,1,2,3,4,5,6,7",
)

由于只有 SAVPE 模块需要在训练期间更新。 将训练良好的文本提示模型转换为检测模型，并采用检测管道，从而降低训练成本。 请注意，此步骤是可选的，您可以直接从分割开始。

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

det_model = YOLOE("yoloe-11l.yaml")
state = torch_load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

开始训练：

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOESegVPTrainer

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze every layer except of the savpe module.
head_index = len(model.model.model) - 1
freeze = list(range(0, head_index))
for name, child in model.model.model[-1].named_children():
    if "savpe" not in name:
        freeze.append(f"{head_index}.{name}")

model.train(
    data=data,
    batch=128,
    epochs=2,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=16e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegVPTrainer,  # use YOLOEVPTrainer if converted to detection model
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
)

训练后转换回分割模型。仅当您在训练前将分割模型转换为检测模型时才需要。

from copy import deepcopy

from ultralytics import YOLOE

model = YOLOE("yoloe-11l-seg.yaml")
model.load("yoloe-11l-seg.pt")

vp_model = YOLOE("yoloe-11l-vp.pt")
model.model.model[-1].savpe = deepcopy(vp_model.model.model[-1].savpe)
model.eval()
model.save("yoloe-11l-seg.pt")

与视觉提示训练类似，对于无提示模型，只需要在训练期间更新专门的提示嵌入。 将训练良好的文本提示模型转换为检测模型，并采用检测流程，从而降低训练成本。 请注意，此步骤是可选的，您也可以直接从分割开始。

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

det_model = YOLOE("yoloe-11l.yaml")
state = torch_load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")
开始训练： 
from ultralytics import YOLOE

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze layers.
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data=data,
    batch=128,
    epochs=1,
    close_mosaic=1,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEPEFreeTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
    single_cls=True,  # this is needed
)

训练后转换回分割模型。仅当您在训练前将分割模型转换为检测模型时才需要。

from copy import deepcopy

from ultralytics import YOLOE

model = YOLOE("yoloe-11l-seg.pt")
model.eval()

pf_model = YOLOE("yoloe-11l-seg-pf.pt")
names = ["object"]
tpe = model.get_text_pe(names)
model.set_classes(names, tpe)
model.model.model[-1].fuse(model.model.pe)

model.model.model[-1].cv3[0][2] = deepcopy(pf_model.model.model[-1].cv3[0][2]).requires_grad_(True)
model.model.model[-1].cv3[1][2] = deepcopy(pf_model.model.model[-1].cv3[1][2]).requires_grad_(True)
model.model.model[-1].cv3[2][2] = deepcopy(pf_model.model.model[-1].cv3[2][2]).requires_grad_(True)
del model.model.pe
model.save("yoloe-11l-seg-pf.pt")

YOLOE 性能比较

在 COCO 等标准基准测试中，YOLOE 在不影响速度或模型大小的情况下，达到或超过了闭集 YOLO 模型的准确性。下表比较了 YOLOE-L（基于 YOLO11 构建）与相应的 YOLOv8 和 YOLO11 模型：

模型 COCO mAP50-95 推理速度 (T4) 参数 GFLOPs (640像素)
YOLOv8-L（封闭集） 52.9% 9.06 毫秒 (110 FPS) 43.7 M 165.2 B
YOLO11-L (封闭集) 53.5% 6.2 毫秒 (130 FPS) 26.2 M 86.9 B
YOLOE-L (open-vocab) 52.6% 6.2 毫秒 (130 FPS) 26.2 M 86.9 B†

† YOLO11-L 和 YOLOE-L 具有相同的架构（YOLO11-L 中禁用了提示模块），因此具有相同的推理速度和相似的 GFLOPs 估计值。

YOLOE-L 实现了 52.6% mAP，超过了 YOLOv8-L（52.9%），但参数减少了大约 40%（26M vs. 43.7M）。它在 6.2 毫秒（161 FPS）内处理 640×640 图像，而 YOLOv8-L 则需要 9.06 毫秒（110 FPS），突出了 YOLO11 的效率。至关重要的是，YOLOE 的开放词汇模块 不产生推理成本，展示了一种 “没有免费的午餐”权衡 设计。

对于零样本和迁移任务，YOLOE 表现出色：在 LVIS 上，YOLOE-small 比 YOLO-Worldv2 提高了 +3.5 AP，同时使用了 3 倍更少的训练资源。将 YOLOE-L 从 LVIS 微调到 COCO 也比 YOLOv8-L 需要 4 倍更少的训练时间，突显了其效率和适应性。YOLOE 进一步保持了 YOLO 的标志性速度，在 T4 GPU 上实现了 300+ FPS，在通过 CoreML 的 iPhone 12 上实现了 ~64 FPS，非常适合边缘和移动部署。

注意

基准测试条件： YOLOE 的结果来自在 Objects365、GoldG 和 LVIS 上预训练，然后在 COCO 上进行微调或评估的模型。YOLOE 相对于 YOLOv8 的轻微 mAP 优势来自于广泛的预训练。如果没有这种开放词汇训练，YOLOE 可以匹配类似大小的 YOLO 模型，从而确认其 SOTA 准确性和开放世界灵活性，而不会降低性能。

与之前模型的比较

YOLOE 在之前的 YOLO 模型和开放词汇检测器上引入了显著的改进：

  • YOLOE 与 YOLOv5：
    YOLOv5 提供了良好的速度-准确性平衡，但需要为新类重新训练，并使用基于锚框的头部。相比之下，YOLOE 是无锚框的，并动态检测新类。YOLOE 基于 YOLOv8 的改进，实现了更高的准确率（COCO 上 52.6% vs. YOLOv5 的约 50% mAP），并集成了实例分割，这与 YOLOv5 不同。

  • YOLOE 与 YOLOv8：
    YOLOE 扩展了 YOLOv8 的重新设计的架构，实现了相似或更高的准确率（52.6% mAP，约 26M 参数，而 YOLOv8-L 的 52.9%，约 44M 参数）。由于更强的预训练，它显着减少了训练时间。关键的进步是 YOLOE 的开放世界能力，通过提示检测未见过的对象（例如，“bird scooter”或“peace symbol”），这与 YOLOv8 的封闭集设计不同。

  • YOLOE 与 YOLO11：
    YOLO11 通过提高效率和减少参数（减少约 22%）改进了 YOLOv8。YOLOE 直接继承了这些优势，匹配 YOLO11 的推理速度和参数计数（约 26M 参数），同时增加了开放词汇检测和分割。在封闭集场景中，YOLOE 相当于 YOLO11，但至关重要的是增加了检测未见类的适应性，实现了YOLO11 + 开放世界能力，而不会影响速度。

  • YOLOE与之前的开放词汇检测器对比：
    早期的开放词汇模型（GLIP、OWL-ViT、YOLO-World）严重依赖视觉-语言Transformer，导致推理速度较慢。YOLOE在零样本准确率方面超过了它们（例如，与YOLO-Worldv2相比，+3.5 AP），同时运行速度快1.4倍，且训练资源显著降低。与基于Transformer的方法（例如GLIP）相比，YOLOE提供了数量级更快的推理速度，有效弥合了开放集检测中的准确率-效率差距。

总而言之，YOLOE 保持了 YOLO 著名的速度和效率，在准确性方面超越了前代产品，集成了分割，并引入了强大的开放世界检测，使其具有独特的通用性和实用性。

应用案例与应用

YOLOE 的开放词汇检测和分割功能支持传统固定类别模型之外的各种应用：

  • 开放世界目标检测：
    非常适合动态场景，如机器人技术，机器人使用提示识别以前未见过的物体；或安全系统快速适应新威胁（例如，危险物品），而无需重新训练。

  • 少样本和单样本检测：
    YOLOE 使用视觉提示 (SAVPE)，可以从单个参考图像中快速学习新对象，非常适合工业检测（立即识别零件或缺陷）或自定义监控，从而可以通过最少的设置实现视觉搜索。

  • 大词汇量和长尾识别：
    YOLOE配备了1000多个类别的词汇，擅长于生物多样性监测（检测稀有物种）、博物馆藏品、零售库存或电子商务等任务，无需大量的每类训练即可可靠地识别许多类别。

  • 交互式检测和分割：
    YOLOE 支持实时交互式应用，例如 可搜索的视频/图像检索、增强现实 (AR) 和直观的 图像编辑，由自然输入（文本或视觉提示）驱动。用户可以使用分割掩码动态地隔离、识别或精确编辑对象。

  • 自动数据标注和引导：
    YOLOE 通过提供初始边界框和分割注释来促进快速数据集创建，从而显著减少人工标注工作。 在大型媒体集合分析中尤其有价值，它可以自动识别存在的对象，从而帮助更快地构建专用模型。

  • 任意对象分割：
    通过提示将分割功能扩展到任意对象——特别有利于医学成像、显微镜或卫星图像分析，自动识别并精确分割结构，而无需专门的预训练模型。与SAM等模型不同，YOLOE同时自动识别和分割对象，有助于内容创作或场景理解等任务。

在所有这些用例中，YOLOE 的核心优势在于其多功能性，它为动态场景中的检测、识别和分割提供了一个统一的模型。它的效率确保了在资源受限设备上的实时性能，非常适合机器人、自动驾驶、国防等领域。

提示

根据您的需求选择YOLOE的模式：

  • 封闭集模式： 适用于固定类别任务（最大速度和准确性）。
  • 提示模式： 通过文本或视觉提示快速添加新对象。
  • 无提示开放集模式： 跨多个类别的通用检测（非常适合编目和发现）。

通常，结合使用多种模式——例如，先进行无提示发现，然后进行有针对性的提示——可以充分发挥 YOLOE 的潜力。

训练与推理

与其他 YOLO 模型（YOLOv8、YOLO-World）类似，YOLOE 与 Ultralytics Python API 和 CLI 无缝集成。以下是如何快速开始：

使用 YOLOE 进行训练和推理

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s-seg.pt")
model.train(data="path/to/data.yaml", epochs=50, imgsz=640)

# Run inference using text prompts ("person", "bus")
model.set_classes(["person", "bus"])
results = model.predict(source="test_images/street.jpg")
results[0].save()  # save annotated output

在这里，YOLOE 默认情况下表现得像一个标准检测器，但通过指定类别（set_classes)。结果包含边界框、掩码和标签。

# Training YOLOE on custom dataset
yolo train model=yoloe-11s-seg.pt data=path/to/data.yaml epochs=50 imgsz=640

# Inference with text prompts
yolo predict model=yoloe-11s-seg.pt source="test_images/street.jpg" classes="person,bus"

CLI 提示符 (classes）指南 YOLOE，类似于 python 的 set_classes。视觉提示（基于图像的查询）目前需要 python API。

其他支持的任务

  • 验证： 使用以下工具轻松评估准确性 model.val() 或 yolo val.
  • 导出： 导出 YOLOE 模型（model.export()）到 ONNX、TensorRT 等，从而方便部署。
  • 追踪: YOLOE 支持目标跟踪（yolo track) 集成后，可用于跟踪视频中提示的类别。

注意

YOLOE 自动包含 分割掩码 在推理结果中（results[0].masks)，简化了像素精确的任务，如对象提取或测量，而无需单独的模型。

快速入门

按照以下步骤，使用 Ultralytics 快速设置 YOLOE：

  1. 安装: 安装或更新 Ultralytics 包：

    pip install -U ultralytics

  2. 下载 YOLOE 权重: 预训练的YOLOE模型（例如，YOLOE-v8-S/L，YOLOE-11变体）可从YOLOE GitHub发布版本中获取。只需下载您所需的版本即可。 .pt 要加载到 Ultralytics YOLO 类中的文件。

  3. 硬件要求：

    • 推理: 推荐使用 GPU（NVIDIA，≥4-8GB 显存）。小型模型可以在边缘 GPU（例如 Jetson）或 CPU 上以较低分辨率高效运行。
    • 训练: 在自定义数据上微调 YOLOE 通常只需要一个 GPU。 作者使用的广泛的开放词汇预训练 (LVIS/Objects365) 需要大量的计算 (8× RTX 4090 GPU)。

  4. 配置: YOLOE配置使用标准的Ultralytics YAML文件。默认配置（例如， yoloe-11s-seg.yaml) 通常就足够了，但您可以根据需要修改 backbone、类别或图像大小。

  5. 运行 YOLOE：

    • 快速推理 （无提示）： 
      yolo predict model=yoloe-11s-seg-pf.pt source="image.jpg"

    • 提示检测（文本提示示例）：

      from ultralytics import YOLO

model = YOLO("yoloe-11s-seg.pt")
names = ["bowl", "apple"]
model.set_classes(names, model.get_text_pe(names))
results = model.predict("kitchen.jpg")
results[0].save()

  6. 集成提示:

    • 类名称: 默认的YOLOE输出使用LVIS类别；使用 set_classes() 以指定您自己的标签。
    • 速度：YOLOE 除非使用提示，否则没有额外开销。文本提示的影响极小；视觉提示的影响稍大。
    • 批量推理: 直接支持 (model.predict([img1, img2]))。对于特定于图像的提示，请单独运行图像。

Ultralytics 文档提供了更多资源。YOLOE 使您可以在熟悉的 YOLO 生态系统中轻松探索强大的开放世界功能。

提示

专家提示： 为了最大限度地提高 YOLOE 的零样本准确率，请从提供的检查点进行微调，而不是从头开始训练。使用与常见训练标签（请参阅 LVIS 类别）对齐的提示词，以提高检测准确率。

引用与致谢

如果YOLOE对您的研究或项目做出了贡献，请引用清华大学Ao Wang、Lihao Liu、Hui Chen、Zijia Lin、Jungong Han和Guiguang Ding的原始论文：

@misc{wang2025yoloerealtimeseeing,
      title={YOLOE: Real-Time Seeing Anything},
      author={Ao Wang and Lihao Liu and Hui Chen and Zijia Lin and Jungong Han and Guiguang Ding},
      year={2025},
      eprint={2503.07465},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2503.07465},
}

如需进一步阅读，请访问 arXiv 查看 YOLOE 原始论文。可以通过其 GitHub 存储库 访问该项目的源代码和其他资源。

常见问题

YOLOE 与 YOLO-World 有何不同？

虽然 YOLOE 和 YOLO-World 都能实现开放词汇检测，但 YOLOE 具有多个优势。YOLOE 在 LVIS 上的准确率提高了 +3.5 AP，同时使用的训练资源减少了 3 倍，运行速度比 YOLO-Worldv2 快 1.4 倍。YOLOE 还支持三种提示模式（文本、视觉和内部词汇），而 YOLO-World 主要侧重于文本提示。此外，YOLOE 还包括内置的 实例分割功能，可为检测到的对象提供像素精确的掩码，而无需额外的开销。

我可以将 YOLOE 用作常规 YOLO 模型吗？

是的，YOLOE 的功能与标准 YOLO 模型完全相同，且不会降低性能。在闭集模式下（不使用提示），YOLOE 的开放词汇模块会重新参数化为标准检测头，从而实现与同等 YOLO11 模型相同的速度和准确性。这使得 YOLOE 非常通用——您可以将其用作传统检测器以获得最大速度，然后在需要时切换到开放词汇模式。

我可以将哪些类型的提示词与 YOLOE 一起使用？

YOLOE 支持三种类型的 prompt：

  1. 文本提示：使用自然语言指定对象类别（例如，“人”、“交通灯”、“电动滑板车”）
  2. 视觉提示: 提供您要检测的对象的参考图像
  3. 内部词汇表: 使用 YOLOE 的 1200 多个类别的内置词汇表，无需外部提示

这种灵活性使您可以使 YOLOE 适应各种场景，而无需重新训练模型，这使其对于检测要求频繁变化的动态环境特别有用。

YOLOE 如何处理实例分割？

YOLOE 通过使用掩码预测分支扩展检测头，将实例分割直接集成到其架构中。这种方法类似于 YOLOv8-Seg，但适用于任何提示的对象类别。分割掩码会自动包含在推理结果中，并且可以通过 results[0].masks。这种统一的方法消除了对单独的检测和分割模型的需求，从而简化了需要像素精确对象边界的应用的工作流程。

YOLOE 如何处理带有自定义提示的推理？

与 YOLO-World 类似，YOLOE 支持“prompt-then-detect”策略，该策略利用离线词汇表来提高效率。自定义提示（如标题或特定对象类别）被预先编码并存储为离线词汇嵌入。这种方法简化了检测过程，无需重新训练。您可以在模型中动态设置这些提示，以使其适应特定的检测任务：

from ultralytics import YOLO

# Initialize a YOLOE model
model = YOLO("yoloe-11s-seg.pt")

# Define custom classes
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

# Execute prediction on an image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()


📅 创建于 5 个月前 ✏️ 更新于 11 天前
RizwanMunawar Y-T-G Laughing-q glenn-jocher ShuaiLYU picsalex willie.maddox@gmail.com JShengP leonnil

评论