Compreender a deteção de ponta a ponta no Ultralytics

Introdução

Se estiver a atualizar para o YOLO26 a partir de um modelo anterior, como YOLOv8 ou YOLO11, uma das maiores mudanças que irá notar é a remoção da Supressão Não Máxima (NMS). YOLO tradicionais produzem milhares de previsões sobrepostas que necessitam de uma etapa NMS separada para filtrar até às deteções finais. Isto aumenta a latência, complica os gráficos de exportação e pode apresentar um comportamento inconsistente em diferentes plataformas de hardware.

O YOLO26 adota uma abordagem diferente. Ele gera as deteções finais diretamente a partir do modelo — sem necessidade de filtragem externa. Este processo é conhecido como deteção de objetos de ponta a ponta e está ativado por predefinição em todos os modelos YOLO26. O resultado é um fluxo de implementação mais simples, menor latência e uma inferência até 43% mais rápida em CPUs.

Este guia explica o que mudou, se é necessário atualizar o seu código, quais os formatos de exportação que suportam a inferência de ponta a ponta e como migrar facilmente a partir de YOLO mais antigos.

Para uma análise mais aprofundada da motivação por trás desta mudança arquitetónica, consulte a publicaçãoUltralytics sobre os motivos pelos quais o YOLO26 elimina NMS.

Como funciona a deteção de ponta a ponta

O YOLO26 utiliza uma arquitetura de duas cabeças durante o treino. Ambas as cabeças partilham a mesma estrutura principal e o mesmo pescoço, mas produzem resultados de formas diferentes:

As formas acima destinam-se à deteção. Outras tarefas ampliam a saída um-para-um com dados adicionais por deteção:

Durante o treino, ambas as redes funcionam em simultâneo — a rede «um para muitos» fornece um sinal de aprendizagem mais rico, enquanto a rede «um para um» aprende a produzir previsões claras e sem sobreposições. Durante inferência e export, apenas o aulas individuais está ativado por predefinição, produzindo até 300 deteções por imagem no formato [x1, y1, x2, y2, confidence, class_id].

Quando ligar model.fuse(), agrupa as camadas Conv + BatchNorm para uma inferência mais rápida e, em modelos de ponta a ponta, também remove a cabeça «um para muitos» — reduzindo o tamanho do modelo e os FLOPs. Para mais detalhes sobre a arquitetura de cabeça dupla, consulte o Página do modelo YOLO26.

Preciso de alterar o meu código?

Utilizar aPython ou CLI Ultralytics Python

Não é necessário fazer alterações. Se utilizar a Python padrão Ultralytics ou CLI, tudo funciona automaticamente — a previsão, a validação e a exportação tratam de modelos de ponta a ponta de forma imediata.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Predict — no NMS step, no code changes
results = model.predict("image.jpg")

yolo predict model=yolo26n.pt source=image.jpg

Utilização de código de inferência personalizado

Sim, o formato de saída é diferente. Se criou uma lógica de pós-processamento personalizada para YOLOv8 ou YOLO11 (por exemplo, ao executar inferência com ONNX ou TensorRT), terá de atualizá-lo para lidar com o novo formato de saída:

Para as tarefas de segmentação, pose e OBB, o YOLO26 anexa dados específicos da tarefa a cada deteção — consulte a tabela de formatos de saída acima.

Onde N é o tamanho de lote e nc é o número de turmas (por exemplo, 80 para COCO).

Com modelos de ponta a ponta, o pós-processamento torna-se muito mais simples — por exemplo, ao utilizar ONNX :

import onnxruntime as ort

# Load and run the exported end-to-end model
session = ort.InferenceSession("yolo26n.onnx")
output = session.run(None, {session.get_inputs()[0].name: input_tensor})

# End-to-end output: (batch, 300, 6) → [x1, y1, x2, y2, confidence, class_id]
detections = output[0][0]  # first image in batch
detections = detections[detections[:, 4] > conf_threshold]  # confidence filter — that's it!

Mudança para a cabeça «um para muitos»

Se precisar do formato YOLO tradicional YOLO (por exemplo, para reutilizar código de pós-processamento existente NMS), pode mudar para a cabeça «um para muitos» a qualquer momento, definindo end2end=False:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Prediction with NMS (traditional behavior)
results = model.predict("image.jpg", end2end=False)

# Validation with NMS
metrics = model.val(data="coco.yaml", end2end=False)

# Export without end-to-end
model.export(format="onnx", end2end=False)

yolo predict model=yolo26n.pt source=image.jpg end2end=False
yolo val model=yolo26n.pt data=coco.yaml end2end=False
yolo export model=yolo26n.pt format=onnx end2end=False

Compatibilidade de formatos de exportação

A maioria dos formatos de exportação suporta inferência de ponta a ponta de forma nativa, incluindo ONNX, TensorRT, CoreML, OpenVINO, TFLite, TF.js e MNN.

Os seguintes formatos não suportam a relação «ponto a ponto» e recorrem automaticamente à relação «um para muitos»: NCNN, RKNN, PaddlePaddle, ExecuTorch, IMX e Edge TPU.

Compromissos entre precisão e velocidade

A deteção de ponta a ponta oferece vantagens significativas na implementação, com um impacto mínimo na precisão:

