YOLOE: Vendo Tudo em Tempo Real

Introdução

YOLOE (Real-Time Seeing Anything) é um novo avanço em modelos YOLO de zero-shot com suporte a prompts, projetado para detecção e segmentação de vocabulário aberto. Diferente dos modelos YOLO anteriores limitados a categorias fixas, o YOLOE usa prompts de texto, imagem ou vocabulário interno, permitindo a detecção em tempo real de qualquer classe de objeto. Construído sobre o YOLOv10 e inspirado pelo YOLO-World, o YOLOE alcança desempenho zero-shot de última geração com impacto mínimo na velocidade e precisão.

Comparado aos modelos YOLO anteriores, o YOLOE aumenta significativamente a eficiência e a precisão. Ele apresenta uma melhoria de +3,5 AP em relação ao YOLO-Worldv2 no LVIS, utilizando apenas um terço dos recursos de treinamento e alcançando velocidades de inferência 1,4× mais rápidas. Ajustado no COCO, o YOLOE-v8-large supera o YOLOv8-L em 0,1 mAP, usando quase 4× menos tempo de treinamento. Isso demonstra o equilíbrio excepcional de precisão, eficiência e versatilidade do YOLOE. As seções abaixo exploram a arquitetura do YOLOE, comparações de benchmark e a integração com o framework Ultralytics.

Visão Geral da Arquitetura

O YOLOE mantém a estrutura padrão do YOLO: um backbone convolucional (por exemplo, CSP-Darknet) para extração de características, um neck (por exemplo, PAN-FPN) para fusão multiescala e uma head de detecção desacoplada e sem âncoras (como no YOLOv8/YOLO11) que prevê objectness, classes e caixas de forma independente. O YOLOE introduz três módulos inovadores que permitem a detecção de vocabulário aberto:

• Re-parameterizable Region-Text Alignment (RepRTA): Suporta detecção baseada em prompt de texto refinando embeddings de texto (por exemplo, do CLIP) através de uma pequena rede auxiliar. Na inferência, essa rede é integrada ao modelo principal, garantindo overhead zero. Assim, o YOLOE detecta objetos rotulados por texto arbitrário (por exemplo, "semáforo" não visto) sem penalidades de tempo de execução.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Habilita a detecção baseada em prompt visual através de um branch de embedding leve. Dada uma imagem de referência, o SAVPE codifica características semânticas e de ativação, condicionando o modelo para detectar objetos visualmente semelhantes — uma capacidade de detecção one-shot útil para logotipos ou peças específicas.

• Lazy Region-Prompt Contrast (LRPC): No modo sem prompt, o YOLOE realiza reconhecimento de conjunto aberto usando embeddings internos treinados em grandes vocabulários (1200+ categorias do LVIS e Objects365). Sem prompts ou codificadores externos, o YOLOE identifica objetos através de busca por similaridade de embedding, lidando eficientemente com grandes espaços de rótulos na inferência.

Além disso, o YOLOE integra segmentação de instância em tempo real estendendo a head de detecção com um branch de previsão de máscara (similar ao YOLACT ou YOLOv8-Seg), adicionando um overhead mínimo.

Crucialmente, os módulos de mundo aberto do YOLOE não introduzem custo de inferência quando usados como um YOLO regular de conjunto fechado. Pós-treinamento, os parâmetros do YOLOE podem ser re-parametrizados em uma head YOLO padrão, preservando FLOPs e velocidade idênticos (por exemplo, correspondendo exatamente ao YOLO11).

Modelos Disponíveis, Tarefas Suportadas e Modos de Operação

Esta seção detalha os modelos disponíveis com seus pesos pré-treinados específicos, as tarefas que eles suportam e sua compatibilidade com vários modos de operação, como Inference, Validation, Training e Export, denotados por ✅ para modos suportados e ❌ para modos não suportados.

Modelos com Prompt de Texto/Visual

