Ir al contenido

YOLOE: Viendo Cualquier Cosa en Tiempo Real

Introducción

Opciones de prompting de YOLOE

YOLOE (Real-Time Seeing Anything) es un nuevo avance en los modelos YOLO de disparo cero y programables, diseñados para la detección y segmentación de vocabulario abierto. A diferencia de los modelos YOLO anteriores limitados a categorías fijas, YOLOE utiliza texto, imágenes o indicaciones de vocabulario interno, lo que permite la detección en tiempo real de cualquier clase de objeto. Construido sobre YOLOv10 e inspirado en YOLO-World, YOLOE logra un rendimiento de disparo cero de última generación con un impacto mínimo en la velocidad y la precisión.



Ver: Cómo utilizar YOLOE con el paquete de python Ultralytics: Vocabulario abierto y ver cualquier cosa en tiempo real 🚀

En comparación con los modelos YOLO anteriores, YOLOE aumenta significativamente la eficiencia y la precisión. Mejora en +3.5 AP con respecto a YOLO-Worldv2 en LVIS, utilizando solo un tercio de los recursos de entrenamiento y logrando velocidades de inferencia 1.4 veces más rápidas. Ajustado en COCO, YOLOE-v8-large supera a YOLOv8-L en 0.1 mAP, utilizando casi 4 veces menos tiempo de entrenamiento. Esto demuestra el equilibrio excepcional de precisión, eficiencia y versatilidad de YOLOE. Las siguientes secciones exploran la arquitectura de YOLOE, las comparaciones de referencia y la integración con el framework de Ultralytics.

Descripción General de la Arquitectura

Arquitectura de YOLOE

YOLOE conserva la estructura estándar de YOLO: un backbone convolucional (por ejemplo, CSP-Darknet) para la extracción de características, un neck (por ejemplo, PAN-FPN) para la fusión multiescala y un head de detección desacoplado y sin anclajes (como en YOLOv8/YOLO11) que predice la objetividad, las clases y los cuadros de forma independiente. YOLOE introduce tres nuevos módulos que permiten la detección de vocabulario abierto:

  • Alineación región-texto reparametrizable (RepRTA): Admite la detección basada en texto mediante el refinamiento de incrustaciones de texto (por ejemplo, de CLIP) a través de una pequeña red auxiliar. En la inferencia, esta red se integra en el modelo principal, lo que garantiza una sobrecarga nula. Por lo tanto, YOLOE detecta objetos arbitrarios etiquetados con texto (por ejemplo, un "semáforo" no visto) sin penalizaciones en tiempo de ejecución.

  • Codificador visual de avisos activado semánticamente (SAVPE): Permite la detección visual solicitada a través de una rama de incrustación ligera. Dada una imagen de referencia, SAVPE codifica las características semánticas y de activación, condicionando el modelo para detectar objetos visualmente similares: una capacidad de detección de un solo disparo útil para logotipos o partes específicas.

  • Contraste de Región-Prompt Lazy (LRPC): En modo sin prompt, YOLOE realiza el reconocimiento de conjunto abierto utilizando incrustaciones internas entrenadas en grandes vocabularios (más de 1200 categorías de LVIS y Objects365). Sin prompts o codificadores externos, YOLOE identifica objetos mediante la búsqueda de similitud de incrustaciones, manejando eficientemente grandes espacios de etiquetas en la inferencia.

Además, YOLOE integra la segmentación de instancias en tiempo real extendiendo el encabezado de detección con una rama de predicción de máscara (similar a YOLACT o YOLOv8-Seg), añadiendo una sobrecarga mínima.

Fundamentalmente, los módulos de mundo abierto de YOLOE no introducen ningún coste de inferencia cuando se utilizan como un YOLO regular de conjunto cerrado. Después del entrenamiento, los parámetros de YOLOE pueden ser reparametrizados en un encabezado YOLO estándar, preservando los mismos FLOPs y velocidad (por ejemplo, coincidiendo exactamente con YOLO11).

Modelos disponibles, tareas compatibles y modos de funcionamiento

En esta sección se detallan los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con varios modos de operación como Inferencia, Validación, Entrenamiento y Exportación, denotado por ✅ para los modos compatibles y ❌ para los modos no compatibles.

Modelos de Prompt Text/Visual

