YOLOE: Visão em Tempo Real de Qualquer Coisa

Introdução

YOLOE (Real-Time Seeing Anything) é um novo avanço em modelos YOLO de zero-shot e com capacidade de prompt, projetados 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 de ponta de zero-shot com impacto mínimo na velocidade e precisão.

Assista: Como usar o YOLOE com o pacote Python Ultralytics: Vocabulário Aberto e Visão de Qualquer Coisa em Tempo Real 🚀

Comparado com os modelos YOLO anteriores, o YOLOE aumenta significativamente a eficiência e a precisão. Ele melhora em +3.5 AP em relação ao YOLO-Worldv2 no LVIS, usando 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 do YOLOE entre precisão, eficiência e versatilidade. As seções abaixo exploram a arquitetura do YOLOE, comparações de benchmark e integração com a estrutura Ultralytics.

Visão Geral da Arquitetura

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

• Alinhamento Região-Texto Re-parametrizável (RepRTA): Suporta detecção com prompts de texto refinando embeddings de texto (por exemplo, do CLIP) através de uma pequena rede auxiliar. Na inferência, esta rede é integrada ao modelo principal, garantindo zero overhead. Assim, o YOLOE detecta objetos arbitrariamente rotulados com texto (por exemplo, um "semáforo" não visto) sem penalidades de tempo de execução.

• Codificador Visual de Prompt Ativado Semanticamente (SAVPE): Permite a detecção visualmente solicitada através de uma ramificação de incorporação leve. Dado 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 partes específicas.

• Contraste de Prompt de Região Preguiçosa (LRPC): No modo sem prompt, o YOLOE executa o reconhecimento de conjunto aberto usando embeddings internos treinados em grandes vocabulários (mais de 1200 categorias de LVIS e Objects365). Sem prompts ou codificadores externos, o YOLOE identifica objetos por meio de pesquisa de 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 o cabeçalho de detecção com um branch de previsão de máscara (semelhante ao YOLACT ou YOLOv8-Seg), adicionando uma sobrecarga mínima.

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. Após o treinamento, os parâmetros do YOLOE podem ser reparametrizados em um cabeçalho 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 suportam e sua compatibilidade com vários modos de operação, como Inferência, Validação, Treinamento e Exportação, denotados por ✅ para modos suportados e ❌ para modos não suportados.

Modelos de Prompt de Texto/Visual

Modelos Livres de Prompt

Exemplos de uso

Os modelos YOLOE são fáceis de integrar em seus aplicativos Python. A Ultralytics fornece uma API Python e comandos CLI fáceis de usar para otimizar o desenvolvimento.

Uso do Treino

Ajuste Fino em dataset personalizado

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

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

model.train(
    data="coco128-seg.yaml",
    epochs=80,
    close_mosaic=10,
    batch=128,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
)

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

model = YOLOE("yoloe-11s-seg.pt")
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data="coco128-seg.yaml",
    epochs=2,
    close_mosaic=0,
    batch=16,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
    freeze=freeze,
)

Uso da Predição

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

from ultralytics import YOLOE

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

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

# Show results
results[0].show()

import numpy as np

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

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

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=np.array(
        [
            [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
            [120, 425, 160, 445],  # Box enclosing glasses
        ],
    ),
    cls=np.array(
        [
            0,  # ID to be assigned for person
            1,  # ID to be assigned for glassses
        ]
    ),
)

# Run inference on an image, using the provided visual prompts as guidance
results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

import numpy as np

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

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

# Define visual prompts based on a separate reference image
visual_prompts = dict(
    bboxes=np.array([[221.52, 405.8, 344.98, 857.54]]),  # Box enclosing person
    cls=np.array([0]),  # ID to be assigned for person
)

# Run prediction on a different image, using reference image to guide what to look for
results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image for detection
    refer_image="ultralytics/assets/bus.jpg",  # Reference image used to get visual prompts
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

# After making prediction with `refer_image`, you can run predictions without passing visual_prompts again and still get the same classes back
results = model("ultralytics/assets/bus.jpg")

# Or export it to a different format while retaining the classes
model.export(format="onnx")

import numpy as np

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

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

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=[
        np.array(
            [
                [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
                [120, 425, 160, 445],  # Box enclosing glasses
            ],
        ),
        np.array([[150, 200, 1150, 700]]),
    ],
    cls=[
        np.array(
            [
                0,  # ID to be assigned for person
                1,  # ID to be assigned for glasses
            ]
        ),
        np.array([0]),
    ],
)

# Run inference on multiple image, using the provided visual prompts as guidance
results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")

# Run prediction. No prompts required.
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Uso da Validação

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

from ultralytics import YOLOE

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

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

A validação do modelo num conjunto de dados é simplificada da seguinte forma:

Treinar Modelos Oficiais

Preparar conjuntos de dados

• Dados de treino

• Dados de validação

Iniciando o treinamento do zero

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

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

