YOLOE: Обнаружение чего угодно в реальном времени
Введение
YOLOE (Real-Time Seeing Anything) — это новое достижение в моделях YOLO с нулевым выстрелом и возможностью запроса, разработанных для обнаружения с открытым словарем и сегментации. В отличие от предыдущих моделей YOLO, ограниченных фиксированными категориями, YOLOE использует текстовые, графические или внутренние словарные подсказки, обеспечивая обнаружение любого класса объектов в реальном времени. Построенная на базе YOLOv10 и вдохновленная YOLO-World, YOLOE достигает современной производительности с нулевым выстрелом с минимальным влиянием на скорость и точность.
Смотреть: Как использовать YOLOE с пакетом Ultralytics python: Открытый словарь и видение чего угодно в реальном времени 🚀
По сравнению с более ранними моделями YOLO, YOLOE значительно повышает эффективность и точность. Она улучшается на +3.5 AP по сравнению с YOLO-Worldv2 на LVIS, используя всего лишь треть обучающих ресурсов и достигая в 1.4 раза более высокой скорости инференса. После тонкой настройки на COCO, YOLOE-v8-large превосходит YOLOv8-L на 0.1 mAP, используя почти в 4 раза меньше времени на обучение. Это демонстрирует исключительный баланс точности, эффективности и универсальности YOLOE. В разделах ниже рассматриваются архитектура YOLOE, сравнения эталонных тестов и интеграция с фреймворком Ultralytics.
Обзор архитектуры
YOLOE сохраняет стандартную структуру YOLO—сверточную backbone (например, CSP-Darknet) для извлечения признаков, neck (например, PAN-FPN) для многомасштабного слияния и anchor-free, decoupled обнаружения head (как в YOLOv8/YOLO11), предсказывающую объектность, классы и ограничивающие рамки независимо. YOLOE представляет три новых модуля, обеспечивающих обнаружение с открытым словарем:
-
Re-parameterizable Region-Text Alignment (RepRTA): Поддерживает обнаружение с текстовыми подсказками путем уточнения текстовых встраиваний (например, из CLIP) через небольшую вспомогательную сеть. Во время инференса эта сеть сворачивается в основную модель, обеспечивая нулевые накладные расходы. Таким образом, YOLOE обнаруживает произвольные объекты с текстовой маркировкой (например, невиданный ранее "светофор") без штрафов во время выполнения.
-
Semantic-Activated Visual Prompt Encoder (SAVPE): Обеспечивает визуальную детекцию с подсказками через облегченную ветвь встраивания. Учитывая эталонное изображение, SAVPE кодирует семантические функции и функции активации, обусловливая модель для обнаружения визуально похожих объектов — возможность обнаружения с одного раза, полезная для логотипов или определенных частей.
-
Lazy Region-Prompt Contrast (LRPC): В режиме без запросов, YOLOE выполняет распознавание открытого набора, используя внутренние вложения, обученные на больших словарях (более 1200 категорий из LVIS и Objects365). Без внешних запросов или кодировщиков, YOLOE идентифицирует объекты посредством поиска сходства вложений, эффективно обрабатывая большие пространства меток при выводе.
Кроме того, YOLOE интегрирует сегментацию экземпляров в реальном времени, расширяя головку обнаружения ветвью прогнозирования маски (аналогично YOLACT или YOLOv8-Seg), добавляя минимальные накладные расходы.
Ключевым моментом является то, что модули открытого мира YOLOE не вносят затрат на вывод при использовании в качестве обычного YOLO с замкнутым набором данных. После обучения параметры YOLOE могут быть повторно параметризованы в стандартную голову YOLO, сохраняя идентичные FLOP и скорость (например, точно соответствующие YOLO11).
Доступные модели, поддерживаемые задачи и режимы работы
В этом разделе подробно описаны доступные модели с их конкретными предварительно обученными весами, задачи, которые они поддерживают, и их совместимость с различными режимами работы, такими как Inference, Validation, Training и Export, обозначенные ✅ для поддерживаемых режимов и ❌ для неподдерживаемых режимов.
Текстовые/Визуальные модели запросов
Тип модели | Предварительно обученные веса | Поддерживаемые задачи | Инференс | Валидация | Обучение | Экспорт |
---|---|---|---|---|---|---|
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 команды для оптимизации разработки.
Использование при обучении
Тонкая настройка на пользовательском наборе данных
Вы можете дообучить любую предварительно обученную модель YOLOE на вашем пользовательском наборе данных YOLO как для задач обнаружения, так и для сегментации экземпляров.
Пример
Сегментация экземпляров
Дообучение предварительно обученной контрольной точки 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 — теперь найди больше похожих".
Идентификаторы классов (cls
) в visual_prompts
используются для связывания каждого ограничивающего прямоугольника с определенной категорией в вашем запросе. Это не фиксированные метки, а временные идентификаторы, которые вы назначаете каждому примеру. Единственное требование состоит в том, что идентификаторы классов должны быть последовательными, начиная с 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. Вместо того чтобы полагаться на предоставленные пользователем метки или визуальные примеры, они обнаруживают объекты из предопределенного списка из 4585 классов на основе набора тегов, используемого Recognize Anything Model Plus (RAM++).
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 | Grounding | 621k | 3681k | final_mixed_train_no_coco.json | final_mixed_train_no_coco_segm.json |
Flickr30k | Grounding | 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
модуль необходимо обновлять во время обучения.
Преобразование хорошо обученной модели Text-prompt в модель обнаружения и адаптация конвейера обнаружения с меньшими затратами на обучение.
Обратите внимание, что этот шаг является необязательным, вы также можете начать непосредственно с сегментации.
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")
Как и в случае с визуальным обучением с подсказками, для модели без подсказок требуется только специализированное внедрение подсказок, которое необходимо обновлять во время обучения. Преобразование хорошо обученной модели Text-prompt в модель обнаружения и принятие конвейера обнаружения с меньшими затратами на обучение. Обратите внимание, что этот шаг является необязательным, вы также можете начать непосредственно с сегментации.
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
YOLOE соответствует или превосходит точность моделей YOLO с закрытым набором на стандартных бенчмарках, таких как COCO, без ущерба для скорости или размера модели. В таблице ниже сравнивается YOLOE-L (построенный на YOLO11) с соответствующими моделями YOLOv8 и YOLO11:
Модель | COCO mAP50-95 | Скорость инференса (T4) | Параметры | GFLOPs (640px) |
---|---|---|---|---|
YOLOv8-L (closed-set) | 52.9% | 9.06 мс (110 FPS) | 43.7 M | 165.2 B |
YOLO11-L (closed-set) | 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 против 43.7M). Он обрабатывает изображения 640×640 за 6.2 мс (161 FPS) по сравнению с 9.06 мс (110 FPS) у YOLOv8-L, что подчеркивает эффективность YOLO11. Важно отметить, что модули открытого словаря YOLOE не несут затрат на вывод, демонстрируя "компромисс без бесплатного обеда".
Для задач zero-shot и transfer YOLOE превосходит другие модели: на LVIS, YOLOE-small улучшается по сравнению с YOLO-Worldv2 на +3.5 AP, используя в 3 раза меньше ресурсов для обучения. Тонкая настройка YOLOE-L с LVIS на COCO также потребовала в 4 раза меньше времени на обучение, чем YOLOv8-L, что подчеркивает ее эффективность и адаптируемость. YOLOE также поддерживает фирменную скорость YOLO, достигая 300+ FPS на GPU T4 и ~64 FPS на iPhone 12 через CoreML, что идеально подходит для периферийных и мобильных развертываний.
Примечание
Условия эталонного тестирования: Результаты YOLOE получены на моделях, предварительно обученных на Objects365, GoldG и LVIS, а затем дообученных или оцененных на COCO. Небольшое преимущество YOLOE в mAP над YOLOv8 обусловлено обширным предварительным обучением. Без этого обучения с открытым словарем YOLOE соответствует моделям YOLO аналогичного размера, подтверждая свою точность SOTA и гибкость открытого мира без штрафов за производительность.
Сравнение с предыдущими моделями
YOLOE представляет заметные улучшения по сравнению с предыдущими моделями YOLO и детекторами с открытым словарем:
-
YOLOE против YOLOv5: YOLOv5 предлагал хороший баланс скорости и точности, но требовал переобучения для новых классов и использовал головы, основанные на якорях. В отличие от него, YOLOE не использует якорей и динамически определяет новые классы. YOLOE, основываясь на улучшениях YOLOv8, достигает более высокой точности (52,6 % против ~50 % mAP у YOLOv5 на COCO) и интегрирует сегментацию экземпляров, в отличие от YOLOv5.
-
YOLOE против YOLOv8: YOLOE расширяется YOLOv8переделанную архитектуру, достигая аналогичной или более высокой точности(52,6% mAP при ~26M параметров против 52,9% у YOLOv8 при ~44M параметров). При этом значительно сокращается время обучения за счет более сильного предварительного обучения. Ключевым достижением является возможность YOLOE работать в открытом мире, обнаруживая невидимые объекты (например,"скутер с птицей" или"символ мира") с помощью подсказок, в отличие от закрытого дизайна YOLOv8.
-
YOLOE против YOLO11: YOLO11 улучшает YOLOv8 , повышая эффективность и уменьшая количество параметров (~22%). YOLOE напрямую наследует эти преимущества, сравнивая скорость вывода и количество параметров YOLO11(~26 М параметров), добавляя при этом обнаружение и сегментацию открытой лексики. В сценариях с закрытыми наборами YOLOE эквивалентен YOLO11, но, что очень важно, добавляет адаптивность для обнаружения невидимых классов, достигая возможностейYOLO11 + открытого мира без ущерба для скорости.
-
YOLOE в сравнении с предыдущими детекторами открытой лексики: Предыдущие модели открытых словарей (GLIP, OWL-ViT, YOLO) в значительной степени опирались на трансформаторы языка зрения, что приводило к медленному выводу. YOLOE превосходит их по точности с нулевого выстрела (например, +3,5 AP по сравнению с YOLO) и работает в 1,4 раза быстрее при значительно меньших ресурсах обучения. По сравнению с подходами на основе трансформаторов (например, GLIP), YOLOE предлагает на порядки более быстрый вывод, эффективно преодолевая разрыв в точности и эффективности при обнаружении открытых наборов.
В заключение, YOLOE сохраняет известную скорость и эффективность YOLO, превосходит предшественников по точности, интегрирует сегментацию и представляет мощное обнаружение в открытом мире, что делает его уникально универсальным и практичным.
Случаи использования и приложения
Обнаружение и сегментация с открытым словарем в YOLOE позволяют использовать разнообразные приложения, выходящие за рамки традиционных моделей с фиксированными классами:
-
Обнаружение объектов в открытом мире: Идеально подходит для динамичных сценариев, таких как робототехника, где роботы распознают ранее невидимые объекты с помощью подсказок, или системы безопасности, быстро адаптирующиеся к новым угрозам (например, опасным предметам) без переобучения.
-
Обнаружение по нескольким и одному снимку: Используя визуальные подсказки (SAVPE), YOLOE быстро изучает новые объекты по одним опорным изображениям - идеальное решение для промышленного контроля (мгновенная идентификация деталей или дефектов) или индивидуального наблюдения, позволяющее осуществлять визуальный поиск с минимальными настройками.
-
Большой словарный запас и длиннохвостовое распознавание: Благодаря словарному запасу из 1000 с лишним классов YOLOE отлично справляется с такими задачами, как мониторинг биоразнообразия (обнаружение редких видов), музейные коллекции, инвентаризация розничной торговли или электронная коммерция, надежно идентифицируя множество классов без длительного обучения для каждого класса.
-
Интерактивное обнаружение и сегментация: YOLOE поддерживает интерактивные приложения в реальном времени, такие как поиск видео/изображений, дополненная реальность (AR) и интуитивное редактирование изображений, управляемое естественным вводом (текстовые или визуальные подсказки). Пользователи могут динамически изолировать, идентифицировать или точно редактировать объекты с помощью масок сегментации.
-
Автоматизированная маркировка данных и бутстрапинг: YOLOE способствует быстрому созданию наборов данных, предоставляя начальные ограничительные рамки и аннотации сегментации, что значительно сокращает усилия человека по маркировке. Это особенно ценно при анализе больших коллекций мультимедиа, где он может автоматически идентифицировать присутствующие объекты, помогая быстрее строить специализированные модели.
-
Сегментация для любых объектов: Расширяет возможности сегментации произвольных объектов с помощью подсказок - особенно полезно для медицинской визуализации, микроскопии или анализа спутниковых снимков, автоматически определяя и точно сегментируя структуры без специализированных предварительно обученных моделей. В отличие от таких моделей, как SAMYOLOE одновременно распознает и сегментирует объекты автоматически, помогая в таких задачах, как создание контента или понимание сцены.
Во всех этих случаях основным преимуществом YOLOE является универсальность, предоставляющая унифицированную модель для обнаружения, распознавания и сегментации в динамических сценариях. Его эффективность обеспечивает производительность в реальном времени на устройствах с ограниченными ресурсами, что идеально подходит для робототехники, автономного вождения, обороны и других областей.
Совет
Выберите режим YOLOE в зависимости от ваших потребностей:
- Режим фиксированного набора: Для задач с фиксированным набором классов (максимальная скорость и точность).
- Режим подсказок: Быстро добавляйте новые объекты с помощью текстовых или визуальных подсказок.
- Режим открытого набора без подсказок: Общее обнаружение по многим категориям (идеально подходит для каталогизации и обнаружения).
Часто сочетание режимов, таких как обнаружение без запроса с последующими целевыми запросами, раскрывает весь потенциал YOLOE.
Обучение и вывод
YOLOE легко интегрируется с Ultralytics Python API и CLI, аналогично другим моделям YOLO (YOLOv8, YOLO-World). Вот как быстро начать работу:
Обучение и вывод с 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's set_classes
. Визуальные подсказки (запросы на основе изображений) в настоящее время требуют Python API.
Другие поддерживаемые задачи
- Проверка: Легко оцените точность с помощью
model.val()
илиyolo val
. - Экспорт: Экспорт моделей YOLOE (
model.export()
) в ONNX, TensorRT и т. д., что облегчает развертывание. - Отслеживание: YOLOE поддерживает отслеживание объектов (
yolo track
) при интеграции, полезно для отслеживания запрошенных классов в видео.
Примечание
YOLOE автоматически включает маски сегментации в результатах инференса (results[0].masks
), упрощая задачи, требующие высокой точности, такие как извлечение объектов или измерение, без необходимости в отдельных моделях.
Начало работы
Быстро настройте YOLOE с помощью Ultralytics, выполнив следующие действия:
-
Установка: Установите или обновите пакет Ultralytics:
pip install -U ultralytics
-
Скачать веса YOLOE: Предварительно обученные модели YOLOE (например, YOLOE-v8-S/L, варианты YOLOE-11) доступны в выпусках YOLOE на GitHub. Просто скачайте нужную вам
.pt
файл для загрузки в класс Ultralytics YOLO. -
Аппаратные требования:
- Инференс: Рекомендуемый GPU (NVIDIA с ≥4-8 ГБ VRAM). Небольшие модели эффективно работают на периферийных GPU (например, Jetson) или CPU при более низком разрешении.
- Обучение: Тонкая настройка YOLOE на пользовательских данных обычно требует всего одного GPU. Обширное предварительное обучение с открытым словарем (LVIS/Objects365), используемое авторами, потребовало значительных вычислительных ресурсов (8× RTX 4090 GPU).
-
Конфигурация: В конфигурациях YOLOE используются стандартные YAML-файлы Ultralytics. Конфигурации по умолчанию (например,
yoloe-11s-seg.yaml
) обычно достаточно, но вы можете изменить backbone, классы или размер изображения по мере необходимости. -
Запуск 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()
- Быстрый вывод (без запроса):
-
Советы по интеграции:
- Названия классов: В выходных данных YOLOE по умолчанию используются категории LVIS; используйте
set_classes()
чтобы указать собственные метки. - Скорость: YOLOE не имеет накладных расходов, если не используются подсказки. Текстовые подсказки оказывают минимальное влияние; визуальные подсказки — несколько большее.
- Пакетный вывод: Поддерживается напрямую (
model.predict([img1, img2])
). Для подсказок, специфичных для изображений, запускайте изображения индивидуально.
- Названия классов: В выходных данных YOLOE по умолчанию используются категории LVIS; используйте
Дополнительные ресурсы можно найти в документации 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},
}
Для дальнейшего чтения оригинальная статья YOLOE доступна на arXiv. Исходный код проекта и дополнительные ресурсы можно найти в их репозитории GitHub.
Часто задаваемые вопросы
Чем YOLOE отличается от YOLO-World?
Хотя и YOLOE, и YOLO-World обеспечивают обнаружение с открытым словарем, YOLOE предлагает несколько преимуществ. YOLOE достигает на +3,5 AP более высокой точности на LVIS, используя в 3 раза меньше ресурсов для обучения и работая в 1,4 раза быстрее, чем YOLO-Worldv2. YOLOE также поддерживает три режима подсказок (текстовый, визуальный и внутренний словарь), тогда как YOLO-World в основном фокусируется на текстовых подсказках. Кроме того, YOLOE включает встроенные возможности сегментации экземпляров, предоставляя пиксельные маски для обнаруженных объектов без дополнительных затрат.
Могу ли я использовать YOLOE как обычную модель YOLO?
Да, YOLOE может функционировать точно так же, как и стандартная модель YOLO, без снижения производительности. При использовании в режиме замкнутого набора (без запросов) модули открытого словаря YOLOE репараметризуются в стандартную головку обнаружения, что приводит к идентичной скорости и точности, как и у эквивалентных моделей YOLO11. Это делает YOLOE чрезвычайно универсальным — вы можете использовать его как традиционный детектор для максимальной скорости, а затем переключаться в режим открытого словаря только при необходимости.
Какие типы подсказок я могу использовать с YOLOE?
YOLOE поддерживает три типа запросов:
- Текстовые подсказки: Укажите классы объектов, используя естественный язык (например, «человек», «светофор», «скутер для птиц»)
- Визуальные подсказки: Предоставьте эталонные изображения объектов, которые вы хотите обнаружить
- Внутренний словарь: Используйте встроенный словарь YOLOE, содержащий более 1200 категорий, без внешних подсказок.
Эта гибкость позволяет адаптировать YOLOE к различным сценариям без переобучения модели, что делает ее особенно полезной для динамических сред, где требования к обнаружению часто меняются.
Как YOLOE обрабатывает сегментацию экземпляров?
YOLOE интегрирует сегментацию экземпляров непосредственно в свою архитектуру, расширяя головку обнаружения ветвью предсказания маски. Этот подход аналогичен YOLOv8-Seg, но работает для любого класса объектов с запросами. Маски сегментации автоматически включаются в результаты инференса и могут быть доступны через results[0].masks
. Этот унифицированный подход устраняет необходимость в отдельных моделях обнаружения и сегментации, оптимизируя рабочие процессы для приложений, требующих пиксельно-точных границ объектов.
Как YOLOE обрабатывает вывод с пользовательскими подсказками?
Подобно YOLO-World, YOLOE поддерживает стратегию «сначала подсказка, затем обнаружение», которая использует автономный словарь для повышения эффективности. Пользовательские подсказки, такие как подписи или конкретные категории объектов, предварительно кодируются и сохраняются в виде автономных векторных представлений словаря. Этот подход упрощает процесс обнаружения, не требуя переобучения. Вы можете динамически устанавливать эти подсказки в модели, чтобы адаптировать ее к конкретным задачам обнаружения:
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()