Tipo de Modelo Pesos Pre-entrenados Tareas admitidas Inferencia Validación Entrenamiento Exportar
YOLOE-11S yoloe-11s-seg.pt Segmentación de instancias
YOLOE-11M yoloe-11m-seg.pt Segmentación de instancias
YOLOE-11L yoloe-11l-seg.pt Segmentación de instancias
YOLOE-v8S yoloe-v8s-seg.pt Segmentación de instancias
YOLOE-v8M yoloe-v8m-seg.pt Segmentación de instancias
YOLOE-v8L yoloe-v8l-seg.pt Segmentación de instancias

Modelos sin indicaciones (Prompt Free)

Tipo de Modelo Pesos Pre-entrenados Tareas admitidas Inferencia Validación Entrenamiento Exportar
YOLOE-11S-PF yoloe-11s-seg-pf.pt Segmentación de instancias
YOLOE-11M-PF yoloe-11m-seg-pf.pt Segmentación de instancias
YOLOE-11L-PF yoloe-11l-seg-pf.pt Segmentación de instancias
YOLOE-v8S-PF yoloe-v8s-seg-pf.pt Segmentación de instancias
YOLOE-v8M-PF yoloe-v8m-seg-pf.pt Segmentación de instancias
YOLOE-v8L-PF yoloe-v8l-seg-pf.pt Segmentación de instancias

Ejemplos de uso

Los modelos YOLOE son fáciles de integrar en sus aplicaciones de python. Ultralytics proporciona una API de python y comandos CLI fáciles de usar para agilizar el desarrollo.

Uso del Entrenamiento

Ajuste fino en un conjunto de datos personalizado

Puede ajustar cualquier modelo YOLOE preentrenado en su conjunto de datos YOLO personalizado tanto para tareas de detección como de segmentación de instancias.

Ejemplo

Segmentación de instancias

El ajuste de un punto de control preentrenado de YOLOE sigue principalmente el procedimiento de entrenamiento estándar de YOLO. La diferencia clave es pasar explícitamente YOLOEPESegTrainer como el trainer a 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
)

Detección de objetos

Todos los modelos YOLOE preentrenados realizan la segmentación de instancias de forma predeterminada. Para utilizar estos puntos de control preentrenados para entrenar un modelo de detección, inicialice un modelo de detección desde cero utilizando la configuración YAML y, a continuación, cargue el punto de control de segmentación preentrenado de la misma escala. Tenga en cuenta que utilizamos YOLOEPETrainer en lugar de YOLOEPESegTrainer ya que estamos entrenando un modelo de detección:

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
)

El sondeo lineal ajusta solo la rama de clasificación mientras congela el resto del modelo. Este enfoque es útil cuando se trabaja con datos limitados, ya que previene el sobreajuste al aprovechar las características aprendidas previamente mientras adapta solo el encabezado de clasificación.

Segmentación de instancias

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

Detección de objetos

Para la tarea de detección de objetos, el proceso de entrenamiento es casi el mismo que el ejemplo de segmentación de instancias anterior, pero usamos YOLOEPETrainer en lugar de YOLOEPESegTrainer, e inicializamos el modelo de detección de objetos usando el YAML y luego cargamos los pesos del punto de control de segmentación de instancias preentrenado.

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

Uso de Predicción

YOLOE admite tanto el prompting basado en texto como el visual. Usar prompts es sencillo, solo tienes que pasarlos a través de predict método como se muestra a continuación:

Ejemplo

Las indicaciones de texto le permiten especificar las clases que desea detectar a través de descripciones textuales. El siguiente código muestra cómo puede usar YOLOE para detectar personas y autobuses en una imagen:

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

Las indicaciones visuales le permiten guiar el modelo mostrándole ejemplos visuales de las clases objetivo, en lugar de describirlas en texto.

El visual_prompts acepta un diccionario con dos claves: bboxes y cls. Cada bounding box en bboxes debe encerrar herméticamente un ejemplo del objeto que desea que el modelo detecte, y la entrada correspondiente en cls especifica la etiqueta de clase para ese cuadro. Este emparejamiento le dice al modelo: "Así es como se ve la clase X; ahora encuentra más como esta".

IDs de clase (cls) en visual_prompts se utilizan para asociar cada cuadro delimitador con una categoría específica dentro de tu prompt. No son etiquetas fijas, sino identificadores temporales que asignas a cada ejemplo. El único requisito es que los ID de clase sean secuenciales, comenzando desde 0. Esto ayuda al modelo a asociar correctamente cada cuadro con su respectiva clase.

