YOLOE: возможность видеть что угодно в реальном времени

Введение

YOLOE (Real-Time Seeing Anything) - это новое достижение в моделях YOLO с нулевым выстрелом и подсказками, предназначенное для обнаружения и сегментации объектов с открытым словарным запасом. В отличие от предыдущих моделей YOLO , ограниченных фиксированными категориями, YOLOE использует подсказки в виде текста, изображений или внутреннего словаря, позволяя в реальном времени обнаруживать любые классы объектов. Построенная на базе YOLOv10 и вдохновленная YOLO, YOLOE достигает современной производительности при нулевом выстреле с минимальным влиянием на скорость и точность.

Смотреть: Как использовать YOLOE с пакетом Ultralytics Python : Open Vocabulary & Real-Time Seeing Anything 🚀

По сравнению с предыдущими моделями YOLO , YOLOE значительно повышает эффективность и точность. Она превосходит YOLO на LVIS на +3,5 AP, используя при этом лишь треть обучающих ресурсов и достигая 1,4× более высокой скорости вывода. При тонкой настройке на COCO YOLOE-v8-large превосходит YOLOv8 на 0,1 mAP, затрачивая почти в 4 раза меньше времени на обучение. Это демонстрирует исключительный баланс точности, эффективности и универсальности YOLOE. В следующих разделах рассматривается архитектура YOLOE, сравнение с эталонами и интеграция с системой Ultralytics фреймворком Ultralytics.

Обзор архитектуры

YOLOE сохраняет стандартную структуру YOLO - конволюционную основу (например, CSP-Darknet) для извлечения признаков, "шею" (например, PAN-FPN) для многомасштабного слияния и безъякорную, раздельную головку обнаружения (как в YOLO11), предсказывающую объектность, классы и коробки независимо. YOLOE представляет три новых модуля, позволяющих обнаруживать открытые словари:

• Перепараметризуемое выравнивание региона и текста (RepRTA): поддерживает обнаружение по текстовому запросу путем уточнения текстовых вкраплений (например, из CLIP) с помощью небольшой вспомогательной сети. При выводе эта сеть складывается в основную модель, обеспечивая нулевые накладные расходы. Таким образом, YOLOE обнаруживает произвольные объекты с текстовыми метками (например, невидимый "светофор") без ущерба для времени выполнения.

• Кодировщик визуальных подсказок с семантической активацией (SAVPE): Обеспечивает обнаружение по визуальному запросу с помощью облегченной ветви встраивания. Получив эталонное изображение, SAVPE кодирует семантические и активационные признаки, настраивая модель на обнаружение визуально похожих объектов - возможность одномоментного обнаружения, полезная для логотипов или специфических деталей.

• Lazy Region-Prompt Contrast (LRPC): В режиме без подсказок YOLOE выполняет распознавание открытых наборов, используя внутренние вкрапления, обученные на больших словарях (1200+ категорий из LVIS и Objects365). Без внешних подсказок или кодировщиков YOLOE идентифицирует объекты с помощью поиска сходства вкраплений, эффективно обрабатывая большие пространства меток при выводе.

Кроме того, YOLOE интегрирует сегментацию экземпляров в реальном времени, расширяя головку обнаружения ветвью предсказания маски (подобно YOLACT или YOLOv8), что добавляет минимальные накладные расходы.

Очень важно, что модули YOLOE с открытым миром не влекут за собой никаких затрат на вывод при использовании в качестве обычного YOLO с закрытым набором. После обучения параметры YOLOE могут быть перепараметризованы в стандартную голову YOLO , сохраняя идентичные FLOP и скорость (например, соответствие YOLO11 точно).

Доступные модели, поддерживаемые задачи и режимы работы

В этом разделе подробно описаны доступные модели с определенными предварительно обученными весами, задачи, которые они поддерживают, и их совместимость с различными режимами работы, такими как Inference, Validation, Training и Export, обозначенными ✅ для поддерживаемых режимов и ❌ для неподдерживаемых режимов.

Модели с текстовыми/визуальными подсказками

Оперативно Бесплатные модели

Примеры использования

Модели YOLOE легко интегрируются в ваши приложения Python . Ultralytics предоставляет удобный Python API и командыCLI для упрощения разработки.

Использование поезда

Тонкая настройка на пользовательском наборе данных

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

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

model.train(
    data="coco128-seg.yaml",
    epochs=80,
    close_mosaic=10,
    batch=128,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
)

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

model = YOLOE("yoloe-11s-seg.pt")
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="coco128-seg.yaml",
    epochs=2,
    close_mosaic=0,
    batch=16,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
    freeze=freeze,
)

Прогнозирование использования

YOLOE поддерживает как текстовые, так и визуальные подсказки. Использовать подсказки очень просто - просто передайте их через predict как показано ниже:

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()

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()

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()

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()

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.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
from ultralytics.models.yolo.yoloe import YOLOESegTrainerFromScratch

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/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",
)

import torch

from ultralytics import YOLOE

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="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/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")

import torch

from ultralytics import YOLOE

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="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/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. YOLOv8 и YOLO11 :

^† YOLO11 и YOLOE-L имеют идентичную архитектуру (в YOLO11 отключены модули подсказок), что приводит к одинаковой скорости вычислений и схожим оценкам GFLOPs.

YOLOE-L достигает 52,6 % mAP, превосходя YOLOv8(52,9 %) при примерно 40 % меньшем количестве параметров (26 М против 43,7 М). Он обрабатывает изображения 640×640 за 6,2 мс (161 кадр/с) по сравнению с 9,06 мс (110 кадр/с) у YOLOv8, что подчеркивает эффективность YOLO11. Очень важно, что модули YOLOE с открытым словарем не требуют затрат на вывод, демонстрируя дизайн "без компромиссов на бесплатный обед".