Modelos Sem Prompt (Prompt Free)

Exemplos de Uso

Os modelos YOLOE são fáceis de integrar às tuas aplicações Python. A Ultralytics fornece Python API amigável e comandos CLI para otimizar o desenvolvimento.

Uso de treinamento

Fine-Tuning em um conjunto de dados personalizado

Podes ajustar (fine-tune) qualquer modelo YOLOE pré-treinado no teu conjunto de dados YOLO personalizado para tarefas de detecção e segmentação de instância.

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
)

Utilização da Previsão

O YOLOE suporta prompts baseados em texto e visuais. Usar prompts é simples — basta passá-los através do método predict conforme mostrado abaixo:

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

Utilização da Validação

A validação de modelo em um conjunto de dados é simplificada da seguinte forma:

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 da Exportação

O processo de exportação é similar a outros modelos YOLO, com a flexibilidade adicional de lidar com prompts de texto e visuais:

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

Treinar Modelos Oficiais

Preparar conjuntos de dados

• Dados de treinamento

• Dados de validação

Iniciando o treinamento do zero

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

Comparação de Desempenho do YOLOE

O YOLOE iguala ou supera a precisão de modelos YOLO de conjunto fechado em benchmarks padrão como COCO e LVIS, sem comprometer a velocidade ou o tamanho do modelo. A tabela abaixo compara o YOLOE-L (baseado no YOLO11) e o YOLOE26-L (baseado no YOLO26) com os modelos de conjunto fechado correspondentes:

^† O YOLOE-L compartilha a arquitetura do YOLO11-L e o YOLOE26-L compartilha a arquitetura do YOLO26-L, resultando em velocidade de inferência e GFLOPs similares.

O YOLOE26-L alcança 36.8% de mAP no LVIS com 32.3M de parâmetros e 88.3B de FLOPs, processando imagens de 640×640 a 6.2 ms (161 FPS) na GPU T4. Isso representa uma melhoria em relação aos 35.2% de mAP no LVIS do YOLOE-L, mantendo a mesma velocidade de inferência. Crucialmente, os módulos de vocabulário aberto do YOLOE não incorrem em custo de inferência, demonstrando um design de "troca sem almoço grátis" (no free lunch trade-off).

Para tarefas de zero-shot, o YOLOE26 supera significativamente os detectores de vocabulário aberto anteriores: no LVIS, o YOLOE26-S alcança 29.9% de mAP, superando o YOLO-World-S em +11.4 AP, enquanto o YOLOE26-L alcança 36.8% de mAP, superando o YOLO-World-L em +10.0 AP. O YOLOE26 mantém uma inferência eficiente a 161 FPS na GPU T4, ideal para aplicações de vocabulário aberto em tempo real.

Comparação com Modelos Anteriores

O YOLOE introduz avanços notáveis em relação aos modelos YOLO anteriores e detectores de vocabulário aberto:

• YOLOE vs YOLOv5: O YOLOv5 oferecia um bom equilíbrio entre velocidade e precisão, mas exigia retreinamento para novas classes e usava heads baseadas em âncoras. Em contraste, o YOLOE é anchor-free e detecta novas classes dinamicamente. O YOLOE, baseando-se nas melhorias do YOLOv8, alcança maior precisão (~52.6% vs. ~50% de mAP do YOLOv5 no COCO) e integra segmentação de instâncias, ao contrário do YOLOv5.

• YOLOE vs YOLOv8: O YOLOE estende a arquitetura redesenhada do YOLOv8, alcançando precisão similar ou superior (52.6% de mAP com ~26M de parâmetros vs. 52.9% com ~44M de parâmetros do YOLOv8-L). Ele reduz significativamente o tempo de treinamento devido a um pré-treinamento mais forte. O avanço principal é a capacidade de mundo aberto do YOLOE, detectando objetos não vistos (ex.: "bird scooter" ou "peace symbol") via prompts, ao contrário do design de conjunto fechado do YOLOv8.