Puede proporcionar indicaciones visuales directamente dentro de la misma imagen en la que desea ejecutar la inferencia. Por ejemplo:

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

O puedes proporcionar ejemplos de una imagen de referencia separada utilizando el refer_image En ese caso, el bboxes y cls en visual_prompts debería describir los objetos en la imagen de referencia, no la imagen de destino en la que está haciendo predicciones:

Nota

Si source es un video o transmisión, el modelo utiliza automáticamente el primer fotograma como refer_image. Esto significa que su visual_prompts se aplican a ese fotograma inicial para ayudar al modelo a entender qué buscar en el resto del vídeo. Alternativamente, puede pasar explícitamente cualquier fotograma específico como el refer_image para controlar qué ejemplos visuales utiliza el modelo como referencia.

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

Usando refer_image también establece las clases de forma permanente, por lo que puedes ejecutar predicciones sin tener que proporcionar los mismos "prompts" visuales de nuevo, y exportar el modelo conservando la capacidad de seguir detectando las mismas clases después de la exportación:

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

También puede pasar varias imágenes de destino para ejecutar la predicción:

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 también incluye variantes sin indicaciones que vienen con un vocabulario incorporado. Estos modelos no requieren ninguna indicación y funcionan como los modelos YOLO tradicionales. En lugar de depender de etiquetas proporcionadas por el usuario o ejemplos visuales, detectan objetos de una lista predefinida de 4585 clases basada en el conjunto de etiquetas utilizado por el 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()

Uso de Val

La validación de modelos en un conjunto de datos se simplifica de la siguiente manera:

Ejemplo

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

Por defecto, utiliza el conjunto de datos proporcionado para extraer incrustaciones visuales para cada categoría.

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)

Alternativamente, podríamos usar otro conjunto de datos como conjunto de datos de referencia para extraer incrustaciones visuales para cada categoría. Ten en cuenta que este conjunto de datos de referencia debe tener exactamente las mismas categorías que el conjunto de datos proporcionado.

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)

Uso de la exportación

El proceso de exportación es similar al de otros modelos YOLO, con la flexibilidad añadida de manejar texto y avisos visuales:

Ejemplo

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

Entrenar modelos oficiales

Preparar conjuntos de datos

Nota

El entrenamiento de modelos YOLOE oficiales necesita anotaciones de segmento para los datos de entrenamiento, aquí está el script proporcionado por el equipo oficial que convierte conjuntos de datos en anotaciones de segmento, impulsado por Modelos SAM2.1. O puede descargar directamente el Processed Segment Annotations en la siguiente tabla proporcionada por el equipo oficial.

  • Datos de entrenamiento
Conjunto de datos Tipo Muestras Cajas delimitadoras Anotaciones de detección sin procesar Anotaciones de Segmentos Procesados
Objects365v1 Detección 609k 9621k objects365_train.json objects365_train_segm.json
GQA Conexión a tierra 621k 3681k final_mixed_train_no_coco.json final_mixed_train_no_coco_segm.json
Flickr30k Conexión a tierra 149k 641k final_flickr_separateGT_train.json final_flickr_separateGT_train_segm.json
  • Datos de Val
Conjunto de datos Tipo Archivos de anotación
LVIS minival Detección minival.txt

Lanzando el entrenamiento desde cero

Nota

Visual Prompt los modelos se ajustan basándose en un entrenamiento adecuado Text Prompt modelos.

Ejemplo

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",
)

Dado que solo el SAVPE el módulo debe actualizarse durante el entrenamiento. Convertir el modelo Text-prompt entrenado adecuadamente en un modelo de detección y adoptar una canalización de detección con un menor coste de entrenamiento. Ten en cuenta que este paso es opcional, también puedes empezar directamente desde la segmentación.

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

Comenzar el entrenamiento:

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

Vuelva a convertir al modelo de segmentación después del entrenamiento. Solo es necesario si convirtió el modelo de segmentación en un modelo de detección antes del entrenamiento.

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

