Ultralytics YOLO26
Visão geral
Ultralytics YOLO26 é a evolução mais recente na série YOLO de detectores de objetos em tempo real, projetada desde o início para dispositivos de borda e de baixo consumo de energia. Ele introduz um design simplificado que remove complexidades desnecessárias enquanto integra inovações direcionadas para oferecer uma implantação mais rápida, leve e acessível.

Explore e execute modelos YOLO26 diretamente na Ultralytics Platform.
A arquitetura do YOLO26 é guiada por três princípios fundamentais:
- Simplicidade: YOLO26 é um modelo nativo de ponta a ponta, produzindo previsões diretamente sem a necessidade de NMS. Ao eliminar esta etapa de pós-processamento, a inferência torna-se mais rápida, leve e fácil de implantar em sistemas do mundo real. Esta abordagem inovadora foi pioneira em YOLOv10 por Ao Wang na Universidade Tsinghua e foi ainda mais aprimorada no YOLO26.
- Eficiência de implantação: O design de ponta a ponta elimina uma etapa inteira do pipeline, simplificando drasticamente a integração, reduzindo a latência e tornando a implantação mais robusta em diversos ambientes.
- Inovação no treinamento: O YOLO26 introduz o MuSGD optimizer, um híbrido de SGD e Muon — inspirado pelos avanços do Kimi K2 da Moonshot AI no treinamento de LLM. Este otimizador traz maior estabilidade e convergência mais rápida, transferindo avanços de otimização de modelos de linguagem para a visão computacional.
- Otimizações específicas para tarefas: O YOLO26 introduz melhorias direcionadas para tarefas especializadas, incluindo perda de segmentação semântica e módulos de proto multiescala para Segmentation, estimativa de Residual Log-Likelihood Estimation (RLE) para Pose de alta precisão, e decodificação otimizada com perda de ângulo para resolver problemas de limite em OBB.
Juntas, estas inovações oferecem uma família de modelos que alcança maior precisão em objetos pequenos, proporciona uma implantação perfeita e executa até 43% mais rápido em CPUs — tornando o YOLO26 um dos modelos YOLO mais práticos e implementáveis até hoje para ambientes com recursos limitados.
Principais recursos
-
Remoção do DFL
O módulo Distribution Focal Loss (DFL), embora eficaz, frequentemente complicava a exportação e limitava a compatibilidade com hardware. O YOLO26 remove o DFL inteiramente, simplificando a inferência e ampliando o suporte para dispositivos de borda e de baixo consumo de energia. -
Inferência de ponta a ponta sem NMS
Ao contrário dos detectores tradicionais que dependem de NMS como uma etapa separada de pós-processamento, o YOLO26 é nativamente de ponta a ponta. As previsões são geradas diretamente, reduzindo a latência e tornando a integração em sistemas de produção mais rápida, leve e confiável. -
ProgLoss + STAL
Funções de perda aprimoradas aumentam a precisão da detecção, com melhorias notáveis no reconhecimento de pequenos objetos, um requisito crítico para IoT, robótica, imagens aéreas e outras aplicações de borda. -
Otimizador MuSGD
Um novo otimizador híbrido que combina SGD com Muon. Inspirado pelo Kimi K2 da Moonshot AI, o MuSGD introduz métodos avançados de otimização do treinamento de LLM na visão computacional, permitindo um treinamento mais estável e uma convergência mais rápida. -
Inferência de CPU até 43% mais rápida
Especificamente otimizado para computação de borda, o YOLO26 oferece uma inferência de CPU significativamente mais rápida, garantindo desempenho em tempo real em dispositivos sem GPUs. -
Aprimoramentos na segmentação de instâncias
Introduz perda de segmentação semântica para melhorar a convergência do modelo e um módulo proto atualizado que aproveita informações multiescala para uma qualidade de máscara superior. -
Estimativa de Pose de precisão
Integra Residual Log-Likelihood Estimation (RLE) para uma localização de pontos-chave mais precisa e otimiza o processo de decodificação para aumentar a velocidade de inferência. -
Decodificação OBB refinada
Introduz uma perda de ângulo especializada para melhorar a precisão da detecção de objetos quadrados e otimiza a decodificação OBB para resolver problemas de descontinuidade de limites.

