Link to this sectionYOLOE: vendo qualquer coisa em tempo real#

Link to this sectionIntrodução#

YOLOE (Real-Time Seeing Anything) é um novo avanço em modelos YOLO zero-shot com suporte a prompts, projetado para detecção e segmentação de vocabulário aberto. Ao contrário 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 no 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 melhora em +3.5 AP sobre o YOLO-Worldv2 no LVIS enquanto usa 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, comparações de benchmark e integração com a estrutura Ultralytics.

Link to this sectionVisã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 sem âncoras (anchor-free) e desacoplada (como no YOLOv8/YOLO11) que prevê a existência de objetos, 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 por prompt de texto ao refinar embeddings de texto (por exemplo, do CLIP) através de uma pequena rede auxiliar. Na inferência, esta rede é integrada ao modelo principal, garantindo custo zero. Assim, o YOLOE detecta objetos arbitrários rotulados por texto (por exemplo, um "semáforo" não visto) sem penalidades de tempo de execução.

• Semantic-Activated Visual Prompt Encoder (SAVPE): Habilita a detecção por 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 a 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 (open-set) usando embeddings internos treinados em grandes vocabulários (mais de 1200 categorias do LVIS e Objects365). Sem prompts externos ou codificadores, o YOLOE identifica objetos através de busca de similaridade de embeddings, lidando eficientemente com grandes espaços de rótulos na inferência.

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

Crucialmente, os módulos de mundo aberto do YOLOE não introduzem nenhum custo de inferência quando usados como um YOLO padrão 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, igualando o YOLO11 exatamente).

Link to this sectionModelos Disponíveis, Tarefas Suportadas e Modos de Operação#

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

Link to this sectionModelos de Prompt de Texto/Visual#

Link to this sectionModelos Sem Prompt (Prompt Free)#

Link to this sectionExemplos de uso#

Os modelos YOLOE são fáceis de integrar nas suas aplicações Python. A Ultralytics fornece uma API Python intuitiva e comandos CLI para agilizar o desenvolvimento.

Link to this sectionUtilização do Treino#

Link to this sectionAjuste fino (Fine-Tuning) em um dataset personalizado#

Você pode ajustar qualquer modelo YOLOE pré-treinado no seu dataset YOLO personalizado para tarefas de detecção e segmentação de instâncias.

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
)

Link to this sectionUso de Predição#

O YOLOE suporta tanto prompts de texto quanto visuais. Usar prompts é simples — basta passá-los através do método predict como 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()

Link to this sectionUso de Validação#

A validação do modelo num 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")

Link to this sectionUso da Exportação#

O processo de exportação é semelhante 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()

Link to this sectionTreinar Modelos Oficiais#

Link to this sectionPreparar conjuntos de dados#

• Dados de treino

• Dados de validação

Link to this sectionIniciando 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",
)

Link to this sectionComparação de Desempenho do YOLOE#

O YOLOE iguala ou supera a precisão dos 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 (construído no YOLO11) e o YOLOE26-L (construído no YOLO26) em relação aos 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 semelhantes.

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

Para tarefas zero-shot, o YOLOE26 supera significativamente os detectores de vocabulário aberto anteriores: no LVIS, o YOLOE26-S atinge 29.9% mAP, superando o YOLO-World-S por +11.4 AP, enquanto o YOLOE26-L atinge 36.8% mAP, superando o YOLO-World-L por +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.