De forma similar al entrenamiento de indicaciones visuales, para el modelo sin indicaciones, solo es necesario actualizar la incrustación de indicaciones especializadas durante el entrenamiento. Convertir el modelo de indicación de texto bien entrenado en un modelo de detección y adoptar una canalización de detección con un menor coste de entrenamiento. Tenga en cuenta que este paso es opcional, también puede empezar directamente desde la segmentación.

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")
Comenzar el entrenamiento:
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
)

Vuelva a convertir al modelo de segmentación después del entrenamiento. Solo es necesario si convirtió el modelo de segmentación en un modelo de detección antes del entrenamiento.

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

Comparación del rendimiento de YOLOE

YOLOE iguala o supera la precisión de los modelos YOLO de conjunto cerrado en puntos de referencia estándar como COCO, sin comprometer la velocidad o el tamaño del modelo. La siguiente tabla compara YOLOE-L (construido sobre YOLO11) con los modelos YOLOv8 y YOLO11 correspondientes:

Modelo COCO mAP50-95 Velocidad de Inferencia (T4) Parámetros GFLOPs (640px)
YOLOv8-L (conjunto cerrado) 52.9% 9.06 ms (110 FPS) 43.7 M 165.2 B
YOLO11-L (conjunto cerrado) 53.5% 6.2 ms (130 FPS) 26.2 M 86.9 B
YOLOE-L (vocabulario abierto) 52.6% 6.2 ms (130 FPS) 26.2 M 86.9 B

YOLO11-L y YOLOE-L tienen arquitecturas idénticas (módulos de prompt desactivados en YOLO11-L), lo que resulta en una velocidad de inferencia idéntica y estimaciones de GFLOPs similares.

YOLOE-L alcanza un 52.6% de mAP, superando a YOLOv8-L (52.9%) con aproximadamente un 40% menos de parámetros (26M vs. 43.7M). Procesa imágenes de 640×640 en 6.2 ms (161 FPS) en comparación con los 9.06 ms (110 FPS) de YOLOv8-L, lo que destaca la eficiencia de YOLO11. Fundamentalmente, los módulos de vocabulario abierto de YOLOE no incurren en costes de inferencia, lo que demuestra un diseño de "sin almuerzo gratis".

Para tareas de cero-shot y transferencia, YOLOE destaca: en LVIS, YOLOE-small mejora a YOLO-Worldv2 en +3.5 AP utilizando 3 veces menos recursos de entrenamiento. El ajuste fino de YOLOE-L de LVIS a COCO también requirió 4 veces menos tiempo de entrenamiento que YOLOv8-L, lo que subraya su eficiencia y adaptabilidad. YOLOE además mantiene la velocidad característica de YOLO, alcanzando más de 300 FPS en una GPU T4 y ~64 FPS en el iPhone 12 a través de CoreML, ideal para implementaciones en el borde y móviles.

Nota

Condiciones de referencia: Los resultados de YOLOE provienen de modelos pre-entrenados en Objects365, GoldG y LVIS, luego ajustados o evaluados en COCO. La ligera ventaja de mAP de YOLOE sobre YOLOv8 proviene de un pre-entrenamiento extenso. Sin este entrenamiento de vocabulario abierto, YOLOE coincide con los modelos YOLO de tamaño similar, lo que afirma su precisión SOTA y su flexibilidad de mundo abierto sin penalizaciones de rendimiento.

Comparación con modelos anteriores