model = YOLOE("yoloe-11l-seg.yaml")
model.train(
    data=data,
    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",
)

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

det_model = YOLOE("yoloe-11l.yaml")
state = torch_load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

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

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

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze every layer except of the savpe module.
head_index = len(model.model.model) - 1
freeze = list(range(0, head_index))
for name, child in model.model.model[-1].named_children():
    if "savpe" not in name:
        freeze.append(f"{head_index}.{name}")

model.train(
    data=data,
    batch=128,
    epochs=2,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=16e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegVPTrainer,  # use YOLOEVPTrainer if converted to detection model
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
)

from copy import deepcopy

from ultralytics import YOLOE

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

vp_model = YOLOE("yoloe-11l-vp.pt")
model.model.model[-1].savpe = deepcopy(vp_model.model.model[-1].savpe)
model.eval()
model.save("yoloe-11l-seg.pt")

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

det_model = YOLOE("yoloe-11l.yaml")
state = torch_load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

from ultralytics import YOLOE

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

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze layers.
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data=data,
    batch=128,
    epochs=1,
    close_mosaic=1,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEPEFreeTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
    single_cls=True,  # this is needed
)

from copy import deepcopy

from ultralytics import YOLOE

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

pf_model = YOLOE("yoloe-11l-seg-pf.pt")
names = ["object"]
tpe = model.get_text_pe(names)
model.set_classes(names, tpe)
model.model.model[-1].fuse(model.model.pe)

model.model.model[-1].cv3[0][2] = deepcopy(pf_model.model.model[-1].cv3[0][2]).requires_grad_(True)
model.model.model[-1].cv3[1][2] = deepcopy(pf_model.model.model[-1].cv3[1][2]).requires_grad_(True)
model.model.model[-1].cv3[2][2] = deepcopy(pf_model.model.model[-1].cv3[2][2]).requires_grad_(True)
del model.model.pe
model.save("yoloe-11l-seg-pf.pt")

Comparação de Desempenho do YOLOE

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

^† YOLO11-L e YOLOE-L têm arquiteturas idênticas (módulos de prompt desativados no YOLO11-L), resultando em velocidade de inferência idêntica e estimativas de GFLOPs semelhantes.

O YOLOE-L atinge 52,6% mAP, superando o YOLOv8-L (52,9%) com aproximadamente 40% menos parâmetros (26M vs. 43,7M). Ele processa imagens de 640×640 em 6,2 ms (161 FPS) comparado aos 9,06 ms (110 FPS) do YOLOv8-L, destacando a eficiência do YOLO11. Crucialmente, os módulos de vocabulário aberto do YOLOE não incorrem em custo de inferência, demonstrando um design de "sem almoço grátis".

Para tarefas de zero-shot e transferência, o YOLOE se destaca: no LVIS, o YOLOE-small melhora em relação ao YOLO-Worldv2 em +3,5 AP usando 3× menos recursos de treinamento. O ajuste fino do YOLOE-L do LVIS para o COCO também exigiu 4× menos tempo de treinamento do que o YOLOv8-L, ressaltando sua eficiência e adaptabilidade. O YOLOE mantém ainda mais a velocidade característica do YOLO, atingindo mais de 300 FPS em uma GPU T4 e ~64 FPS no iPhone 12 via CoreML, ideal para implementações de borda e móveis.

Comparação com Modelos Anteriores

