YOLOE: viendo cualquier cosa en tiempo real

Introducción

YOLOE (Real-Time Seeing Anything) es un nuevo avance en modelos YOLO de tipo zero-shot y con prompts, 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 prompts de texto, imagen o 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 zero-shot de vanguardia con un impacto mínimo en la velocidad y la precisión.

En comparación con los modelos YOLO anteriores, YOLOE mejora significativamente la eficiencia y la precisión. Mejora en +3.5 AP sobre YOLO-Worldv2 en LVIS mientras utiliza solo un tercio de los recursos de entrenamiento y logra velocidades de inferencia 1.4× más rápidas. Ajustado en COCO, YOLOE-v8-large supera a YOLOv8-L por 0.1 mAP, usando casi 4× menos tiempo de entrenamiento. Esto demuestra el equilibrio excepcional de YOLOE en cuanto a precisión, eficiencia y versatilidad. Las siguientes secciones exploran la arquitectura de YOLOE, las comparaciones de benchmarks y la integración con el marco de trabajo Ultralytics.

Descripción general de la arquitectura

YOLOE conserva la estructura estándar de YOLO: un backbone convolucional (p. ej., CSP-Darknet) para la extracción de características, un neck (p. ej., PAN-FPN) para la fusión multiescala y una head de detección desacoplada y sin anclas (como en YOLOv8/YOLO11) que predice la presencia de objetos, clases y cajas de forma independiente. YOLOE introduce tres nuevos módulos que permiten la detección de vocabulario abierto:

• Re-parameterizable Region-Text Alignment (RepRTA): Admite detección mediante prompts de texto refinando los embeddings de texto (p. ej., 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 un consumo de recursos nulo. Por lo tanto, YOLOE detecta objetos etiquetados con texto arbitrario (p. ej., un "semáforo" no visto previamente) sin penalizaciones en tiempo de ejecución.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Permite la detección mediante prompts visuales a través de una rama de embedding ligera. Dada una imagen de referencia, SAVPE codifica características semánticas y de activación, condicionando al modelo para detectar objetos visualmente similares, una capacidad de detección one-shot útil para logotipos o partes específicas.

• Lazy Region-Prompt Contrast (LRPC): En el modo sin prompts, YOLOE realiza el reconocimiento de conjuntos abiertos utilizando embeddings internos entrenados con vocabularios grandes (más de 1200 categorías de LVIS y Objects365). Sin prompts ni codificadores externos, YOLOE identifica objetos mediante una búsqueda de similitud de embeddings, manejando eficientemente grandes espacios de etiquetas en la inferencia.

Además, YOLOE integra segmentación de instancias en tiempo real al extender la cabeza de detección con una rama de predicción de máscaras (similar a YOLACT o YOLOv8-Seg), añadiendo un coste mínimo.

Fundamentalmente, los módulos de mundo abierto de YOLOE no introducen coste de inferencia cuando se utilizan como un YOLO normal de conjunto cerrado. Tras el entrenamiento, los parámetros de YOLOE pueden ser re-parametrizados en una head estándar de YOLO, conservando los mismos FLOPs y velocidad (p. ej., coincidiendo exactamente con YOLO11).

Modelos disponibles, tareas admitidas y modos de funcionamiento

Esta sección detalla los modelos disponibles con sus pesos preentrenados específicos, las tareas que admiten y su compatibilidad con varios modos de operación como Inferencia, Validación, Entrenamiento y Exportación, denotados por ✅ para los modos admitidos y ❌ para los modos no admitidos.

Modelos con prompts de texto/visuales

Modelos sin prompts (Prompt Free)

Ejemplos de uso

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

Uso del entrenamiento

Ajuste fino (fine-tuning) en un conjunto de datos personalizado

Puedes ajustar cualquier modelo YOLOE preentrenado en tu 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-26s-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-26s.yaml")

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-26s-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
)

Uso de la predicción (Predict)

YOLOE admite prompts tanto basados en texto como visuales. Usar prompts es sencillo: solo pásalos a través del método predict como se muestra a continuación:

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-26l-seg.pt")  # or yoloe-26s/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.
model.set_classes(["person", "bus"])

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

# Show results
results[0].show()

Uso de validación (Val)

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

from ultralytics import YOLOE

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

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

Uso de la exportación

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

from ultralytics import YOLOE

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

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

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

• Entrenar datos

• Datos de validación

Lanzar el entrenamiento desde cero

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

# Option 1: Use Python dictionary
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"]),
)