Para a maioria das aplicações reais, o valor de cerca de 0,5 mAP A diferença é insignificante, especialmente quando se tem em conta os ganhos em termos de rapidez e simplicidade. Se a precisão máxima for a sua principal prioridade, pode sempre recorrer à cabeça «um para muitos» utilizando end2end=False.

Consulte as métricas de desempenho do YOLO26 para obter resultados detalhados de testes de desempenho em todos os tamanhos de modelo (n, s, m, l, x).

Migração do YOLOv8 do YOLO11

Se estiver a atualizar um projeto existente para o YOLO26, eis uma lista de verificação rápida para garantir uma transição tranquila:

• CLI Ultralytics / CLI Ultralytics : Não é necessário fazer alterações — basta atualizar o nome do modelo para yolo26n.pt ) e YOLO11 para executar o rastreamento de objetos em quadros de vídeo. Este script assume que os pacotes necessários ( yolo26n-seg.pt, yolo26n-pose.pt, yolo26n-obb.pt)
• Código personalizado de pós-processamento: Atualização para lidar com os novos formatos de saída — (N, 300, 6) para deteção, além de dados específicos da tarefa para segmentação, pose, e OBB. Repare também na alteração do formato da caixa de xywh para xyxy
• Canais de exportação: consulte a secção sobre compatibilidade de formatos acima para o formato de destino
• TensorRT INT8: Certifique-se de que TensorRT sua TensorRT é superior à 10.3.0 para obter suporte completo
• Exportações FP16: Se precisar que todas as saídas sejam em FP16, exporte com end2end=False — ver por que é que o output0 permanece em FP32
• iOS CoreML: O processo de ponta a ponta é totalmente suportado. Se precisar de suporte para o Xcode Preview, utilize end2end=False com nms=True
• Dispositivos de borda (NCNN, RKNN): Estes formatos recorrem automaticamente ao padrão «um para muitos», pelo que deve incluir NMS seu pipeline no dispositivo

FAQ

Posso utilizar end2end=True e nms=True em simultâneo?

Não. Estas opções são mutuamente exclusivas. Se definir nms=True num modelo de ponta a ponta durante export, será automaticamente forçado a nms=False com um aviso. O terminal já trata internamente da filtragem de duplicados, pelo que não NMS necessário NMS externo.

No entanto, end2end=False em conjunto com nms=True é uma configuração válida — integra NMS tradicional NMS gráfico de exportação. Isto pode ser útil para CoreML exportações, pois permite utilizar a função de pré-visualização do Xcode diretamente com o modelo de deteção.

O que controla o parâmetro max_det nos modelos de ponta a ponta?

O max_det O parâmetro (padrão: 300) define o número máximo de deteções que o cabeçalho «um para um» pode gerar por imagem. Pode ajustá-lo durante a inferência ou na exportação:

model.predict("image.jpg", max_det=100)  # fewer detections, slightly faster
model.export(format="onnx", max_det=500)  # more detections for dense scenes

Note-se que os checkpoints padrão do YOLO26 foram treinados com max_det=300. Embora seja possível aumentar este valor, o modelo «um para um» foi otimizado durante o treino para produzir até 300 deteções precisas, pelo que as deteções além desse limite poderão ter uma qualidade inferior. Se precisar de mais de 300 deteções por imagem, considere voltar a treinar o modelo com um valor mais elevado max_det valor.

ONNX meu ONNX exportado apresenta os resultados (1, 300, 6) — está correto?

Sim, esse é o formato de saída de ponta a ponta esperado para a deteção: tamanho de lote de 1 a 300 deteções, cada uma com 6 valores [x1, y1, x2, y2, confidence, class_id]. Basta filtrar por limiar de confiança e está feito — não NMS ).

Para outras tarefas, a forma da saída difere:

Como posso verificar se o meu modelo exportado é de ponta a ponta?

Pode verificar isso utilizando aPython Ultralytics ou analisando diretamente os metadados ONNX exportado:

from ultralytics import YOLO

model = YOLO("yolo26n.onnx")
model.predict(verbose=False)  # run predict to setup predictor first
print(model.predictor.model.end2end)  # True if end-to-end is enabled

import onnxruntime as ort

session = ort.InferenceSession("yolo26n.onnx")
metadata = session.get_modelmeta().custom_metadata_map
print(metadata.get("end2end"))  # 'True' if end-to-end is enabled

Em alternativa, verifique a estrutura da saída — os modelos de deteção de ponta a ponta produzem (1, 300, 6), enquanto os modelos tradicionais produzem (1, nc + 4, 8400). Para outras formas de tarefas, consulte o Perguntas frequentes sobre formatos de saída.

O modelo end-to-end é compatível com tarefas de segmentação, pose e OBB?

Sim. Todas as variantes de tarefas do YOLO26 — detecção, segmentação, estimativa de pose, e deteção de objetos orientados (OBB) — suportam a inferência de ponta a ponta por predefinição. O end2end=False A opção de recurso alternativo também está disponível em todas as tarefas.

Cada tarefa complementa os resultados básicos da deteção com dados específicos da tarefa:

📅 Criado há 0 dias ✏️ Atualizado há 0 dias

Comentários