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 vez de usar una lista de clases fijada durante el entrenamiento, recibe las categorías que quieres en el momento de la inferencia, como texto, como ejemplo visual o mediante un vocabulario integrado de 4585 nombres. Basado en las arquitecturas de Ultralytics YOLO —YOLOv8, YOLO11 y YOLO26— e inspirado en YOLO-World, YOLOE alcanza una precisión de vanguardia en tareas de detección sin ejemplos, con una velocidad similar a la de YOLO con clases cerradas.

Inicio rápido#

Indica las clases que quieres y ejecuta el modelo. YOLOE-26 devuelve cajas y máscaras de segmentación de instancias para categorías con las que nunca se ha entrenado.

from ultralytics import YOLOE

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

# "autobús de dos pisos" no es una clase de COCO; YOLOE la identifica solo a partir de las palabras
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 Instalación y requisitos antes de desplegarlo en una máquina sin acceso a la red.

Elegir un modo de indicaciones#

YOLOE admite tres modos de indicaciones, y la elección determina qué punto de control cargas y qué aspecto tienen las etiquetas de clase. Elige la fila que corresponda a lo que puedes proporcionar durante la inferencia.

Instalación y requisitos#

YOLOE está incluido en el paquete principal de Ultralytics:

pip install -U ultralytics

Además, las indicaciones de texto necesitan un codificador de texto, que se descarga la primera vez que se usa en lugar de durante la instalación:

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

Los puntos de control 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 con indicación de texto 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 durante la inferencia, integra las indicaciones en los pesos una vez y reutilízalos; consulta Reutilizar incrustaciones de indicaciones.

Descripción general de la arquitectura#

YOLOE conserva la estructura estándar de YOLO —un backbone convolucional para extraer características, un neck para la fusión multiescala y una cabeza desacoplada y sin anclajes que predice clases y cajas— y añade tres módulos, uno por cada modo de indicaciones:

• Alineación región-texto reparametrizable (RepRTA) refina las incrustaciones de texto de CLIP mediante una pequeña red auxiliar. Esa red se ejecuta una vez por llamada a set_classes() y se elimina al exportar, por lo que no tiene ningún coste por fotograma. Lo que sí se ejecuta en cada pasada hacia delante es la comparación de las incrustaciones de indicaciones almacenadas con las características de las regiones; consulta Limitaciones para saber cuánto cuesta con un conjunto grande de indicaciones.
• Codificador de indicaciones visuales activadas semánticamente (SAVPE) codifica características semánticas y de activación de una caja de ejemplo, y condiciona el modelo para que detecte objetos de aspecto similar. Esta es la vía de aprendizaje de un solo ejemplo para objetivos difíciles de describir, como un logotipo o una pieza concreta.
• Contraste diferido de indicaciones de región (LRPC) compara las incrustaciones de región con un vocabulario integrado de 4585 nombres, para que los puntos de control sin indicaciones reconozcan objetos sin indicaciones externas ni codificador de texto.

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

Modelos disponibles#

Todos los puntos de control siguientes son modelos de segmentación de instancias y admiten val, predict, export y track. Carga un archivo *-seg.pt para usar indicaciones de texto o visuales y un archivo *-seg-pf.pt para la inferencia sin indicaciones; no son intercambiables. Consulta Elegir un modo de indicaciones. 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 sin ejemplos en LVIS minival a 640 píxeles, extraídos del artículo 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 incluye para todos los modelos de la comparación; la cabeza end-to-end de YOLOE-26 queda como máximo 1,1 AP por debajo con indicaciones de texto y 2,6 AP con indicaciones visuales.

Sin indicaciones#

Los puntos de control sin indicaciones responden usando su vocabulario integrado, sin que se les proporcione ninguna indicación. Cada celda de precisión muestra end-to-end/Non-E2E, los dos protocolos con los que 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 equivalentes YOLOE-11 y YOLOE-v8 en todas las escalas coincidentes en mAP_50-95, y se mantienen por debajo de la línea v8 en parámetros y FLOPs. En la misma partición, el artículo presenta 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 de escala v8 que presentó. En LVIS, YOLOE-v8s supera a YOLO-Worldv2-S en 3.5 AP, con un tercio del coste de entrenamiento y 1.4× la velocidad de inferencia. Al transferirlo a COCO, YOLOE-v8l obtiene 0.6 box AP y 0.4 mask AP más que YOLOv8-L de conjunto cerrado, con casi 4× menos tiempo de entrenamiento.