# Option 2: Use YAML file (yoloe_data.yaml)
# train:
#   yolo_data:
#     - Objects365.yaml
#   grounding_data:
#     - img_path: flickr/full_images/
#       json_file: flickr/annotations/final_flickr_separateGT_train_segm.json
#     - img_path: mixed_grounding/gqa/images
#       json_file: mixed_grounding/annotations/final_mixed_train_no_coco_segm.json
# val:
#   yolo_data:
#     - lvis.yaml

model = YOLOE("yoloe-26l-seg.yaml")
model.train(
    data=data,  # or data="yoloe_data.yaml" if using YAML file
    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",
)

Comparativa de 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 y LVIS, sin comprometer la velocidad ni el tamaño del modelo. La siguiente tabla compara YOLOE-L (basado en YOLO11) y YOLOE26-L (basado en YOLO26) frente a los modelos de conjunto cerrado correspondientes:

^† YOLOE-L comparte la arquitectura de YOLO11-L y YOLOE26-L comparte la arquitectura de YOLO26-L, lo que resulta en una velocidad de inferencia y GFLOPs similares.

YOLOE26-L logra un 36.8% de mAP en LVIS con 32.3M de parámetros y 88.3B de FLOPs, procesando imágenes de 640×640 a 6.2 ms (161 FPS) en una GPU T4. Esto supone una mejora respecto al 35.2% de mAP en LVIS de YOLOE-L manteniendo la misma velocidad de inferencia. Fundamentalmente, los módulos de vocabulario abierto de YOLOE no tienen coste de inferencia, lo que demuestra un diseño de "compensación sin almuerzo gratis".

Para tareas de disparo cero (zero-shot), YOLOE26 supera significativamente a los detectores de vocabulario abierto anteriores: en LVIS, YOLOE26-S logra un 29.9% de mAP, superando a YOLO-World-S por +11.4 AP, mientras que YOLOE26-L alcanza un 36.8% de mAP, superando a YOLO-World-L por +10.0 AP. YOLOE26 mantiene una inferencia eficiente a 161 FPS en una GPU T4, ideal para aplicaciones de vocabulario abierto en tiempo real.

Comparación con modelos anteriores

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

• YOLOE frente a YOLOv5: YOLOv5 ofrecía un buen equilibrio entre velocidad y precisión, pero requería reentrenamiento para nuevas clases y utilizaba cabezales basados en anclas. Por el contrario, YOLOE es sin anclas y detecta clases nuevas de forma dinámica. YOLOE, basándose en las mejoras de YOLOv8, logra una mayor precisión (52.6% frente a ~50% de mAP de YOLOv5 en COCO) e integra segmentación de instancias, a diferencia de YOLOv5.

• YOLOE frente a YOLOv8: YOLOE extiende la arquitectura rediseñada de YOLOv8, logrando una precisión similar o superior (52.6% mAP con ~26M de parámetros frente al 52.9% con ~44M de parámetros de YOLOv8-L). Reduce significativamente el tiempo de entrenamiento gracias a un preentrenamiento más potente. El avance clave es la capacidad de mundo abierto de YOLOE, detectando objetos no vistos (p. ej., "bird scooter" o "peace symbol") mediante prompts, a diferencia del diseño de conjunto cerrado de YOLOv8.

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

• YOLOE26 frente a YOLOE (basado en YOLO11): YOLOE26 se basa en la arquitectura de YOLO26, heredando su diseño integral sin NMS para una inferencia más rápida. En LVIS, YOLOE26-L alcanza un 36.8% de mAP, mejorando el 35.2% de mAP de YOLOE-L. YOLOE26 ofrece las cinco escalas de modelo (N/S/M/L/X) en comparación con las tres de YOLOE (S/M/L), proporcionando más flexibilidad para diferentes escenarios de implementación.

• YOLOE26 frente a detectores de vocabulario abierto previos: Los modelos de vocabulario abierto anteriores (GLIP, OWL-ViT, YOLO-World) dependían en gran medida de transformers de visión-lenguaje, lo que resultaba en una inferencia lenta. En LVIS, YOLOE26-S alcanza un 29.9% de mAP (+11.4 AP sobre YOLO-World-S) y YOLOE26-L logra un 36.8% de mAP (+10.0 AP sobre YOLO-World-L), manteniendo una inferencia en tiempo real a 161 FPS en una GPU T4. En comparación con los enfoques basados en transformers (p. ej., GLIP), YOLOE26 ofrece una inferencia órdenes de magnitud más rápida, cerrando eficazmente la brecha de precisión-eficiencia en la detección de conjunto abierto.