• YOLOE vs YOLO11: O YOLO11 melhora o YOLOv8 com maior eficiência e menos parâmetros (redução de ~22%). O YOLOE herda esses ganhos diretamente, igualando a velocidade de inferência e a contagem de parâmetros do YOLO11 (~26M de parâmetros), ao mesmo tempo em que adiciona detecção e segmentação de vocabulário aberto. Em cenários de conjunto fechado, o YOLOE é equivalente ao YOLO11, mas, crucialmente, adiciona adaptabilidade para detectar classes não vistas, alcançando o YOLO11 + capacidade de mundo aberto sem comprometer a velocidade.

• YOLOE26 vs YOLOE (baseado no YOLO11): O YOLOE26 baseia-se na arquitetura do YOLO26, herdando seu design end-to-end sem NMS para uma inferência mais rápida. No LVIS, o YOLOE26-L alcança 36.8% de mAP, superando os 35.2% de mAP do YOLOE-L. O YOLOE26 oferece todas as cinco escalas de modelo (N/S/M/L/X) em comparação com as três do YOLOE (S/M/L), proporcionando mais flexibilidade para diferentes cenários de implantação.

• YOLOE26 vs detectores de vocabulário aberto anteriores: Modelos anteriores de vocabulário aberto (GLIP, OWL-ViT, YOLO-World) dependiam fortemente de transformers de visão-linguagem, resultando em inferência lenta. No LVIS, o YOLOE26-S alcança 29.9% de mAP (+11.4 AP sobre o YOLO-World-S) e o YOLOE26-L alcança 36.8% de mAP (+10.0 AP sobre o YOLO-World-L), mantendo a inferência em tempo real a 161 FPS na GPU T4. Comparado a abordagens baseadas em transformer (ex.: GLIP), o YOLOE26 oferece inferência ordens de magnitude mais rápida, efetivamente eliminando a lacuna de precisão-eficiência na detecção de conjunto aberto.

Em resumo, o YOLOE e o YOLOE26 mantêm a velocidade e eficiência renomadas do YOLO, superam predecessores em precisão, integram segmentação e introduzem uma poderosa detecção de mundo aberto. O YOLOE26 avança ainda mais a arquitetura com a inferência end-to-end sem NMS do YOLO26, tornando-o ideal para aplicações de vocabulário aberto em tempo real.

Casos de Uso e Aplicações

A detecção e segmentação de vocabulário aberto do YOLOE permitem diversas aplicações além dos modelos tradicionais de classes fixas:

• Detecção de Objetos em Mundo Aberto: Ideal para cenários dinâmicos como robótica, onde robôs reconhecem objetos previamente não vistos usando prompts, ou sistemas de segurança que se adaptam rapidamente a novas ameaças (ex.: itens perigosos) sem retreinamento.

• Detecção Few-Shot e One-Shot: Usando prompts visuais (SAVPE), o YOLOE aprende rapidamente novos objetos a partir de imagens de referência únicas—perfeito para inspeção industrial (identificando peças ou defeitos instantaneamente) ou vigilância personalizada, permitindo buscas visuais com configuração mínima.

• Reconhecimento de Grande Vocabulário & Long-Tail: Equipado com um vocabulário de mais de 1000 classes, o YOLOE se destaca em tarefas como monitoramento de biodiversidade (detectando espécies raras), coleções de museus, inventário de varejo ou e-commerce, identificando confiavelmente muitas classes sem treinamento extensivo por classe.

• Detecção e Segmentação Interativa: O YOLOE suporta aplicações interativas em tempo real, como recuperação pesquisável de vídeo/imagem, realidade aumentada (AR) e edição de imagem intuitiva, impulsionadas por entradas naturais (textos ou prompts visuais). Usuários podem isolar, identificar ou editar objetos dinamicamente com precisão usando máscaras de segmentação.