Ejemplos de uso#

Todos los ejemplos de YOLOE siguientes se ejecutan desde la API de Python. La predicción con indicaciones de texto, la validación, la exportación, el seguimiento y el entrenamiento normal también funcionan desde la CLI; las recetas de ajuste fino y las indicaciones visuales pasan una clase de entrenador o predictor como argumento, algo que solo acepta la API de Python.

Uso del entrenamiento#

Ajusta cualquier checkpoint *-seg.pt publicado con tu propio conjunto de datos YOLO. Este proceso sigue en gran medida el procedimiento estándar de entrenamiento de YOLO; la diferencia está en el entrenador que pasas. YOLOEPESegTrainer integra los nombres de tus clases en la cabeza y ajusta el modelo a partir de ahí, que es lo que necesitas para tus propias etiquetas; el entrenador predeterminado no entrena con tus nombres de clase.

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,  # <- Importante: el entrenador de ajuste fino, no el predeterminado
)

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 la predicción#

La llamada con indicaciones de texto es la que se muestra en Inicio rápido. Los otros dos modos necesitan un argumento adicional cada uno:

import numpy as np

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

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

# Una caja de ejemplo por objetivo, cada una con su propio identificador de clase
visual_prompts = {
    "bboxes": np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # persona, gafas
    "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",  # Imagen objetivo
    refer_image="ultralytics/assets/bus.jpg",  # Dónde se encuentran las cajas de ejemplo
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

# refer_image también fija las clases de forma permanente, así que las llamadas posteriores no necesitan indicaciones
results = model("ultralytics/assets/bus.jpg")
model.export(format="onnx")  # Y la exportación las conserva

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), tensor float en [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: persona, gafas
        np.array([[150, 200, 1150, 700]]),  # zidane.jpg: persona
    ],
    "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 la validación#

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

from ultralytics import YOLOE

model = YOLOE("yoloe-26l-seg.pt")  # o yoloe-26s/m-seg.pt para otros tamaños

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

Dos variantes de la misma llamada cubren los otros 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 otro conjunto de datos, que debe contener exactamente las mismas categorías.
• Sin indicaciones — carga un checkpoint *-seg-pf.pt y pasa single_cls=True.

Uso de la exportación#

Las incrustaciones de las indicaciones se pueden guardar una vez y reutilizar al generar exportaciones estáticas como ONNX, OpenVINO, TensorRT, CoreML, LiteRT y RKNN. El modelo PyTorch original carga el perfil NPZ antes de la exportación; no es una entrada adicional en tiempo de ejecución y el modelo exportado no necesita 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")

# El perfil queda vinculado al checkpoint de origen y se puede reutilizar en exportaciones posteriores.
model = YOLOE("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="onnx")

El mismo perfil de indicaciones también puede configurar un modelo solo de detección creado a partir de la arquitectura YOLOE correspondiente. Esto elimina la rama de máscaras y 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)

Seguimiento de uso#

Las clases indicadas pasan directamente al seguimiento, para que puedas seguir objetos con los que nunca se entrenó el rastreador:

from ultralytics import YOLOE

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

# persist=True mantiene estables los ID de seguimiento entre fotogramas
for result in model.track("path/to/video.mp4", stream=True, persist=True):
    print(result.boxes.id)

Comparativa de YOLOE#

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

• Frente a un YOLO de conjunto cerrado. Una vez configuradas las indicaciones, YOLOE predice mediante el flujo normal de detección/segmentación y se exporta como cualquier otro modelo. Lo que añade es la posibilidad de cambiar la lista de clases en tiempo de inferencia en lugar de volver a entrenar; lo que sacrifica es una precisión de cero disparos muy inferior a la de un modelo entrenado con tus propias clases.
• Frente a las familias YOLOE anteriores. YOLOE-26 hereda la cabeza integral sin NMS de YOLO26, admite cinco escalas (n/s/m/l/x) frente a las tres anteriores (s/m/l) y lidera en todas las escalas coincidentes en Rendimiento.
• Frente a los detectores de vocabulario abierto basados en Transformer. GLIP y OWL-ViT ejecutan un Transformer de visión y lenguaje durante la inferencia. YOLOE codifica las indicaciones una sola vez y después las compara con las características de las regiones dentro de una cabeza convolucional.