Tarefas e modos suportados
O YOLO26 baseia-se na gama versátil de modelos estabelecida pelos lançamentos anteriores do Ultralytics YOLO, oferecendo suporte aprimorado em várias tarefas de visão computacional:
| Modelo | Nomes de arquivo | Tarefa | Inferência | Validação | Treinamento | Exportação |
|---|---|---|---|---|---|---|
| YOLO26 | yolo26n.pt yolo26s.pt yolo26m.pt yolo26l.pt yolo26x.pt | Detection | ✅ | ✅ | ✅ | ✅ |
| YOLO26-seg | yolo26n-seg.pt yolo26s-seg.pt yolo26m-seg.pt yolo26l-seg.pt yolo26x-seg.pt | Instance Segmentation | ✅ | ✅ | ✅ | ✅ |
| YOLO26-pose | yolo26n-pose.pt yolo26s-pose.pt yolo26m-pose.pt yolo26l-pose.pt yolo26x-pose.pt | Pose/Keypoints | ✅ | ✅ | ✅ | ✅ |
| YOLO26-obb | yolo26n-obb.pt yolo26s-obb.pt yolo26m-obb.pt yolo26l-obb.pt yolo26x-obb.pt | Oriented Detection | ✅ | ✅ | ✅ | ✅ |
| YOLO26-cls | yolo26n-cls.pt yolo26s-cls.pt yolo26m-cls.pt yolo26l-cls.pt yolo26x-cls.pt | Classification | ✅ | ✅ | ✅ | ✅ |
Esta estrutura unificada garante que o YOLO26 seja aplicável à detecção, segmentação, classificação, estimativa de pose e detecção de objetos orientados em tempo real — tudo com suporte para treinamento, validação, inferência e exportação.
yolo26-p2.yaml e yolo26-p6.yaml adicionam um cabeçote de detecção P2 (objeto pequeno) ou P6 (entrada grande) e são fornecidas apenas como arquiteturas YAML. Nenhum peso específico de escala yolo26*-p2.pt ou yolo26*-p6.pt é liberado. Instancie uma configuração escalonada a partir do YAML (por exemplo, YOLO("yolo26n-p6.yaml")) e treine ou ajuste conforme necessário.
Métricas de desempenho
Veja Detection Docs para exemplos de uso com estes modelos treinados no COCO, que incluem 80 classes pré-treinadas.
| Modelo | tamanho (pixels) | mAPval 50-95 | mAPval 50-95(e2e) | Velocidade CPU ONNX (ms) | Velocidade T4 TensorRT10 (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.4 |
| YOLO26s | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.7 |
| YOLO26m | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.2 |
| YOLO26l | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.4 |
| YOLO26x | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 193.9 |
Os valores de Params e FLOPs são para o modelo fundido após model.fuse(), que combina camadas Conv e BatchNorm e remove a head de detecção auxiliar one-to-many. Checkpoints pré-treinados mantêm a arquitetura de treinamento completa e podem exibir contagens maiores.
Exemplos de Uso
Esta seção fornece exemplos simples de treinamento e inferência com YOLO26. Para a documentação completa sobre estes e outros modos, veja as páginas de documentação de Previsão, Train, Val, e Exportação.
Note que o exemplo abaixo é para modelos YOLO26 Detect para object detection. Para tarefas adicionais suportadas, veja os documentos de Segment, Classify, OBB, e Pose.
Modelos PyTorch*.pt pré-treinados, bem como arquivos de configuração *.yaml, podem ser passados para a classe YOLO() para criar uma instância de modelo em Python:
from ultralytics import YOLO
# Load a COCO-pretrained YOLO26n model
model = YOLO("yolo26n.pt")
# Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Run inference with the YOLO26n model on the 'bus.jpg' image
results = model("path/to/bus.jpg")O YOLO26 apresenta uma arquitetura de head dupla que oferece flexibilidade para diferentes cenários de implantação:
- Head One-to-One (Padrão): Produz previsões end-to-end sem NMS, gerando
(N, 300, 6)com um máximo de 300 detecções por imagem. Esta head é otimizada para inferência rápida e implantação simplificada. - Head One-to-Many: Gera saídas tradicionais YOLO que requerem pós-processamento NMS, resultando em
(N, nc + 4, 8400)ondencé o número de classes. Esta head normalmente alcança maior precisão ao custo de processamento adicional.
Você pode alternar entre heads durante a exportação, previsão ou validação:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Use one-to-one head (default, no NMS required)
results = model.predict("image.jpg") # inference
metrics = model.val(data="coco.yaml") # validation
model.export(format="onnx") # export
# Use one-to-many head (requires NMS)
results = model.predict("image.jpg", end2end=False) # inference
metrics = model.val(data="coco.yaml", end2end=False) # validation
model.export(format="onnx", end2end=False) # exportA escolha depende dos requisitos de implantação: use a head one-to-one para máxima velocidade e simplicidade, ou a head one-to-many quando a precisão for a prioridade principal.
YOLOE-26: Segmentação de Instância de Vocabulário Aberto
O YOLOE-26 integra a arquitetura de alto desempenho YOLO26 com as capacidades de vocabulário aberto da série YOLOE. Ele permite a detecção e segmentação em tempo real de qualquer classe de objeto usando prompts de texto, prompts visuais, ou um modo sem prompt para inferência zero-shot, removendo efetivamente as restrições de treinamento por categorias fixas.
Ao aproveitar o design NMS-free, end-to-end do YOLO26, o YOLOE-26 entrega inferência rápida de mundo aberto. Isso o torna uma solução poderosa para aplicações de borda em ambientes dinâmicos onde os objetos de interesse representam um vocabulário amplo e em evolução.
Veja Docs YOLOE para exemplos de uso com estes modelos treinados no Objects365v1, GQA e Flickr30k datasets.
| Modelo | tamanho (pixels) | Tipo de Prompt | mAPminival 50-95(e2e) | mAPminival 50-95 | mAPr | mAPc | mAPf | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|---|---|
| YOLOE-26n-seg | 640 | Texto/Visual | 23.7 / 20.9 | 24.7 / 21.9 | 20.5 / 17.6 | 24.1 / 22.3 | 26.1 / 22.4 | 4.8 | 6.0 |
| YOLOE-26s-seg | 640 | Texto/Visual | 29.9 / 27.1 | 30.8 / 28.6 | 23.9 / 25.1 | 29.6 / 27.8 | 33.0 / 29.9 | 13.1 | 21.7 |
| YOLOE-26m-seg | 640 | Texto/Visual | 35.4 / 31.3 | 35.4 / 33.9 | 31.1 / 33.4 | 34.7 / 34.0 | 36.9 / 33.8 | 27.9 | 70.1 |
| YOLOE-26l-seg | 640 | Texto/Visual | 36.8 / 33.7 | 37.8 / 36.3 | 35.1 / 37.6 | 37.6 / 36.2 | 38.5 / 36.1 | 32.3 | 88.3 |
| YOLOE-26x-seg | 640 | Texto/Visual | 39.5 / 36.2 | 40.6 / 38.5 | 37.4 / 35.3 | 40.9 / 38.8 | 41.0 / 38.8 | 69.9 | 196.7 |
Exemplo de uso
YOLOE-26 suporta tanto prompts baseados em texto quanto visuais. Usar prompts é simples—basta passá-los através do predict método como mostrado abaixo:
Prompts de texto permitem que você especifique as classes que deseja detectar através de descrições textuais. O código a seguir mostra como você pode usar o YOLOE-26 para detectar pessoas e ônibus em uma imagem:
from ultralytics import YOLO
# Initialize model
model = YOLO("yoloe-26l-seg.pt") # or select 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()Para uma análise profunda sobre técnicas de prompt, treinamento do zero e exemplos completos de uso, visite a Documentação do YOLOE.
Citações e Agradecimentos
A Ultralytics não publicou um artigo de pesquisa formal para o YOLO26 devido à natureza em rápida evolução dos modelos. Em vez disso, focamos em fornecer modelos de ponta e torná-los fáceis de usar. Para as últimas atualizações sobre recursos, arquiteturas e uso do YOLO, visite nosso repositório GitHub e documentação.
Se você usar o YOLO26 ou outro software da Ultralytics em seu trabalho, por favor, cite-o como:
@software{yolo26_ultralytics,
author = {Glenn Jocher and Jing Qiu},
title = {Ultralytics YOLO26},
version = {26.0.0},
year = {2026},
url = {https://github.com/ultralytics/ultralytics},
orcid = {0000-0001-5950-6979, 0000-0003-3783-7069},
license = {AGPL-3.0}
}DOI pendente. O YOLO26 está disponível sob licenças AGPL-3.0 e Enterprise .
FAQ
Quais são as principais melhorias no YOLO26 em comparação com o YOLO11?
- Remoção do DFL: Simplifica a exportação e expande a compatibilidade com edge
- Inferência de ponta a ponta sem NMS: Elimina o NMS para uma implantação mais rápida e simples
- ProgLoss + STAL: Aumenta a precisão, especialmente em objetos pequenos
- Otimizador MuSGD: Combina SGD e Muon (inspirado no Kimi K2 da Moonshot) para um treinamento mais estável e eficiente
- Inferência de CPU até 43% mais rápida: Ganhos de desempenho significativos para dispositivos apenas com CPU
Quais tarefas o YOLO26 suporta?
O YOLO26 é uma família de modelos unificada, fornecendo suporte de ponta a ponta para múltiplas tarefas de visão computacional:
- Detecção de Objetos
- Instance Segmentation
- Classificação de Imagens
- Estimativa de Pose
- Detecção de Objetos Orientados (OBB)
Cada variante de tamanho (n, s, m, l, x) suporta todas as tarefas, além de versões de vocabulário aberto via YOLOE-26.
Por que o YOLO26 é otimizado para implantação em edge?
O YOLO26 oferece desempenho de edge de última geração com:
- Inferência em CPU até 43% mais rápida
- Tamanho de modelo reduzido e menor uso de memória
- Arquitetura simplificada para compatibilidade (sem DFL, sem NMS)
- Formatos de exportação flexíveis, incluindo TensorRT, ONNX, CoreML, TFLite e OpenVINO
Como começo com o YOLO26?
Os modelos YOLO26 foram lançados em 14 de janeiro de 2026 e estão disponíveis para download. Instale ou atualize o ultralytics pacote e carregue um modelo:
from ultralytics import YOLO
# Load a pretrained YOLO26 nano model
model = YOLO("yolo26n.pt")
# Run inference on an image
results = model("image.jpg")Veja a Exemplos de Uso seção para instruções de treinamento, validação e exportação.