En resumen, YOLOE y YOLOE26 mantienen la famosa velocidad y eficiencia de YOLO, superan a sus predecesores en precisión, integran segmentación e introducen una potente detección de mundo abierto. YOLOE26 hace avanzar aún más la arquitectura con inferencia integral sin NMS de YOLO26, lo que lo hace ideal para aplicaciones de vocabulario abierto en tiempo real.

Casos de uso y aplicaciones

La detección y segmentación de vocabulario abierto de YOLOE permiten diversas aplicaciones más allá de los modelos tradicionales de clases fijas:

• Detección de objetos en mundo abierto: Ideal para escenarios dinámicos como la robótica, donde los robots reconocen objetos previamente desconocidos utilizando prompts, o sistemas de seguridad que se adaptan rápidamente a nuevas amenazas (p. ej., artículos peligrosos) sin necesidad de reentrenamiento.

• Detección de pocos disparos (few-shot) y un solo disparo (one-shot): Utilizando prompts visuales (SAVPE), YOLOE aprende rápidamente nuevos objetos a partir de imágenes de referencia únicas: perfecto para inspección industrial (identificando piezas o defectos al instante) o vigilancia personalizada, permitiendo búsquedas visuales con una configuración mínima.

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

• Detección y segmentación interactiva: YOLOE admite aplicaciones interactivas en tiempo real, tales como recuperación de vídeo/imágenes buscables, realidad aumentada (AR) y edición intuitiva de imágenes, impulsadas por entradas naturales (textos o prompts 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 al proporcionar anotaciones iniciales de cajas delimitadoras y segmentación, lo que reduce significativamente el esfuerzo de etiquetado humano. Es especialmente valioso en el análisis de grandes colecciones multimedia, donde puede identificar automáticamente los objetos presentes, ayudando a crear modelos especializados más rápidamente.

• Segmentación para cualquier objeto: Extiende las capacidades de segmentación a objetos arbitrarios a través de prompts; particularmente beneficioso para imágenes médicas, microscopía o análisis de imágenes por satélite, identificando y segmentando estructuras con precisión automáticamente sin necesidad de modelos preentrenados especializados. A diferencia de modelos como SAM, YOLOE reconoce y segmenta objetos automáticamente de forma simultánea, ayudando en tareas como la creación de contenido o la comprensión de escenas.

En todos estos casos de uso, la ventaja principal de YOLOE es su versatilidad, proporcionando un modelo unificado para detección, reconocimiento y segmentación en escenarios dinámicos. Su eficiencia garantiza un rendimiento en tiempo real en dispositivos con recursos limitados, siendo ideal para robótica, conducción autónoma, 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í tienes cómo empezar rápidamente:

from ultralytics import YOLO

# Load pretrained YOLOE model and train on custom data
model = YOLO("yoloe-26s-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

Otras tareas compatibles

• Validación: Evalúa la precisión fácilmente con model.val() o yolo val.
• Exportación: Exporta modelos YOLOE (model.export()) a ONNX, TensorRT, etc., facilitando la implementación.
• Seguimiento: YOLOE admite el seguimiento de objetos (yolo track) cuando está integrado, útil para seguir clases solicitadas mediante prompts en vídeos.

Introducción

Configura YOLOE rápidamente con Ultralytics siguiendo estos pasos:

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

   pip install -U ultralytics

2. Descarga de pesos de YOLOE: Los modelos YOLOE preentrenados (p. ej., YOLOE-v8-S/L, variantes YOLOE-11) están disponibles en los lanzamientos de GitHub de YOLOE. Simplemente descarga tu archivo .pt deseado para cargarlo en la clase YOLO de Ultralytics.

3. Requisitos de hardware:

   • Inferencia: Se recomienda GPU (NVIDIA con ≥4-8GB VRAM). Los modelos pequeños funcionan eficientemente en GPU de borde (p. ej., Jetson) o CPU a resoluciones más bajas. Para una inferencia de alto rendimiento en estaciones de trabajo compactas, consulta nuestra guía NVIDIA DGX Spark.
   • Entrenamiento: El ajuste fino de YOLOE en datos personalizados suele requerir solo una GPU. El extenso preentrenamiento de vocabulario abierto (LVIS/Objects365) utilizado por los autores requirió una capacidad de cómputo sustancial (8× GPUs RTX 4090).

4. Configuración: Las configuraciones de YOLOE utilizan archivos YAML estándar de Ultralytics. Las configuraciones por defecto (p. ej., yoloe-26s-seg.yaml) suelen ser suficientes, pero puedes modificar el backbone, las clases o el tamaño de la imagen según sea necesario.

5. Ejecutar YOLOE:

   • Inferencia rápida (sin prompt):

     yolo predict model=yoloe-26s-seg-pf.pt source="image.jpg"

   • Detección con prompt (ejemplo de prompt de texto):

     from ultralytics import YOLO
     
     model = YOLO("yoloe-26s-seg.pt")
     model.set_classes(["bowl", "apple"])
     results = model.predict("kitchen.jpg")
     results[0].save()

6. Consejos de integración:

   • Nombres de clases: Las salidas por defecto de YOLOE utilizan categorías LVIS; usa set_classes() para especificar tus propias etiquetas.
   • Velocidad: YOLOE no tiene carga adicional a menos que se utilicen prompts. Los prompts de texto tienen un impacto mínimo; los visuales un poco más.
   • Comportamiento de NMS: YOLOE utiliza automáticamente agnostic_nms=True durante la predicción, fusionando cajas superpuestas entre clases. Esto evita detecciones duplicadas cuando el mismo objeto coincide con varias categorías en el amplio vocabulario de YOLOE (más de 1200 clases LVIS). Puedes anular esto pasando agnostic_nms=False explícitamente.
   • Inferencia por lotes: Soportada directamente (model.predict([img1, img2])). Para prompts específicos de imagen, ejecuta las imágenes individualmente.

La documentación de Ultralytics proporciona recursos adicionales. YOLOE te permite explorar fácilmente potentes capacidades de mundo abierto dentro del conocido ecosistema YOLO.

Citas y reconocimientos

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

@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 seguir leyendo, el artículo original de YOLOE está disponible en arXiv. El código fuente del proyecto y recursos adicionales se pueden acceder a través de su repositorio de GitHub.

Preguntas frecuentes

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

Aunque tanto YOLOE como YOLO-World permiten la detección de vocabulario abierto, YOLOE ofrece varias ventajas. YOLOE logra una precisión +3.5 AP superior en LVIS utilizando 3 veces menos recursos de entrenamiento y funcionando 1.4 veces más rápido que YOLO-Worldv2. YOLOE también admite tres modos de prompting (texto, visual y vocabulario interno), mientras que YOLO-World se centra principalmente en prompts de texto. Además, YOLOE incluye capacidades integradas de segmentación de instancias, proporcionando máscaras de precisión a nivel de píxel para los objetos detectados sin carga adicional.

¿Puedo usar YOLOE como un modelo YOLO normal?

Sí, YOLOE puede funcionar exactamente como un modelo YOLO estándar sin penalización de rendimiento. Cuando se utiliza en modo de conjunto cerrado (sin prompts), los módulos de vocabulario abierto de YOLOE se re-parametrizan en el cabezal 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 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. Prompts de texto: Especifica clases de objetos usando lenguaje natural (p. ej., "persona", "semáforo", "patinete eléctrico")
2. Prompts visuales: Proporciona imágenes de referencia de los objetos que deseas detectar
3. Vocabulario interno: Usa el vocabulario integrado de YOLOE de más de 1200 categorías sin prompts externos

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

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

YOLOE integra la segmentación de instancias directamente en su arquitectura mediante la extensión del cabezal de detección con una rama de predicción de máscaras. Este enfoque es similar al de YOLOv8-Seg pero funciona para cualquier clase de objeto con prompt. Las máscaras de segmentación se incluyen automáticamente en los resultados de inferencia y se pueden acceder mediante results[0].masks. Este enfoque unificado elimina la necesidad de modelos de detección y segmentación separados, simplificando los flujos de trabajo para aplicaciones que requieren límites de objetos de precisión a nivel de píxel.

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

Similar a YOLO-World, YOLOE admite una estrategia de "prompt-entonces-detecta" que utiliza un vocabulario sin conexión (offline) para mejorar la eficiencia. Los prompts personalizados, como subtítulos o categorías de objetos específicas, se codifican previamente y se almacenan como incrustaciones de vocabulario offline. Este enfoque simplifica el proceso de detección sin requerir reentrenamiento. Puedes configurar dinámicamente estos prompts dentro del modelo para adaptarlo a tareas de detección específicas:

from ultralytics import YOLO

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

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

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

# Show results
results[0].show()