YOLOE: Detección y segmentación de vocabulario abierto en tiempo real#

Ultralytics YOLOE (Real-Time Seeing Anything) es un modelo de detección de vocabulario abierto y segmentación de instancias: en lugar de una lista de clases fija en el momento del entrenamiento, toma las categorías que deseas en el momento de la inferencia como un texto descriptivo, un ejemplo visual o un vocabulario integrado de 4.585 nombres. Construido sobre las arquitecturas Ultralytics YOLO —YOLOv8, YOLO11 y YOLO26— e inspirado en YOLO-World, YOLOE alcanza una precisión de vanguardia sin entrenamiento previo (zero-shot) con una velocidad cercana a la de un YOLO de conjunto cerrado.

Inicio rápido#

Indica las clases que quieras y ejecuta. YOLOE-26 devuelve cuadros delimitadores y máscaras de segmentación de instancias para categorías con las que nunca ha sido entrenado.

from ultralytics import YOLOE

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

# "double-decker bus" is not a COCO class; YOLOE resolves it from the words alone
model.set_classes(["double-decker bus", "person"])

results = model.predict("https://ultralytics.com/images/bus.jpg")
results[0].show()

La primera llamada a set_classes() descarga un codificador de texto; consulta la sección Instalación y requisitos antes de realizar el despliegue en una máquina sin acceso a la red.

Elegir un modo de indicación#

YOLOE admite tres modos de indicación, y la elección determina qué punto de control (checkpoint) cargas y cómo se ven las etiquetas de tus clases. Selecciona la fila que coincida con lo que puedes proporcionar en el momento de la inferencia.

Instalación y requisitos#

YOLOE se incluye en el paquete principal de Ultralytics:

pip install -U ultralytics

La indicación de texto requiere además un codificador de texto, el cual se descarga en el primer uso en lugar de durante la instalación:

• La primera llamada a set_classes() instala ultralytics/CLIP desde GitHub con pip (proporciona el tokenizador) y descarga un codificador de texto TorchScript en el directorio de trabajo actual. YOLOE-26 descarga mobileclip2_b.ts, de unos 254 MB; YOLOE-11 y YOLOE-v8 descargan mobileclip_blt.ts. Ejecuta la descarga una vez desde el directorio desde el que vas a operar, o copia el archivo allí; de lo contrario, se volverá a solicitar.
• Ambos pasos requieren acceso a la red, así que ejecuta una predicción guiada antes de realizar el despliegue en una máquina sin conexión o aislada (air-gapped).
• Las indicaciones visuales y los puntos de control sin indicaciones no necesitan ningún codificador de texto.

Los puntos de control de YOLOE-26 requieren ultralytics 8.4.0 o posterior; las familias YOLOE-11 y YOLOE-v8 están disponibles en versiones anteriores. Una predicción guiada por texto pone a prueba todo el proceso: descarga del punto de control, instalación de CLIP, codificador de texto e inferencia:

yolo predict model=yoloe-26s-seg.pt source="https://ultralytics.com/images/bus.jpg" classes="person"

Para omitir por completo la descarga del codificador de texto en el momento de la inferencia, integra las indicaciones en los pesos una sola vez y reutilízalas; consulta Reutilizar incrustaciones de indicaciones.

Descripción general de la arquitectura#

YOLOE mantiene la estructura estándar de YOLO —una red troncal (backbone) convolucional para la extracción de características, un cuello (neck) para la fusión multiescala y una cabeza desacoplada y libre de anclajes que predice clases y cuadros— y añade tres módulos, uno por cada modo de indicación:

• Alineación de región y texto reparametrizable (RepRTA): Refina las incrustaciones de texto de CLIP mediante una pequeña red auxiliar. Dicha red se ejecuta una vez por cada llamada a set_classes() y se pliega durante la exportación, por lo que no genera costes por fotograma. Lo que sí se ejecuta en cada pase de propagación hacia adelante es la comparación de las incrustaciones de indicaciones almacenadas con las características de las regiones; consulta Limitaciones para conocer el coste que esto supone con un conjunto de indicaciones grande.
• Codificador de indicaciones visuales activado por semántica (SAVPE): Codifica las características semánticas y de activación a partir de un cuadro de ejemplo, condicionando el modelo a objetos que tengan un aspecto similar. Esta es la ruta de un solo disparo (one-shot) para objetivos difíciles de nombrar, como un logotipo o una pieza específica.
• Contraste de indicaciones de regiones perezoso (LRPC): Compara las incrustaciones de regiones con un vocabulario integrado de 4.585 nombres, de modo que los puntos de control sin indicaciones reconocen objetos sin necesidad de indicaciones externas ni de un codificador de texto.