YOLOE introduce avances notables con respecto a los modelos YOLO anteriores y a los detectores de vocabulario abierto:

  • YOLOE vs YOLOv5:
    YOLOv5 ofrecía un buen equilibrio entre velocidad y precisión, pero requería un reentrenamiento para las nuevas clases y utilizaba cabezas basadas en anclajes. En cambio, YOLOE es sin anclajes y detecta dinámicamente nuevas clases. YOLOE, basándose en las mejoras de YOLOv8, logra una mayor precisión (52.6% vs. ~50% mAP de YOLOv5 en COCO) e integra la segmentación de instancias, a diferencia de YOLOv5.

  • YOLOE vs YOLOv8:
    YOLOE extiende la arquitectura rediseñada de YOLOv8, logrando una precisión similar o superior (52.6% mAP con ~26M de parámetros vs. 52.9% de YOLOv8-L con ~44M de parámetros). Reduce significativamente el tiempo de entrenamiento debido a un preentrenamiento más fuerte. El avance clave es la capacidad de mundo abierto de YOLOE, detectando objetos no vistos (por ejemplo, "patinete para pájaros" o "símbolo de la paz") a través de indicaciones, a diferencia del diseño de conjunto cerrado de YOLOv8.

  • YOLOE vs YOLO11:
    YOLO11 mejora YOLOv8 con una eficiencia mejorada y menos parámetros (~22% de reducción). YOLOE hereda estas ganancias directamente, igualando la velocidad de inferencia y el recuento de parámetros de YOLO11 (~26M de parámetros), al tiempo que añade detección y segmentación de vocabulario abierto. En escenarios de conjunto cerrado, YOLOE es equivalente a YOLO11, pero añade crucialmente la adaptabilidad para detectar clases no vistas, logrando YOLO11 + capacidad de mundo abierto sin comprometer la velocidad.

  • YOLOE vs detectores de vocabulario abierto anteriores:
    Los modelos anteriores de vocabulario abierto (GLIP, OWL-ViT, YOLO-World) se basaban en gran medida en transformadores de visión-lenguaje, lo que conducía a una inferencia lenta. YOLOE supera a estos en precisión de cero disparos (por ejemplo, +3.5 AP vs. YOLO-Worldv2) mientras se ejecuta 1.4 veces más rápido con recursos de entrenamiento significativamente menores. En comparación con los enfoques basados en transformadores (por ejemplo, GLIP), YOLOE ofrece órdenes de magnitud de inferencia más rápidas, lo que cierra eficazmente la brecha de precisión-eficiencia en la detección de conjuntos abiertos.

En resumen, YOLOE mantiene la reconocida velocidad y eficiencia de YOLO, supera a sus predecesores en precisión, integra la segmentación e introduce una potente detección de mundo abierto, lo que lo hace excepcionalmente versátil y práctico.

Casos de uso y aplicaciones

La detección y segmentación de vocabulario abierto de YOLOE permite diversas aplicaciones más allá de los modelos tradicionales de clase fija:

  • Detección de Objetos en Mundo Abierto:
    Ideal para escenarios dinámicos como la robótica, donde los robots reconocen objetos nunca antes vistos utilizando indicaciones, o los sistemas de seguridad que se adaptan rápidamente a nuevas amenazas (por ejemplo, elementos peligrosos) sin necesidad de volver a entrenar.

  • Detección con pocos ejemplos y un solo ejemplo:
    Utilizando indicaciones visuales (SAVPE), YOLOE aprende rápidamente nuevos objetos a partir de imágenes de referencia únicas, perfecto para la inspección industrial (identificación instantánea de piezas o defectos) o la vigilancia personalizada, lo que permite búsquedas visuales con una configuración mínima.

  • Reconocimiento de vocabulario extenso y de cola larga:
    Equipado con un vocabulario de más de 1000 clases, YOLOE destaca en tareas como la monitorización de la biodiversidad (detección de especies raras), las colecciones de museos, el inventario minorista o el comercio electrónico, identificando de forma fiable muchas clases sin una formación exhaustiva por clase.

  • Detección y segmentación interactivas:
    YOLOE admite aplicaciones interactivas en tiempo real, como la recuperación de videos/imágenes con capacidad de búsqueda, la realidad aumentada (RA) y la edición de imágenes intuitiva, impulsada por entradas naturales (texto o indicaciones visuales). Los usuarios pueden aislar, identificar o editar objetos dinámicamente con precisión utilizando máscaras de segmentación.

  • Etiquetado y Bootstrapping Automatizado de Datos:
    YOLOE facilita la creación rápida de conjuntos de datos al proporcionar anotaciones iniciales de cuadros delimitadores y segmentación, lo que reduce significativamente los esfuerzos de etiquetado humano. Particularmente valioso en el análisis de grandes colecciones de medios, donde puede auto-identificar los objetos presentes, ayudando a construir modelos especializados más rápido.

  • Segmentación para cualquier objeto:
    Extiende las capacidades de segmentación a objetos arbitrarios a través de indicaciones, lo que es particularmente beneficioso para imágenes médicas, microscopía o análisis de imágenes satelitales, identificando y segmentando automáticamente estructuras sin modelos pre-entrenados especializados. A diferencia de modelos como SAM, YOLOE reconoce y segmenta objetos simultáneamente de forma automática, lo que ayuda en tareas como la creación de contenido o la comprensión de escenas.