Las alternativas más parecidas aceptan una indicación de texto, pero solo YOLOE y SAM 3 devuelven máscaras, y cada una responde a preguntas distintas:

¿Vienes de YOLO-World? La estructura de la API es la misma: sustituye YOLOWorld por YOLOE, carga un checkpoint *-seg.pt y mantén tal cual la llamada a set_classes(). Obtienes máscaras e indicaciones visuales; la nota sobre exportación relativa a las clases fijadas se aplica a ambos.

Casos de uso y aplicaciones#

La detección de vocabulario abierto elimina la necesidad de volver a entrenar para cada clase, algo especialmente importante cuando no se conoce de antemano la lista de objetivos:

• Detección en entornos abiertos — robótica y sistemas de seguridad que se encuentran con objetos que nadie enumeró durante el entrenamiento.
• Detección con un solo ejemplo — las indicaciones visuales detectan una pieza, un logotipo o un defecto concretos a partir de una única caja de referencia, algo útil en la inspección industrial.
• Catalogación de categorías poco frecuentes — el vocabulario integrado de 4,585 nombres es lo bastante amplio para realizar análisis de seguimiento de la biodiversidad o inventario minorista.
• Preparación inicial de conjuntos de datos — genera etiquetas preliminares con cajas y máscaras antes de la revisión humana y, después, entrena con esos resultados un modelo rápido de conjunto cerrado.
• Segmentación de objetivos arbitrarios — los checkpoints *-seg.pt publicados devuelven una máscara con cada predicción, por lo que la imagen médica y el análisis por satélite obtienen resultados precisos a nivel de píxel sin necesidad de un segundo modelo.

Un patrón habitual combina dos modos: ejecuta una vez el modo sin indicaciones para descubrir qué hay y, después, cambia a las indicaciones de texto para las categorías que te interesan.

Limitaciones#

YOLOE sacrifica precisión a cambio de poder cambiar las clases durante la inferencia. Estas son las consecuencias que conviene conocer antes de decidirte:

• La precisión de cero disparos es muy inferior a la de un modelo entrenado con tus clases. Los checkpoints con indicaciones obtienen aproximadamente entre 22 y 40 mAP en LVIS minival; un YOLO de conjunto cerrado entrenado con tus propios datos los superará en esas clases. Elige YOLOE para cubrir clases con las que no puedes entrenar, no para sustituir el entrenamiento.
• Las categorías poco frecuentes son el punto débil. La columna mAP_r de Rendimiento muestra específicamente la precisión en las clases poco frecuentes de LVIS y, con indicaciones de texto, sus valores son inferiores a los de las columnas de clases comunes y frecuentes en todas las filas. Si tus objetivos son poco habituales, fíjate en este dato y no en el mAP principal.
• Una indicación describe el aspecto, no las relaciones. La detección compara las características de las regiones con la incrustación de la indicación, así que las indicaciones que dependen del estado, el contexto o la comparación —«dañado», «el situado más a la izquierda», «el que se está llevando»— no ofrecen una referencia fiable con la que comparar. Utiliza expresiones parecidas a los nombres de categorías habituales.
• Los conjuntos grandes de indicaciones aumentan la latencia. Las incrustaciones de las indicaciones se calculan una sola vez, pero se comparan con las características de las regiones en cada pasada hacia delante. En CPU con yoloe-26s-seg.pt, el tiempo de una pasada hacia delante aumenta alrededor de un 19 % al pasar de 80 a 1,203 clases y cerca de un 89 % con el vocabulario completo de 4,585 nombres. Los FLOPs indicados no cambian en absoluto, porque no se cuenta la similitud entre regiones y texto, así que el perfil no te avisará.
• Los nombres de clase son marcadores de posición hasta que añades indicaciones. Un checkpoint *-seg.pt recién cargado devuelve nc=80 con nombres numéricos ("0", "1", …), así que llama a set_classes() antes de leer las etiquetas. Los checkpoints sin indicaciones ya incluyen todo el vocabulario.

Notas de implementación#