La segmentación de instancias proviene de una rama de máscaras en la cabeza de detección, tal como en YOLOv8-Seg, y cada predicción incluye una máscara en results[0].masks. Una vez que el modelo es exportado, los módulos de mundo abierto se reparametrizan en una cabeza YOLO estándar, por lo que el archivo exportado ejecuta la ruta habitual de detección y segmentación.

Modelos disponibles#

Cada punto de control a continuación es un modelo de segmentación de instancias y es compatible con val, predict, export y track. Carga un archivo *-seg.pt para la indicación por texto o visual y un archivo *-seg-pf.pt para la inferencia sin indicaciones; no son intercambiables, consulta Elegir un modo de indicación. Solo los archivos *-seg.pt admiten train; un punto de control sin indicaciones se genera a partir de un modelo entrenado con indicaciones de texto, consulta Entrenar los modelos oficiales desde cero.

Rendimiento de YOLOE en LVIS#

Resultados de zero-shot en el conjunto minival de LVIS a 640 píxeles, extraídos del documento de investigación de Ultralytics YOLO26.

Indicaciones de texto y visuales#

Cada celda de precisión y parámetros muestra indicación de texto / indicación visual; los FLOPs se indican una sola vez. Los parámetros y los FLOPs corresponden a la configuración de detección evaluada en el artículo. La precisión es la cifra Non-E2E del artículo, el único protocolo que reporta para cada modelo en la comparativa; la cabeza de extremo a extremo (end-to-end) de YOLOE-26 se queda por detrás por un máximo de 1,1 AP con indicaciones de texto y 2,6 AP con indicaciones visuales.

Sin prompt#

Los puntos de control sin indicaciones responden a partir de su vocabulario integrado sin que se proporcione ninguna indicación. Cada celda de precisión muestra end-to-end / Non-E2E, los dos protocolos bajo los cuales el artículo evalúa YOLOE-26; la página de YOLO26 cita la columna Non-E2E.

Con indicaciones de texto y visuales, los modelos YOLOE-26 superan a sus homólogos YOLOE-11 y YOLOE-v8 en cada escala correspondiente en mAP_50-95, manteniéndose por debajo de la línea de la versión v8 en cuanto a parámetros y FLOPs. En la misma partición (split), el artículo reporta YOLO-Worldv2 con 24,4 (S), 32,4 (M) y 35,5 (L), y los detectores basados en Transformer GLIP-T con 26,0, GDINO-T con 27,4 y DetCLIP-T con 34,4, cada uno con entre 155 y 232 M de parámetros. El artículo original de YOLOE añade dos resultados para los modelos a escala v8 que introdujo. En LVIS, YOLOE-v8s supera a YOLO-Worldv2-S por 3,5 AP con un tercio del coste de entrenamiento y 1,4 veces la velocidad de inferencia. Al transferirse a COCO, YOLOE-v8l gana 0,6 AP de cuadro y 0,4 AP de máscara en comparación con el modelo de conjunto cerrado YOLOv8-L, con un tiempo de entrenamiento casi 4 veces menor.

Ejemplos de uso#

Cada ejemplo de YOLOE que se muestra a continuación se ejecuta desde la API de Python. La predicción con indicaciones de texto, la validación, la exportación, el rastreo y el entrenamiento simple también funcionan desde la CLI; las recetas de ajuste fino (fine-tuning) y las indicaciones visuales pasan una clase de entrenador o predictor como argumento, lo cual solo acepta la API de Python.

Uso de entrenamiento#

Ajusta con precisión (fine-tune) cualquier punto de control *-seg.pt publicado en tu propio conjunto de datos de YOLO. Esto sigue principalmente el procedimiento estándar de entrenamiento de YOLO; la diferencia radica en el entrenador que pasas. YOLOEPESegTrainer fusiona los nombres de tus clases en la cabeza y realiza el ajuste fino a partir de ahí, que es lo que buscas para tus propias etiquetas; el entrenador predeterminado no entrena con los nombres de tus clases.

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

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