En todos estos casos de uso, la principal ventaja de YOLOE es la versatilidad, proporcionando un modelo unificado para la detección, el reconocimiento y la segmentación en escenarios dinámicos. Su eficiencia garantiza un rendimiento en tiempo real en dispositivos con recursos limitados, ideal para la robótica, la conducción autónoma, la defensa y mucho más.

Consejo

Elige el modo de YOLOE según tus necesidades:

  • Modo de conjunto cerrado: Para tareas de clase fija (máxima velocidad y precisión).
  • Modo con indicaciones: Añada nuevos objetos rápidamente mediante indicaciones de texto o visuales.
  • Modo de conjunto abierto sin indicaciones: Detección general en muchas categorías (ideal para catalogación y descubrimiento).

A menudo, la combinación de modos, como el descubrimiento sin indicaciones seguido de indicaciones específicas, aprovecha todo el potencial de YOLOE.

Entrenamiento e Inferencia

YOLOE se integra perfectamente con la API de python de Ultralytics y la CLI, de forma similar a otros modelos YOLO (YOLOv8, YOLO-World). Aquí te mostramos cómo empezar rápidamente:

Entrenamiento e inferencia con 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

Aquí, YOLOE se comporta como un detector estándar de forma predeterminada, pero cambia fácilmente a la detección solicitada especificando clases (set_classes). Los resultados contienen cuadros delimitadores, máscaras y etiquetas.

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

Indicaciones de la CLI (classes) guía YOLOE de forma similar a set_classes. El prompting visual (consultas basadas en imágenes) actualmente requiere la API de python.

Otras tareas admitidas

  • Validación: Evalúe la precisión fácilmente con model.val() o yolo val.
  • Exportar: Exportar modelos YOLOE (model.export()) a ONNX, TensorRT, etc., facilitando el despliegue.
  • Seguimiento: YOLOE admite el seguimiento de objetos (yolo track) cuando se integra, útil para rastrear las clases solicitadas en los vídeos.

Nota

YOLOE incluye automáticamente máscaras de segmentación en los resultados de la inferencia (results[0].masks), lo que simplifica las tareas de precisión de píxeles, como la extracción o la medición de objetos, sin necesidad de modelos separados.

Empezando

Configure rápidamente YOLOE con Ultralytics siguiendo estos pasos:

  1. Instalación: Instala o actualiza el paquete Ultralytics:

    pip install -U ultralytics
    
  2. Descargar Pesos de YOLOE: Los modelos YOLOE pre-entrenados (por ejemplo, YOLOE-v8-S/L, variantes de YOLOE-11) están disponibles en las versiones de YOLOE GitHub. Simplemente descargue el .pt archivo para cargar en la clase YOLO de Ultralytics.

  3. Requisitos de hardware:

    • Inferencia: GPU recomendada (NVIDIA con ≥4-8GB VRAM). Los modelos pequeños se ejecutan de manera eficiente en GPU de borde (por ejemplo, Jetson) o CPU a resoluciones más bajas.
    • Entrenamiento: El ajuste fino de YOLOE en datos personalizados normalmente requiere solo una GPU. El extenso pre-entrenamiento de vocabulario abierto (LVIS/Objects365) utilizado por los autores requirió un cómputo sustancial (8× GPUs RTX 4090).
  4. Configuración: Las configuraciones de YOLOE utilizan archivos YAML estándar de Ultralytics. Configuraciones predeterminadas (por ejemplo, yoloe-11s-seg.yaml) suelen ser suficientes, pero puedes modificar el backbone, las clases o el tamaño de la imagen según sea necesario.

  5. Ejecutando YOLOE:

    • Inferencia rápida (sin *prompt*):
      yolo predict model=yoloe-11s-seg-pf.pt source="image.jpg"
      
    • Detección con indicaciones (ejemplo de indicación de texto):

      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. Consejos de integración:

    • Nombres de clase: Las salidas predeterminadas de YOLOE utilizan categorías LVIS; usa set_classes() para especificar sus propias etiquetas.
    • Velocidad: YOLOE no tiene sobrecarga a menos que se utilicen prompts. Los prompts de texto tienen un impacto mínimo; los prompts visuales un poco más.
    • Inferencia por lotes: Soportado directamente (model.predict([img1, img2])). Para las indicaciones específicas de la imagen, ejecute las imágenes individualmente.