• Rotulagem Automatizada de Dados e Bootstrapping: O YOLOE facilita a criação rápida de datasets fornecendo anotações iniciais de caixas delimitadoras (bounding box) e segmentação, reduzindo significativamente os esforços de rotulagem humana. Particularmente valioso na análise de grandes coleções de mídia, onde pode identificar automaticamente os objetos presentes, auxiliando na construção mais rápida de modelos especializados.

• Segmentação para Qualquer Objeto: Estende as capacidades de segmentação para objetos arbitrários através de prompts—particularmente benéfico para imagens médicas, microscopia ou análise de imagens de satélite, identificando e segmentando estruturas automaticamente com precisão sem modelos pré-treinados especializados. Ao contrário de modelos como SAM, o YOLOE reconhece e segmenta objetos automaticamente de forma simultânea, auxiliando em tarefas como criação de conteúdo ou entendimento de cena.

Em todos esses casos de uso, a principal vantagem do YOLOE é a versatilidade, fornecendo um modelo unificado para detecção, reconhecimento e segmentação em cenários dinâmicos. Sua eficiência garante desempenho em tempo real em dispositivos com recursos limitados, ideal para robótica, direção autônoma, defesa e além.

Treinamento e Inferência

O YOLOE integra-se perfeitamente com a Ultralytics Python API e a CLI, de forma similar a outros modelos YOLO (YOLOv8, YOLO-World). Veja como começar rapidamente:

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

Outras Tarefas Suportadas

• Validação: Avalie a precisão facilmente com model.val() ou yolo val.
• Exportação: Exporte modelos YOLOE (model.export()) para ONNX, TensorRT, etc., facilitando a implantação.
• Rastreamento: O YOLOE suporta rastreamento de objetos (yolo track) quando integrado, útil para rastrear classes com prompt em vídeos.

Primeiros passos

Configure rapidamente o YOLOE com a Ultralytics seguindo estes passos:

1. Instalação: Instale ou atualize o pacote Ultralytics:

   pip install -U ultralytics

2. Baixar Pesos do YOLOE: Modelos YOLOE pré-treinados (ex.: YOLOE-v8-S/L, variantes YOLOE-11) estão disponíveis nas releases do GitHub do YOLOE. Basta baixar o arquivo .pt desejado para carregar na classe Ultralytics YOLO.

3. Requisitos de Hardware:

   • Inferência: GPU recomendada (NVIDIA com ≥4-8GB VRAM). Modelos pequenos rodam eficientemente em GPUs de borda (ex.: Jetson) ou CPUs em resoluções mais baixas. Para inferência de alto desempenho em estações de trabalho compactas, consulte nosso guia NVIDIA DGX Spark.
   • Treinamento: Ajustar o YOLOE em dados personalizados normalmente requer apenas uma GPU. O extenso pré-treinamento de vocabulário aberto (LVIS/Objects365) usado pelos autores exigiu computação substancial (8 GPUs RTX 4090).

4. Configuração: As configurações do YOLOE usam arquivos YAML padrão da Ultralytics. Configurações padrão (ex.: yoloe-26s-seg.yaml) geralmente bastam, mas você pode modificar o backbone, classes ou tamanho da imagem conforme necessário.