results = model.train(
    data="coco128-seg.yaml",
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: the fine-tuning trainer, not the default
)

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

model = YOLOE("yoloe-26s.yaml").load("yoloe-26s-seg.pt")

results = model.train(data="coco128.yaml", epochs=80, patience=10, trainer=YOLOEPETrainer)

Uso de Predict#

La llamada de indicación de texto es la que se muestra en Inicio rápido. Los otros dos modos requieren cada uno un argumento adicional:

import numpy as np

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

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

# One example box per target, each with its own class ID
visual_prompts = {
    "bboxes": np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # person, glasses
    "cls": np.array([0, 1]),
}

results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

import numpy as np

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

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

visual_prompts = {"bboxes": np.array([[221.52, 405.8, 344.98, 857.54]]), "cls": np.array([0])}  # person

results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image
    refer_image="ultralytics/assets/bus.jpg",  # Where the example boxes live
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

# refer_image also sets the classes permanently, so later calls need no prompts at all
results = model("ultralytics/assets/bus.jpg")
model.export(format="onnx")  # And the export keeps them

import numpy as np
import torch

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

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

img_tensor = torch.rand(1, 3, 480, 480)  # (1, 3, H, W) float tensor in [0, 1]
visual_prompts = {"bboxes": np.array([[10, 10, 50, 50]]), "cls": np.array([0])}

results = model.predict(
    img_tensor,
    refer_image=img_tensor,
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
    imgsz=640,
)

import numpy as np

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

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

visual_prompts = {
    "bboxes": [
        np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # bus.jpg: person, glasses
        np.array([[150, 200, 1150, 700]]),  # zidane.jpg: person
    ],
    "cls": [np.array([0, 1]), np.array([0])],
}

results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

Uso de Val#

La validación se ejecuta como en cualquier otro modelo en un conjunto de datos de segmentación:

from ultralytics import YOLOE

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

metrics = model.val(data="coco128-seg.yaml")

Dos variantes de la misma llamada cubren los demás modos de indicación:

• Indicaciones visuales: model.val(data="coco128-seg.yaml", load_vp=True) extrae una incrustación visual por categoría del propio conjunto de datos. Añade refer_data="coco.yaml" para obtener las incrustaciones de un conjunto de datos diferente, el cual debe contener exactamente las mismas categorías.
• Sin indicaciones: carga un punto de control *-seg-pf.pt y pasa single_cls=True.

Uso de exportación#

Los embeddings de prompts se pueden guardar una sola vez y reutilizar al generar exportaciones estáticas como ONNX, OpenVINO, TensorRT, CoreML, LiteRT y RKNN. El perfil NPZ se carga en el modelo original de PyTorch antes de la exportación; no es una entrada adicional en tiempo de ejecución y el modelo exportado no requiere el archivo NPZ.

from ultralytics import YOLOE

model = YOLOE("yoloe-26n-seg.pt")
model.set_classes(["person", "bus"])
model.save_prompt_embeddings("person-bus.npz")