В задачах с нулевым выстрелом и переносом YOLOE превосходит всех: на LVIS YOLOE-small превосходит YOLO на +3,5 AP, затрачивая на обучение в 3 раза меньше ресурсов. Тонкая настройка YOLOE-L при переходе от LVIS к COCO также потребовала в 4 раза меньше времени на обучение, чем YOLOv8, что подчеркивает эффективность и адаптивность YOLOE. YOLOE также сохраняет отличительную скорость YOLO, достигая 300+ FPS на GPU T4 и ~64 FPS на iPhone 12 с помощью CoreML, что идеально подходит для пограничных и мобильных развертываний.

Сравнение с предыдущими моделями

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 легко интегрируется с Ultralytics Python API и CLIкак и другие модели YOLO YOLOv8, YOLO). Вот как быстро начать работу:

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

# 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"

Другие поддерживаемые задачи

• Валидация: Оценить точность легко с помощью model.val() или yolo val.
• Экспорт: Экспорт моделей YOLOE (model.export()) в ONNX, TensorRT и т.д., что облегчает развертывание.
• Отслеживание: YOLOE поддерживает слежение за объектами (yolo track) при интеграции, что полезно для отслеживания подсказанных классов в видео.

Начало работы

Быстро настройте YOLOE с Ultralytics , выполнив следующие действия:

1. Установка: Установите или обновите пакет Ultralytics :

   pip install -U ultralytics
   

2. Скачать YOLOE Weights: Предварительно обученные модели YOLOE (например, варианты YOLOE-v8-S/L, YOLOE-11) доступны из релизов YOLOE на GitHub. Просто загрузите нужную вам модель .pt файл для загрузки в класс Ultralytics YOLO .

3. Требования к аппаратному обеспечению:

   • Заключение: Рекомендуется GPU NVIDIA с ≥4-8 ГБ VRAM). Небольшие модели эффективно работают на граничных GPU (например, Jetson) или CPU при более низком разрешении.
   • Обучение: Тонкая настройка YOLOE на пользовательских данных обычно требует всего одного GPU. Обширное предварительное обучение с использованием открытого словаря (LVIS/Objects365), использованное авторами, потребовало значительных вычислений (8× RTX 4090 GPU).

4. Конфигурация: Конфигурации YOLOE используют стандартные YAML-файлы Ultralytics . Конфигурации по умолчанию (например, yoloe-11s-seg.yaml) обычно достаточно, но вы можете изменить костяк, классы или размер изображения по мере необходимости.

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 внесла вклад в ваше исследование или проект, пожалуйста, процитируйте оригинальную статью Ао Ванга, Лихао Лю, Хуи Чена, Цзыцзя Линя, Чжунгон Ханя и Гуйгуань Дина из Университета Цинхуа:

@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?

Хотя и YOLOE, и YOLO позволяют распознавать открытую лексику, YOLOE имеет ряд преимуществ. YOLOE достигает точности +3,5 AP на LVIS, используя при этом в 3 раза меньше ресурсов для обучения и работая в 1,4 раза быстрее, чем YOLO. YOLOE также поддерживает три режима подсказок (текстовый, визуальный и внутренний словарь), в то время как YOLO ориентирован в основном на текстовые подсказки. Кроме того, YOLOE включает встроенные возможности сегментации экземпляров, обеспечивая пиксельно-точные маски для обнаруженных объектов без дополнительных накладных расходов.

Могу ли я использовать YOLOE как обычную модель YOLO ?

Да, YOLOE может работать точно так же, как стандартная модель YOLO , без снижения производительности. При использовании в режиме закрытого набора (без подсказок) модули открытого словаря YOLOE перепараметрируются в стандартную детекторную головку, в результате чего скорость и точность работы идентичны эквивалентным моделям YOLO11 . Это делает YOLOE чрезвычайно универсальным - вы можете использовать его как традиционный детектор для максимальной скорости, а затем переключаться в режим открытого словаря только при необходимости.

Какие типы подсказок можно использовать с YOLOE?

YOLOE поддерживает три типа подсказок:

1. Текстовые подсказки: Укажите классы объектов с помощью естественного языка (например, "человек", "светофор", "скутер")
2. Визуальные подсказки: Предоставьте эталонные изображения объектов, которые вы хотите обнаружить
3. Внутренний словарь: Используйте встроенный словарь YOLOE, состоящий из 1200+ категорий, без внешних подсказок

Такая гибкость позволяет адаптировать YOLOE к различным сценариям без переобучения модели, что делает ее особенно полезной в динамичных средах, где требования к обнаружению часто меняются.

Как YOLOE обрабатывает сегментацию экземпляров?

YOLOE интегрирует сегментацию экземпляров непосредственно в свою архитектуру, расширяя головку обнаружения ветвью предсказания маски. Этот подход аналогичен YOLOv8, но работает для любого класса объектов. Маски сегментации автоматически включаются в результаты вывода и могут быть доступны через results[0].masks. Этот единый подход устраняет необходимость в отдельных моделях обнаружения и сегментации, упрощая рабочие процессы для приложений, требующих пиксельной точности границ объектов.

Как YOLOE обрабатывает умозаключения с помощью пользовательских подсказок?

Подобно YOLO, 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()

📅 Создано 2 месяца назад ✏️ Обновлено 1 месяц назад

Комментарии