O YOLOE introduz avanços notáveis em relação aos modelos YOLO anteriores e aos 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 cabeças baseadas em âncoras. Em contraste, o YOLOE é sem âncoras e detecta dinamicamente novas classes. O YOLOE, com base nas melhorias do YOLOv8, alcança maior precisão (52,6% vs. ~50% mAP do YOLOv5 no COCO) e integra a 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 ~26 milhões de parâmetros vs. 52,9% do YOLOv8-L com ~44 milhões de parâmetros). 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, "scooter de pássaro" ou "símbolo da paz") por meio de 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, correspondendo à velocidade de inferência e à contagem de parâmetros do YOLO11 (~26 milhões 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 adiciona crucialmente adaptabilidade para detectar classes não vistas, alcançando YOLO11 + capacidade de mundo aberto sem comprometer a velocidade.

• YOLOE vs detectores anteriores de vocabulário aberto:
  Os 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. O YOLOE os supera em precisão zero-shot (por exemplo, +3,5 AP vs. YOLO-Worldv2), enquanto é executado 1,4 vezes mais rápido com recursos de treinamento significativamente menores. Comparado com abordagens baseadas em transformer (por exemplo, GLIP), o YOLOE oferece uma 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 mantém a renomada velocidade e eficiência do YOLO, supera seus antecessores em precisão, integra segmentação e introduz uma poderosa detecção de mundo aberto, tornando-o excepcionalmente versátil e prático.

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 classe fixa:

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

• 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 pesquisas visuais com configuração mínima.

• Reconhecimento de Vocabulário Amplo e Cauda Longa:
  Equipado com um vocabulário de mais de 1000 classes, o YOLOE se destaca em tarefas como monitoramento da biodiversidade (detecção de espécies raras), coleções de museus, inventário de varejo ou e-commerce, identificando de forma confiável muitas classes sem treinamento extensivo por classe.

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

• Rotulagem e Bootstrapping Automatizados de Dados:
  O YOLOE facilita a criação rápida de conjuntos de dados, fornecendo anotações iniciais de caixas delimitadoras 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 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 imagens médicas, microscopia ou análise de imagens de satélite, identificando e segmentando automaticamente estruturas sem modelos pré-treinados especializados. Ao contrário de modelos como o SAM, o YOLOE reconhece e segmenta objetos simultaneamente de forma automática, auxiliando em tarefas como criação de conteúdo ou compreensão 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 muito mais.

Treino e Inferência

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

from ultralytics import YOLO

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

# Training YOLOE on custom dataset
yolo train model=yoloe-11s-seg.pt data=path/to/data.yaml epochs=50 imgsz=640

# Inference with text prompts
yolo predict model=yoloe-11s-seg.pt source="test_images/street.jpg" classes="person,bus"

Outras Tarefas Suportadas

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

Começando

Configure rapidamente o YOLOE com Ultralytics seguindo estes passos:

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

   pip install -U ultralytics
   

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

3. Requisitos de Hardware:

   • Inferência: GPU recomendada (NVIDIA com ≥4-8GB VRAM). Modelos pequenos são executados de forma eficiente em GPUs de borda (por exemplo, Jetson) ou CPUs em resoluções mais baixas.
   • Treinamento: O ajuste fino do 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 Ultralytics padrão. Configurações padrão (por exemplo, yoloe-11s-seg.yaml) normalmente são suficientes, mas você pode modificar o backbone, as classes ou o tamanho da imagem conforme necessário.

5. Executando o YOLOE:

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

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

   • Detecção com prompt (exemplo de prompt de texto):

     from ultralytics import YOLO
     
     model = YOLO("yoloe-11s-seg.pt")
     names = ["bowl", "apple"]
     model.set_classes(names, model.get_text_pe(names))
     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 use prompts. Os prompts de texto têm um impacto mínimo; os prompts visuais um pouco mais.
   • Inferência em lote: Suportado diretamente (model.predict([img1, img2])). Para prompts específicos da 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 YOLO familiar.

Citações e Agradecimentos

Se o YOLOE contribuiu para sua pesquisa ou projeto, cite o artigo original de Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han e Guiguang Ding da Universidade 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 mais informações, o artigo original do YOLOE está disponível no arXiv. O código fonte do projeto e recursos adicionais podem ser acedidos através do 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 3× menos recursos de treinamento e executa 1,4× mais rápido que o YOLO-Worldv2. O YOLOE também suporta três modos de prompting (texto, visual e vocabulário interno), enquanto o YOLO-World se concentra principalmente em prompts de texto. Além disso, o YOLOE inclui recursos de segmentação de instância integrados, fornecendo máscaras precisas em pixels para objetos detectados sem sobrecarga adicional.

Posso usar o YOLOE como um modelo YOLO regular?

Sim, o YOLOE pode funcionar exatamente como um modelo YOLO padrão, sem perda de desempenho. Quando usado no modo de conjunto fechado (sem prompts), os módulos de vocabulário aberto do YOLOE são reparametrizados no cabeçalho de deteçã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 detetor tradicional para velocidade máxima e, em seguida, 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. Text prompts: Especifique as classes de objetos usando linguagem natural (por exemplo, "pessoa", "semáforo", "scooter de pássaros")
2. Prompts visuais: Forneça imagens de referência dos objetos que você deseja detectar
3. Vocabulário interno: Use o vocabulário interno 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.

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 o cabeçalho de detecção com um ramo de previsão de máscara. Esta abordagem é semelhante ao YOLOv8-Seg, mas funciona para qualquer classe de objeto solicitada. As máscaras de segmentação são automaticamente incluídas nos resultados da inferência e podem ser acessadas através de results[0].masks. Essa abordagem unificada elimina a necessidade de modelos separados de detecção e segmentação, simplificando os fluxos de trabalho para aplicações que exigem limites de objetos com precisão de pixels.

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

Semelhante ao YOLO-World, o YOLOE suporta uma estratégia de "prompt-then-detect" que utiliza um vocabulário offline para aumentar a eficiência. Prompts personalizados, como legendas ou categorias de objetos específicos, são pré-codificados e armazenados como embeddings de vocabulário offline. Esta abordagem agiliza o processo de detecção sem exigir um novo treinamento. Você pode definir dinamicamente esses 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-11s-seg.pt")

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

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

# Show results
results[0].show()

📅 Criado há 3 meses ✏️ Atualizado há 1 dia

Comentários