# The profile is bound to the source checkpoint and can be reused for later exports.
model = YOLOE("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="onnx")

El mismo perfil de prompt también puede configurar un modelo exclusivo de detección construido a partir de la arquitectura YOLOE correspondiente. Esto elimina la rama de máscaras mientras conserva las clases indicadas:

from ultralytics import YOLOE

model = YOLOE("yoloe-26n.yaml").load("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="rknn", name="rk3588", quantize=16)

Uso de Track#

Las clases guiadas se transfieren directamente al rastreo, por lo que puedes seguir objetos con los que el rastreador nunca ha sido entrenado:

from ultralytics import YOLOE

model = YOLOE("yoloe-26s-seg.pt")
model.set_classes(["forklift", "pallet"])

# persist=True keeps track IDs stable across frames
for result in model.track("path/to/video.mp4", stream=True, persist=True):
    print(result.boxes.id)

Cómo se compara YOLOE#

YOLOE se sitúa entre un detector de conjunto cerrado y un modelo de vocabulario abierto de gran peso. Tres comparaciones determinan si es la opción correcta:

• Frente a un YOLO de conjunto cerrado. Una vez establecidas las indicaciones, YOLOE predice a través de la ruta habitual de detección y segmentación y se exporta como cualquier otro modelo. Lo que aporta es la capacidad de cambiar la lista de clases en el momento de la inferencia en lugar de reentrenar; el coste es una precisión zero-shot muy inferior a la de un modelo entrenado con tus propias clases.
• Frente a las familias YOLOE anteriores. YOLOE-26 hereda la cabeza de extremo a extremo sin NMS de YOLO26 y cubre cinco escalas (n/s/m/l/x) frente a las tres anteriores (s/m/l), liderando en cada escala correspondiente en Rendimiento.
• Frente a detectores de vocabulario abierto basados en Transformer. GLIP y OWL-ViT ejecutan un Transformer de visión-lenguaje en la inferencia. YOLOE codifica las indicaciones una sola vez y luego las compara con las características de las regiones dentro de una cabeza convolucional.

Las alternativas más cercanas aceptan una indicación de texto, pero solo YOLOE y SAM 3 devuelven máscaras, y las tres responden a preguntas diferentes:

¿Vienes de YOLO-World? La API tiene la misma forma: cambia YOLOWorld por YOLOE, carga un punto de control *-seg.pt y mantén tu llamada set_classes() tal como está. Obtienes máscaras e indicaciones visuales; la nota de exportación sobre clases congeladas se aplica a ambas.

Casos de uso y aplicaciones#

La detección de vocabulario abierto elimina el paso de reentrenamiento por clase, lo cual importa más cuando la lista de objetivos no se conoce de antemano:

• Detección en mundo abierto — robótica y sistemas de seguridad que encuentran objetos que nadie enumeró en el momento del entrenamiento.
• Detección de un solo ejemplo — las indicaciones visuales seleccionan una parte específica, logotipo o defecto a partir de un único cuadro de referencia, útil en inspección industrial.
• Catalogación de cola larga — el vocabulario integrado de 4585 nombres es lo suficientemente amplio para monitoreo de biodiversidad o barridos de inventario minorista.
• Generación de conjuntos de datos — etiqueta previamente imágenes con cuadros y máscaras antes de la revisión humana, luego entrena un modelo rápido de conjunto cerrado con el resultado.
• Segmentación de objetivos arbitrarios — los puntos de control *-seg.pt publicados devuelven una máscara con cada predicción, por lo que la imagen médica y el análisis satelital obtienen resultados precisos a nivel de píxel sin un segundo modelo.

Un patrón común combina dos modos: ejecuta sin indicaciones una vez para descubrir qué hay presente, luego cambia a indicaciones de texto para las categorías que importan.

Limitaciones#

YOLOE sacrifica precisión a cambio de la capacidad de cambiar clases en el momento de la inferencia. Las consecuencias que vale la pena conocer antes de comprometerte:

• La precisión de disparo cero está muy por debajo de un modelo entrenado en tus clases. Los puntos de control con indicaciones se sitúan aproximadamente en la banda de 22-40 mAP en la validación reducida de LVIS; un YOLO de conjunto cerrado entrenado con tus propios datos superará eso en esas clases. Usa YOLOE para cubrir clases para las que no puedes entrenar, no para reemplazar el entrenamiento.
• Las categorías raras son el punto débil. La columna mAP_r en Rendimiento informa específicamente sobre la precisión en las clases raras de LVIS, y bajo indicaciones de texto se sitúa por debajo de las columnas común y frecuente en cada fila. Revísala en lugar del mAP principal cuando tus objetivos sean inusuales.
• Una indicación describe la apariencia, no las relaciones. La detección funciona comparando las características de la región con la incrustación de la indicación, por lo que las indicaciones que dependen del estado, contexto o comparación —«dañado», «más a la izquierda», «el que está siendo transportado»— no tienen un punto de referencia fiable para coincidir. Prefiere una redacción cercana a los nombres de categorías cotidianos.
• Los conjuntos grandes de indicaciones cuestan latencia. Las incrustaciones de las indicaciones se calculan una vez, pero se comparan con las características de la región en cada pasada hacia adelante. Medido en CPU con yoloe-26s-seg.pt, una pasada hacia adelante aumenta aproximadamente un 19% al pasar de 80 a 1203 clases y aproximadamente un 89% con el vocabulario completo de 4585 nombres. Los FLOPs reportados no se mueven en absoluto, porque la similitud entre región y texto no se cuenta, por lo que el perfil no te avisará.
• Los nombres de las clases son marcadores de posición hasta que indicas. Un punto de control *-seg.pt recién cargado informa nc=80 con nombres numéricos ("0", "1", …), así que llama a set_classes() antes de leer las etiquetas. Los puntos de control sin indicaciones vienen con el vocabulario completo ya poblado.

Notas de despliegue#

• Hardware. La inferencia necesita una GPU NVIDIA con 4-8 GB de VRAM; las escalas n y s se ejecutan en GPUs de borde como Jetson o en CPU a resolución reducida. El ajuste fino necesita una sola GPU.
• NMS es agnóstico de clase por defecto. YOLOE predice con agnostic_nms=True. En YOLOE-11 y YOLOE-v8, esto suprime los cuadros superpuestos con menor puntuación entre diferentes clases en lugar de solo dentro de la misma clase, lo que evita duplicados cuando un objeto coincide con varias categorías. Los modelos YOLOE-26 de extremo a extremo no aplican ninguna supresión de IoU; allí, el modo agnóstico solo mantiene la única mejor clase por anclaje en lugar de permitir que un anclaje emita varias etiquetas de clase. Pasa agnostic_nms=False para anular esto.
• Lotes. La inferencia por lotes funciona directamente, y las indicaciones visuales pueden diferir por imagen en la misma llamada.

Entrenamiento de los modelos oficiales desde cero#

La mayoría de los lectores nunca necesitan esto. Reproduce los puntos de control de vocabulario abierto publicados a partir de Objects365, GQA y Flickr30k —alrededor de 1,4 millones de muestras de entrenamiento en 8× RTX 4090— y no está relacionado con el ajuste fino en tus propios datos, el cual se cubre en Uso de entrenamiento arriba.

El entrenamiento necesita anotaciones de segmentación. Descarga los archivos procesados a continuación o genera los tuyos propios con el script proporcionado por el equipo oficial, el cual funciona con SAM 2.1. La validación utiliza la validación reducida de LVIS.

El modelo de indicación de texto se entrena primero, y los otros dos modos de indicación son refinamientos de este:

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

data = {
    "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 the path to a YAML file holding the same structure
    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",
)

Los puntos de control de indicación visual y sin indicaciones parten de ese modelo de indicación de texto entrenado y actualizan un módulo cada uno. YOLOESegVPTrainer es la receta de indicación visual y YOLOEPEFreeTrainer la de sin indicaciones, pero ninguno congela nada por sí solo: el entrenamiento selectivo proviene de la lista freeze que pasas junto a él, la cual nombra a todos los hijos de la cabeza excepto savpe (respectivamente, cada torre de clasificación), y la ejecución sin indicaciones necesita además single_cls=True. El repositorio original de YOLOE contiene las recetas completas para los modelos a escala v8.

Una ejecución sin indicaciones finalizada se reparametriza en un punto de control que informa sus nombres sin ninguna indicación en la inferencia, utilizando get_vocab y set_vocab:

from ultralytics import YOLOE

# Weights written by the prompt-free run and by the text-prompt run it started from. Each
# rerun creates a new directory (train-2, train-3, ...), so take the paths the runs printed.
model = YOLOE("runs/segment/train-2/weights/best.pt")  # prompt-free run, its head is already fused
text_model = YOLOE("runs/segment/train/weights/best.pt")  # text-prompt run, its head is still unfused

names = list(YOLOE("yoloe-26l-seg-pf.pt").model.names.values())  # the 4,585-name vocabulary, or your own list
vocab = text_model.get_vocab(names)

model.set_vocab(vocab, names)
model.save("yoloe-26l-seg-pf-custom.pt")  # never overwrite the released checkpoint

Citas y agradecimientos#

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 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 lecturas adicionales, el artículo original de YOLOE está disponible en arXiv. Se puede acceder al código fuente del proyecto y a recursos adicionales a través de su repositorio de GitHub.

FAQ#