YOLOE: Viendo Cualquier Cosa en Tiempo Real

Introducción

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

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

Modelos sin indicaciones (Prompt Free)

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.

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
)

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

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:

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

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

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:

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)

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:

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

• Datos de entrenamiento

• Datos de Val

Lanzando el entrenamiento desde cero

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

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

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

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

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

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

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

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

from copy import deepcopy

from ultralytics import YOLOE

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

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

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

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

from ultralytics import YOLOE

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

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

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

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

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

from copy import deepcopy

from ultralytics import YOLOE

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

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

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

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:

^† 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.

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 nuevas clases y utilizaba cabezas basadas en anclas. En cambio, YOLOE no utiliza anclas y detecta nuevas clases de forma dinámica. YOLOE, basándose en las mejoras de YOLOv8, logra una mayor precisión (52,6% frente al ~50% de mAP de YOLOv5 en COCO) e integra la segmentación de instancias, a diferencia de YOLOv5.

• YOLOE frente a YOLOv8: YOLOE se extiende YOLOv8consiguiendo una precisión similar o superior(52,6% mAP con ~26M de parámetros frente al 52,9% de YOLOv8 con ~44M de parámetros). Reduce significativamente el tiempo de entrenamiento gracias a un mayor preentrenamiento. El avance clave es la capacidad de mundo abierto de YOLOE, que detecta objetos invisibles (por ejemplo,"pájaro patinete" o"símbolo de la paz") mediante instrucciones, a diferencia del diseño de conjunto cerrado de YOLOv8.

• YOLOE frente a YOLO11: YOLO11 mejora YOLOv8 con mayor eficacia y menos parámetros (~22% de reducción). YOLOE hereda directamente estas mejoras, igualando la velocidad de inferencia y el número de parámetros de YOLO11(~26 millones de parámetros), al tiempo que añade la detección y segmentación de vocabulario abierto. En escenarios cerrados, YOLOE es equivalente a YOLO11, pero añade una adaptabilidad crucial para detectar clases no vistas, logrando YOLO11 + capacidad de mundo abierto sin comprometer la velocidad.

• YOLOE frente a anteriores detectores de vocabulario abierto: Los modelos anteriores de vocabulario abierto (GLIP, OWL-ViT, YOLO) se basaban en gran medida en transformadores de visión-lenguaje, lo que provocaba una inferencia lenta. YOLOE los supera en precisión cero (por ejemplo, +3,5 AP frente a YOLO) y funciona 1,4 veces más rápido con recursos de formación significativamente menores. En comparación con los enfoques basados en transformadores (p. ej., GLIP), YOLOE ofrece una inferencia varios órdenes de magnitud más rápida, lo que salva la brecha entre precisión y 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 no vistos previamente mediante avisos, o sistemas de seguridad que se adaptan rápidamente a nuevas amenazas (por ejemplo, objetos peligrosos) sin necesidad de reentrenamiento.

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

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

• Detección y segmentación interactivas: YOLOE es compatible con aplicaciones interactivas en tiempo real, como la recuperación de imágenes y vídeos con función de búsqueda, la realidad aumentada (RA) y la edición intuitiva de imágenes mediante entradas naturales (texto o indicaciones visuales). Los usuarios pueden aislar, identificar o editar objetos de forma dinámica y precisa mediante máscaras de segmentación.

• Etiquetado automático de datos y Bootstrapping: YOLOE facilita la creación rápida de conjuntos de datos proporcionando anotaciones iniciales de cajas delimitadoras y segmentación, lo que reduce significativamente los esfuerzos de etiquetado humano. Especialmente valioso en el análisis de grandes colecciones de medios, donde puede identificar automáticamente los objetos presentes, ayudando a crear modelos especializados con mayor rapidez.

• Segmentación de cualquier objeto: Amplía las capacidades de segmentación a objetos arbitrarios a través de indicaciones -especialmente beneficioso para el análisis de imágenes médicas, microscopía o imágenes de satélite-, identificando automáticamente y segmentando con precisión estructuras sin modelos especializados preentrenados. A diferencia de modelos como SAMYOLOE reconoce y segmenta objetos automáticamente de forma simultánea, lo que ayuda en tareas como la creación de contenidos 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.

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:

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"

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.

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.

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 6 meses ✏️ Actualizado hace 19 días

Comentarios