5. Executando o YOLOE:

   • Inferência rápida (sem prompt):

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

   • Detecção com prompt (exemplo 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. Dicas de Integração:

   • Nomes de classes: Os resultados padrão do YOLOE usam categorias LVIS; use set_classes() para especificar seus próprios rótulos.
   • Velocidade: O YOLOE não tem sobrecarga a menos que você use prompts. Prompts de texto têm impacto mínimo; visuais um pouco mais.
   • Comportamento do NMS: O YOLOE usa automaticamente agnostic_nms=True durante a previsão, mesclando caixas sobrepostas entre classes. Isso evita detecções duplicadas quando o mesmo objeto corresponde a várias categorias no grande vocabulário do YOLOE (mais de 1200 classes LVIS). Você pode substituir isso passando agnostic_nms=False explicitamente.
   • Inferência em lote: Suportada diretamente (model.predict([img1, img2])). Para prompts específicos por imagem, processe as imagens individualmente.

A documentação da Ultralytics fornece mais recursos. O YOLOE permite que você explore facilmente poderosas capacidades de mundo aberto dentro do familiar ecossistema YOLO.

Citações e Agradecimentos

Se o YOLOE contribuiu para sua pesquisa ou projeto, por favor, cite o artigo original de Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han, e Guiguang Ding da Universidade 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 leitura adicional, o artigo original do YOLOE está disponível no arXiv. O código-fonte do projeto e recursos adicionais podem ser acessados via repositório GitHub.

FAQ

Como o YOLOE difere do YOLO-World?

Embora tanto o YOLOE quanto o YOLO-World permitam a detecção de vocabulário aberto, o YOLOE oferece várias vantagens. O YOLOE alcança +3.5 AP de maior precisão no LVIS enquanto usa 3x menos recursos de treinamento e roda 1.4x mais rápido que o YOLO-Worldv2. O YOLOE também suporta três modos de prompt (texto, visual e vocabulário interno), enquanto o YOLO-World foca principalmente em prompts de texto. Além disso, o YOLOE inclui capacidades integradas de segmentação de instâncias, fornecendo máscaras precisas de pixel para objetos detectados sem sobrecarga adicional.

Posso usar o YOLOE como um modelo YOLO comum?

Sim, o YOLOE pode funcionar exatamente como um modelo YOLO padrão sem penalidade de desempenho. Quando usado no modo de conjunto fechado (sem prompts), os módulos de vocabulário aberto do YOLOE são re-parametrizados para a head de detecção padrão, resultando em velocidade e precisão idênticas aos modelos YOLO11 equivalentes. Isso torna o YOLOE extremamente versátil—você pode usá-lo como um detector tradicional para velocidade máxima e depois mudar para o modo de vocabulário aberto apenas quando necessário.

Que tipos de prompts posso usar com o YOLOE?

O YOLOE suporta três tipos de prompts:

1. Prompts de texto: Especifique classes de objetos usando linguagem natural (ex.: "person", "traffic light", "bird scooter")
2. Prompts visuais: Forneça imagens de referência dos objetos que você deseja detectar
3. Vocabulário interno: Use o vocabulário integrado de mais de 1200 categorias do YOLOE sem prompts externos

Essa flexibilidade permite que você adapte o YOLOE a vários cenários sem retreinar o modelo, tornando-o particularmente útil para ambientes dinâmicos onde os requisitos de detecção mudam frequentemente.

Como o YOLOE lida com a segmentação de instâncias?

O YOLOE integra a segmentação de instâncias diretamente em sua arquitetura estendendo a head de detecção com um ramo de predição de máscara. Essa abordagem é similar ao YOLOv8-Seg, mas funciona para qualquer classe de objeto com prompt. Máscaras de segmentação são incluídas automaticamente nos resultados de inferência e podem ser acessadas via results[0].masks. Essa abordagem unificada elimina a necessidade de modelos de detecção e segmentação separados, simplificando fluxos de trabalho para aplicações que requerem limites de objeto de precisão de pixel.

Como o YOLOE lida com a inferência com prompts personalizados?

Similar ao YOLO-World, o YOLOE suporta uma estratégia de "prompt-then-detect" (promptar-e-detectar) que utiliza um vocabulário offline para aumentar a eficiência. Prompts personalizados como legendas ou categorias de objetos específicas são pré-codificados e armazenados como embeddings de vocabulário offline. Essa abordagem simplifica o processo de detecção sem exigir retreinamento. Você pode definir esses prompts dinamicamente dentro do modelo para adaptá-lo a tarefas de detecção 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()