La documentación de Ultralytics proporciona más recursos. YOLOE le permite explorar fácilmente potentes capacidades de mundo abierto dentro del ecosistema YOLO familiar.

Consejo

Consejo profesional: Para maximizar la precisión zero-shot de YOLOE, ajuste con precisión a partir de los puntos de control proporcionados en lugar de entrenar desde cero. Utilice palabras clave que se ajusten a las etiquetas de entrenamiento comunes (véase las categorías LVIS) para mejorar la precisión de la detección.

Citas y agradecimientos

Si YOLOE ha contribuido a su investigación o proyecto, cite el artículo original de Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han y Guiguang Ding de la Universidad de Tsinghua:

@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},
}

Para obtener más información, el artículo original de YOLOE está disponible en arXiv. Se puede acceder al código fuente del proyecto y a los recursos adicionales a través de su repositorio de GitHub.

Preguntas frecuentes

¿En qué se diferencia YOLOE de YOLO-World?

Si bien tanto YOLOE como YOLO-World permiten la detección de vocabulario abierto, YOLOE ofrece varias ventajas. YOLOE alcanza una precisión +3.5 AP más alta en LVIS mientras usa 3 veces menos recursos de entrenamiento y se ejecuta 1.4 veces más rápido que YOLO-Worldv2. YOLOE también admite tres modos de solicitud (texto, visual y vocabulario interno), mientras que YOLO-World se centra principalmente en las indicaciones de texto. Además, YOLOE incluye capacidades integradas de segmentación de instancias, que proporcionan máscaras precisas a nivel de píxel para los objetos detectados sin sobrecarga adicional.

¿Puedo usar YOLOE como un modelo YOLO normal?

Sí, YOLOE puede funcionar exactamente como un modelo YOLO estándar sin penalización en el rendimiento. Cuando se utiliza en modo de conjunto cerrado (sin prompts), los módulos de vocabulario abierto de YOLOE se reparametrizan en el encabezado de detección estándar, lo que resulta en una velocidad y precisión idénticas a los modelos YOLO11 equivalentes. Esto hace que YOLOE sea extremadamente versátil: puedes usarlo como un detector tradicional para obtener la máxima velocidad y luego cambiar al modo de vocabulario abierto solo cuando sea necesario.

¿Qué tipos de prompts puedo usar con YOLOE?

YOLOE admite tres tipos de prompts:

  1. Indicaciones de texto: Especifique las clases de objetos utilizando lenguaje natural (por ejemplo, "persona", "semáforo", "patinete para pájaros")
  2. Indicaciones visuales: Proporcione imágenes de referencia de los objetos que desea detectar
  3. Vocabulario interno: Utilice el vocabulario integrado de YOLOE de más de 1200 categorías sin indicaciones externas

Esta flexibilidad le permite adaptar YOLOE a varios escenarios sin necesidad de volver a entrenar el modelo, lo que lo hace particularmente útil para entornos dinámicos donde los requisitos de detección cambian con frecuencia.

¿Cómo gestiona YOLOE la segmentación de instancias?

YOLOE integra la segmentación de instancias directamente en su arquitectura extendiendo el encabezado de detección con una rama de predicción de máscara. Este enfoque es similar a YOLOv8-Seg, pero funciona para cualquier clase de objeto solicitada. Las máscaras de segmentación se incluyen automáticamente en los resultados de la inferencia y se puede acceder a ellas a través de results[0].masks. Este enfoque unificado elimina la necesidad de modelos de detección y segmentación separados, lo que agiliza los flujos de trabajo para las aplicaciones que requieren límites de objetos con precisión de píxeles.

¿Cómo gestiona YOLOE la inferencia con prompts personalizados?

Similar a YOLO-World, YOLOE admite una estrategia de "prompt-then-detect" (indicación y luego detección) que utiliza un vocabulario fuera de línea para mejorar la eficiencia. Las indicaciones personalizadas, como los subtítulos o las categorías de objetos específicos, se pre-codifican y se almacenan como incrustaciones de vocabulario fuera de línea. Este enfoque agiliza el proceso de detección sin necesidad de volver a entrenar. Puede establecer dinámicamente estas indicaciones dentro del modelo para adaptarlo a tareas de detección específicas:

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


📅 Creado hace 5 meses ✏️ Actualizado hace 11 días

Comentarios