Link to this sectionComparaçã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 é livre de âncoras e detecta dinamicamente novas classes. O YOLOE, construindo sobre as melhorias do YOLOv8, alcança maior precisão (52.6% vs ~50% 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 semelhante ou superior (52.6% mAP com ~26M de parâmetros vs. os 52.9% com ~44M de parâmetros do YOLOv8-L). Ele reduz significativamente o tempo de treinamento devido ao pré-treinamento mais forte. O principal avanço é a capacidade de mundo aberto do YOLOE, detectando objetos não vistos (por exemplo, "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 eficiência aprimorada 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), enquanto 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 YOLO11 + capacidade de mundo aberto sem comprometer a velocidade.

• YOLOE26 vs YOLOE (baseado em YOLO11): O YOLOE26 constrói sobre a arquitetura do YOLO26, herdando seu design end-to-end livre de NMS para uma inferência mais rápida. No LVIS, o YOLOE26-L atinge 36.8% mAP, melhorando sobre os 35.2% 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, levando a uma inferência lenta. No LVIS, o YOLOE26-S atinge 29.9% mAP (+11.4 AP sobre o YOLO-World-S) e o YOLOE26-L atinge 36.8% mAP (+10.0 AP sobre o YOLO-World-L), mantendo a inferência em tempo real a 161 FPS na GPU T4. Comparado às abordagens baseadas em transformer (por exemplo, GLIP), o YOLOE26 oferece inferência ordens de magnitude mais rápida, efetivamente preenchendo 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 inferência end-to-end livre de NMS do YOLO26, tornando-o ideal para aplicações de vocabulário aberto em tempo real.

Link to this sectionCasos 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 classe fixa:

• Detecção de Objetos de Mundo Aberto: Ideal para cenários dinâmicos como robótica, onde robôs reconhecem objetos anteriormente não vistos usando prompts, ou sistemas de segurança que se adaptam rapidamente a novas ameaças (por exemplo, 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 e Cauda Longa: 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 de forma confiável muitas classes sem treinamento extenso por classe.

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

• Rotulagem Automática de Dados e Bootstrapping: O YOLOE facilita a criação rápida de datasets fornecendo anotações iniciais de caixa delimitadora 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 auto-identificar objetos presentes, auxiliando na construção de modelos especializados mais rapidamente.

• Segmentação para Qualquer Objeto: Estende as capacidades de segmentação para objetos arbitrários através de prompts—particularmente benéfico para imagem médica, microscopia ou análise de imagens de satélite, identificando e segmentando automaticamente estruturas com precisão sem modelos pré-treinados especializados. Diferente de modelos como o SAM, o YOLOE reconhece e segmenta simultaneamente objetos automaticamente, 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.

Link to this sectionTreinamento e Inferência#

O YOLOE integra-se perfeitamente com a API Python da Ultralytics e a CLI, semelhante 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

Link to this sectionOutras 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.

Link to this sectionComeçando#

Configure rapidamente o YOLOE com a Ultralytics seguindo estes passos:

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

   pip install -U ultralytics

2. Baixar Pesos do YOLOE: Modelos YOLOE pré-treinados (por exemplo, YOLOE-v8-S/L, variantes YOLOE-11) estão disponíveis nos lançamentos do GitHub do YOLOE. Basta baixar o arquivo .pt desejado para carregar na classe YOLO da Ultralytics.

3. Requisitos de Hardware:

   • Inferência: GPU recomendada (NVIDIA com ≥4-8GB VRAM). Modelos pequenos rodam eficientemente em GPUs de borda (por exemplo, Jetson) ou CPUs em resoluções mais baixas. Para inferência de alto desempenho em estações de trabalho compactas, veja nosso guia NVIDIA DGX Spark.
   • Treinamento: O ajuste fino do YOLOE em dados personalizados normalmente requer apenas uma GPU. O pré-treinamento extensivo 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 (por exemplo, yoloe-26s-seg.yaml) geralmente são suficientes, 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 classe: As saídas 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 se usem prompts. Prompts de texto têm impacto mínimo; prompts visuais um pouco mais.
   • Comportamento NMS: O YOLOE usa automaticamente agnostic_nms=True durante a predição, mesclando caixas sobrepostas entre classes. Isso evita detecções duplicadas quando o mesmo objeto corresponde a várias categorias no vocabulário amplo do YOLOE (mais de 1200 classes LVIS). Você pode substituir isso passando agnostic_nms=False explicitamente.
   • Inferência em lote: Suportado diretamente (model.predict([img1, img2])). Para prompts específicos de imagem, execute as imagens individualmente.

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

Link to this sectionCitações e Agradecimentos#

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

Link to this sectionFAQ#

Link to this sectionComo 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 de precisão de pixel para objetos detectados sem sobrecarga adicional.

Link to this sectionPosso usar o YOLOE como um modelo YOLO normal?#

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 reparametrizados 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 alternar para o modo de vocabulário aberto apenas quando necessário.

Link to this sectionQue 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 (por exemplo, "person", "traffic light", "bird scooter")
2. Prompts visuais: Forneça imagens de referência de objetos que você deseja detectar
3. Vocabulário interno: Use o vocabulário integrado do YOLOE de mais de 1200 categorias 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.

Link to this sectionComo o YOLOE lida com a segmentação de instâncias?#

O YOLOE integra a segmentação de instâncias diretamente na sua arquitetura ao estender a cabeça de detecção com uma ramificação de previsão de máscara. Esta abordagem é semelhante ao YOLOv8-Seg, mas funciona para qualquer classe de objeto indicada. As máscaras de segmentação são incluídas automaticamente nos resultados de inferência e podem ser acessadas via results[0].masks. Esta abordagem unificada elimina a necessidade de modelos separados de detecção e segmentação, otimizando fluxos de trabalho para aplicações que exigem contornos de objetos com precisão de pixel.

Link to this sectionComo o YOLOE lida com a inferência com prompts personalizados?#

Semelhante ao YOLO-World, o YOLOE suporta uma estratégia de "prompt-then-detect" (prompt antes da detecção) que utiliza um vocabulário offline para aumentar a eficiência. Prompts personalizados, como legendas ou categorias específicas de objetos, são pré-codificados e armazenados como embeddings de vocabulário offline. Esta abordagem simplifica o processo de detecção sem exigir retreinamento. Podes definir dinamicamente estes prompts 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()