• Hardware. La inferencia necesita una GPU NVIDIA con entre 4 y 8 GB de VRAM; las escalas n y s funcionan en GPU de borde como Jetson o en CPU con una resolución reducida. El ajuste fino necesita una única GPU.
• NMS no distingue clases de forma predeterminada. YOLOE predice con agnostic_nms=True. De forma predeterminada, esto suprime las cajas solapadas con puntuaciones más bajas entre distintas clases, en lugar de hacerlo solo dentro de la misma clase, lo que evita duplicados cuando un objeto coincide con varias categorías. Con nms=False, YOLOE-26 no aplica ninguna supresión por IoU; el modo agnóstico solo conserva la mejor clase por ancla, en lugar de permitir que una ancla emita varias etiquetas de clase. Pasa agnostic_nms=False para cambiar este comportamiento.
• Procesamiento por lotes. La inferencia por lotes funciona directamente y las indicaciones visuales pueden ser distintas para cada imagen de una misma llamada.

Entrenar desde cero los modelos oficiales#

La mayoría de los lectores no necesita hacerlo. Este proceso reproduce los checkpoints de vocabulario abierto publicados a partir de Objects365, GQA y Flickr30k —unos 1.4 M de muestras de entrenamiento en 8× RTX 4090— y no tiene relación con el ajuste fino de tus propios datos, que se explica en Uso del entrenamiento más arriba.

El entrenamiento necesita anotaciones de segmentos. Puedes descargar los archivos procesados que aparecen a continuación o generar los tuyos con el script del equipo oficial, basado en SAM 2.1. La validación utiliza LVIS minival.

Primero se entrena el modelo con indicaciones de texto; 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,  # o la ruta a un archivo YAML con la misma estructura
    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 con indicaciones visuales y sin indicaciones parten de ese modelo entrenado con indicaciones de texto y actualizan un módulo cada uno. YOLOESegVPTrainer es la receta para indicaciones visuales y YOLOEPEFreeTrainer la receta sin indicaciones, pero ninguna de las dos clases congela nada por sí sola: el entrenamiento selectivo depende de la lista freeze que pases junto con ella, que incluye todos los elementos secundarios del cabezal excepto savpe (respectivamente, todas las torres de clasificación), y la ejecución sin indicaciones también necesita single_cls=True. El repositorio original de YOLOE incluye las recetas completas para los modelos de escala v8.

Una ejecución sin indicaciones terminada se reparametriza en un punto de control que informa de sus nombres sin indicaciones durante la inferencia, usando get_vocab y set_vocab:

from ultralytics import YOLOE

# Pesos escritos por la ejecución sin indicaciones y por la ejecución con indicaciones de texto desde la que partió. Cada
# nueva ejecución crea un directorio nuevo (train-2, train-3, ...), así que usa las rutas que hayan mostrado las ejecuciones.
model = YOLOE("runs/segment/train-2/weights/best.pt")  # ejecución sin indicaciones; el cabezal ya está fusionado
text_model = YOLOE("runs/segment/train/weights/best.pt")  # ejecución con indicaciones de texto; el cabezal aún no está fusionado

names = list(YOLOE("yoloe-26l-seg-pf.pt").model.names.values())  # el vocabulario de 4,585 nombres o tu propia lista
vocab = text_model.get_vocab(names)

model.set_vocab(vocab, names)
model.save("yoloe-26l-seg-pf-custom.pt")  # no sobrescribas nunca el punto de control publicado

get_vocab devuelve la rama que selecciona el indicador end2end del modelo, y set_vocab reparametriza esa rama. Los archivos publicados de YOLOE-26 incluyen, en cambio, un vocabulario por rama, que es lo que permite que nms elija entre ellas; para reproducirlo, toma el segundo vocabulario de otra copia del modelo con indicaciones de texto. YOLOE-11 y YOLOE-v8 tienen una sola rama, así que usan la llamada anterior sin cambios.

one2one_model = YOLOE("runs/segment/train/weights/best.pt")  # get_vocab fusiona el cabezal que lee, así que carga una segunda copia
one2one_model.model.end2end = True  # leer la rama sin NMS

model.set_vocab(vocab, names, one2one_vocab=one2one_model.get_vocab(names))

Citas y agradecimientos#

Si YOLOE ha contribuido a tu investigación o proyecto, cita el artículo original de Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han y Guiguang Ding, de la Universidad 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. Puedes acceder al código fuente del proyecto y a recursos adicionales a través de su repositorio de GitHub.

Preguntas frecuentes#