YOLOv10: deteção de objetos ponta a ponta em tempo real#
Lançado em maio de 2024 e desenvolvido com base no Ultralytics pacote Python por investigadores da Tsinghua University, o YOLOv10 introduz uma nova abordagem à deteção de objetos em tempo real, resolvendo deficiências no pós-processamento e na arquitetura dos modelos presentes em versões anteriores do YOLO. Ao eliminar a supressão não máxima (NMS) e otimizar vários componentes do modelo, o YOLOv10 alcançou um excelente desempenho, com uma redução significativa da sobrecarga computacional na altura do lançamento. O seu design ponta a ponta sem NMS pioneirou uma abordagem que foi desenvolvida posteriormente no YOLO26.

Assista: Como treinar YOLOv10 no conjunto de dados SKU-110k usando Ultralytics | Conjunto de dados de varejo
Visão geral#
A deteção de objetos em tempo real procura prever com precisão as categorias e posições dos objetos nas imagens, com baixa latência. A série YOLO tem estado na vanguarda desta investigação graças ao equilíbrio entre desempenho e eficiência. No entanto, a dependência de NMS e as ineficiências arquiteturais têm impedido um desempenho ideal. O YOLOv10 resolve estes problemas ao introduzir atribuições duplas consistentes para treino sem NMS e uma estratégia holística de design do modelo orientada para a eficiência e a precisão.
Arquitetura#
A arquitetura do YOLOv10 baseia-se nos pontos fortes dos modelos YOLO anteriores e introduz várias inovações importantes. A arquitetura do modelo é composta pelos seguintes elementos:
- Backbone: responsável pela extração de características, o backbone do YOLOv10 utiliza uma versão aprimorada do CSPNet (Cross Stage Partial Network) para melhorar o fluxo de gradientes e reduzir a redundância computacional.
- Neck: o neck foi concebido para agregar características de diferentes escalas e encaminhá-las para a head. Inclui camadas PAN (Path Aggregation Network) para uma fusão eficaz de características multiescala.
- Head One-to-Many: gera várias previsões por objeto durante o treino para fornecer sinais de supervisão ricos e melhorar a precisão da aprendizagem.
- Cabeça One-to-One: Gera uma única previsão melhor por objeto durante a inferência, eliminando a necessidade de NMS e, assim, reduzindo a latência e aumentando a eficiência.
Principais funcionalidades#
- Treinamento sem NMS: Utiliza atribuições duplas consistentes para eliminar a necessidade de NMS e reduzir a latência da inferência.
- Design holístico do modelo: Otimização abrangente de vários componentes sob as perspectivas de eficiência e precisão, incluindo cabeças de classificação leves, redução de resolução desacoplada entre espaço e canais e design de blocos orientado por classificação.
- Recursos aprimorados do modelo: Incorpora convoluções com kernels grandes e módulos de atenção própria parcial para melhorar o desempenho sem um custo computacional significativo.
Variantes do modelo#
O YOLOv10 oferece modelos em várias escalas para atender a diferentes necessidades de aplicação:
- YOLOv10n: Versão Nano para ambientes com recursos extremamente limitados.
- YOLOv10s: Versão Small que equilibra velocidade e precisão.
- YOLOv10m: Versão Medium para uso geral.
- YOLOv10b: Versão equilibrada com maior largura para obter mais precisão.
- YOLOv10l: Versão Large para obter mais precisão à custa de um maior consumo de recursos computacionais.
- YOLOv10x: Versão Extra-large para obter o máximo de precisão e desempenho.
Desempenho#
O YOLOv10 supera as versões anteriores do YOLO e outros modelos de última geração em precisão e eficiência. Por exemplo, o YOLOv10s é 1,8 vez mais rápido que o RT-DETR-R18, com AP semelhante no conjunto de dados COCO, e o YOLOv10b apresenta 46% menos latência e 25% menos parâmetros que o YOLOv9-C, com o mesmo desempenho.
Latência medida com TensorRT FP16 em uma GPU T4.
| Modelo | Tamanho de entrada | APval | FLOPs (G) | Latência (ms) |
|---|---|---|---|---|
| [YOLOv10n][1] | 640 | 38.5 | 6.7 | 1.84 |
| [YOLOv10s][2] | 640 | 46.3 | 21.6 | 2.49 |
| [YOLOv10m][3] | 640 | 51.1 | 59.1 | 4.74 |
| [YOLOv10b][4] | 640 | 52.5 | 92.0 | 5.74 |
| [YOLOv10l][5] | 640 | 53.2 | 120.3 | 7.28 |
| [YOLOv10x][6] | 640 | 54.4 | 160.4 | 10.70 |
Metodologia#
Atribuições duplas consistentes para treinamento sem NMS#
O YOLOv10 utiliza atribuições duplas de rótulos, combinando estratégias one-to-many e one-to-one durante o treinamento para garantir uma supervisão rica e uma implantação eficiente de ponta a ponta. Por padrão, a previsão e a validação do Ultralytics usam a cabeça one-to-many com NMS; define nms=False para selecionar a cabeça sem NMS. A métrica de correspondência consistente alinha a supervisão entre as duas estratégias, melhorando a qualidade das previsões durante a inferência.
Design holístico do modelo orientado por eficiência e precisão#
Melhorias de eficiência#
- Cabeça de classificação leve: Reduz a sobrecarga computacional da cabeça de classificação usando convoluções separáveis em profundidade.
- Redução de resolução desacoplada entre espaço e canais: Desacopla a redução espacial e a modulação de canais para minimizar a perda de informação e o custo computacional.
- Design de blocos orientado por classificação: Adapta o design dos blocos com base na redundância intrínseca de cada estágio, garantindo o uso ideal dos parâmetros.
Melhorias de precisão#
- Convolução com kernel grande: Amplia o campo receptivo para aprimorar a capacidade de extração de características.
- Atenção própria parcial (PSA): Incorpora módulos de atenção própria para melhorar o aprendizado de representações globais com sobrecarga mínima.
Experimentos e resultados#
O YOLOv10 foi amplamente testado em benchmarks padrão, como o COCO, demonstrando desempenho e eficiência superiores. O modelo alcança resultados de última geração em diferentes variantes, apresentando melhorias significativas em latência e precisão em comparação com versões anteriores e outros detectores contemporâneos.
Comparações#

Em comparação com outros detectores de última geração:
- YOLOv10s / x são 1,8× / 1,3× mais rápidos que RT-DETR-R18 / R101, com precisão semelhante
- O YOLOv10b tem 25% menos parâmetros e 46% menos latência que o YOLOv9-C com a mesma precisão
- YOLOv10l / x superam o YOLOv8l / x em 0,3 AP / 0,5 AP, com 1,8× / 2,3× menos parâmetros
Os valores abaixo são os apresentados no artigo do YOLOv10, medidos de acordo com o protocolo próprio do estudo; por isso, não são diretamente comparáveis aos valores nas páginas de modelos do Ultralytics:
| Modelo | Parâmetros (M) | FLOPs (G) | mAPval 50-95 | Latência (ms) | Latência-forward (ms) |
|---|---|---|---|---|---|
| YOLOv6-3.0-N | 4.7 | 11.4 | 37.0 | 2.69 | 1.76 |
| Gold-YOLO-N | 5.6 | 12.1 | 39.6 | 2.92 | 1.82 |
| YOLOv8n | 3.2 | 8.7 | 37.3 | 6.16 | 1.77 |
| YOLOv10n | 2.3 | 6.7 | 38.5 | 1.84 | 1.79 |
| YOLOv6-3.0-S | 18.5 | 45.3 | 44.3 | 3.42 | 2.35 |
| Gold-YOLO-S | 21.5 | 46.0 | 45.4 | 3.82 | 2.73 |
| YOLOv8s | 11.2 | 28.6 | 44.9 | 7.07 | 2.33 |
| YOLOv10s | 7.2 | 21.6 | 46.3 | 2.49 | 2.39 |
| RT-DETR-R18 | 20.0 | 60.0 | 46.5 | 4.58 | 4.49 |
| YOLOv6-3.0-M | 34.9 | 85.8 | 49.1 | 5.63 | 4.56 |
| Gold-YOLO-M | 41.3 | 87.5 | 49.8 | 6.38 | 5.45 |
| YOLOv8m | 25.9 | 78.9 | 50.6 | 9.50 | 5.09 |
| YOLOv10m | 15.4 | 59.1 | 51.1 | 4.74 | 4.63 |
| YOLOv6-3.0-L | 59.6 | 150.7 | 51.8 | 9.02 | 7.90 |
| Gold-YOLO-L | 75.1 | 151.7 | 51.8 | 10.65 | 9.78 |
| YOLOv8l | 43.7 | 165.2 | 52.9 | 12.39 | 8.06 |
| RT-DETR-R50 | 42.0 | 136.0 | 53.1 | 9.20 | 9.07 |
| YOLOv10l | 24.4 | 120.3 | 53.2 | 7.28 | 7.21 |
| YOLOv8x | 68.2 | 257.8 | 53.9 | 16.86 | 12.83 |
| RT-DETR-R101 | 76.0 | 259.0 | 54.3 | 13.71 | 13.58 |
| YOLOv10x | 29.5 | 160.4 | 54.4 | 10.70 | 10.60 |
Os valores de parâmetros e FLOPs correspondem ao modelo fundido após model.fuse(), que combina as camadas Conv e BatchNorm e remove a cabeça auxiliar de detecção one-to-many. Os checkpoints pré-treinados mantêm a arquitetura completa de treinamento e podem apresentar valores maiores.
Exemplos de uso#
Os modelos também podem ser treinados em GPUs na nuvem por meio da Plataforma Ultralytics. Para fazer previsões em novas imagens com o YOLOv10:
from ultralytics import YOLO
# Carrega um modelo YOLOv10n pré-treinado
model = YOLO("yolov10n.pt")
# Realizar detecção de objetos em uma imagem
results = model("image.jpg")
# Apresenta os resultados
results[0].show()Para treinar o YOLOv10 em um conjunto de dados personalizado:
from ultralytics import YOLO
# Carrega o modelo YOLOv10n do zero
model = YOLO("yolov10n.yaml")
# Treinar o modelo
model.train(data="coco8.yaml", epochs=100, imgsz=640)Tarefas e modos compatíveis#
A série de modelos YOLOv10 oferece uma variedade de modelos, cada um otimizado para Detecção de objetos de alto desempenho. Esses modelos atendem a diferentes necessidades computacionais e requisitos de precisão, tornando-os versáteis para uma ampla gama de aplicações.
| Modelo | Nomes de arquivo | Tarefas | Treinamento | Validação | Inferência | Exportar |
|---|---|---|---|---|---|---|
| YOLOv10 | yolov10n.pt yolov10s.pt yolov10m.pt yolov10b.pt yolov10l.pt yolov10x.pt | Deteção de objetos | ✅ | ✅ | ✅ | ✅ |
Exportação do YOLOv10#
Devido às novas operações introduzidas com o YOLOv10, nem todos os formatos de exportação oferecidos pelo Ultralytics são compatíveis no momento. A tabela a seguir indica quais formatos foram convertidos com sucesso usando o Ultralytics para o YOLOv10. Fica à vontade para abrir uma solicitação de pull request se puderes contribuir com uma alteração para adicionar suporte à exportação de outros formatos para o YOLOv10.
| Formato de exportação | Suporte à exportação | Inferência do modelo exportado | Observações |
|---|---|---|---|
| TorchScript | ✅ | ✅ | Formato padrão de modelo PyTorch. |
| ONNX | ✅ | ✅ | Amplo suporte para implantação. |
| OpenVINO | ✅ | ✅ | Otimizado para hardware Intel. |
| TensorRT | ✅ | ✅ | Otimizado para GPUs NVIDIA. |
| CoreML | ✅ | ✅ | Limitado a dispositivos Apple. |
| TF SavedModel | ✅ | ✅ | Formato padrão de modelo do TensorFlow. |
| TF GraphDef | ✅ | ✅ | Formato legado do TensorFlow. |
| TF Edge TPU | ✅ | ✅ | Específico para dispositivos Edge TPU do Google. |
| LiteRT | ✅ | ✅ | Otimizado para dispositivos móveis, sistemas embarcados e navegadores (LiteRT.js). |
| PaddlePaddle | ❌ | ❌ | Popular na China; menor suporte global. |
| NCNN | ✅ | ❌ | O operador torch.topk não é compatível com o runtime do NCNN. |
Conclusão#
O YOLOv10 estabeleceu um novo padrão em detecção de objetos em tempo real quando foi lançado, ao solucionar as limitações das versões anteriores do YOLO e incorporar estratégias inovadoras de design. Sua abordagem sem NMS foi pioneira na detecção de objetos de ponta a ponta na família YOLO. Para conhecer o modelo mais recente do Ultralytics, com desempenho aprimorado e inferência sem NMS, veja o YOLO26.
Citações e agradecimentos#
Gostaríamos de agradecer aos autores do YOLOv10, da Universidade Tsinghua, pela extensa pesquisa e pelas contribuições significativas para o framework Ultralytics:
@inproceedings{wang2024yolov10,
title={YOLOv10: Real-Time End-to-End Object Detection},
author={Wang, Ao and Chen, Hui and Liu, Lihao and Chen, Kai and Lin, Zijia and Han, Jungong and Ding, Guiguang},
booktitle={Advances in Neural Information Processing Systems},
doi = {10.52202/079017-3429},
url = {https://proceedings.neurips.cc/paper_files/paper/2024/file/c34ddd05eb089991f06f3c5dc36836e0-Paper-Conference.pdf},
volume={37},
pages={107984--108011},
year={2024}
}Para obter informações detalhadas sobre a implementação, as inovações arquiteturais e os resultados experimentais, consulta o artigo de pesquisa sobre o YOLOv10 e o repositório do GitHub da equipe da Universidade Tsinghua.
Perguntas frequentes#
O YOLOv10, desenvolvido por pesquisadores da Universidade Tsinghua, introduz várias inovações importantes na detecção de objetos em tempo real. Ele elimina a necessidade de supressão não máxima (NMS) usando atribuições duplas consistentes durante o treinamento e componentes de modelo otimizados para oferecer desempenho superior com menor sobrecarga computacional. Para saber mais sobre a arquitetura e os principais recursos, consulta a seção Visão geral do YOLOv10.
Para facilitar a inferência, podes usar a biblioteca Python Ultralytics YOLO ou a interface de linha de comandos (CLI). Abaixo estão exemplos de como prever imagens novas usando YOLOv10:
Exemplofrom ultralytics import YOLO # Carrega o modelo YOLOv10n pré-treinado model = YOLO("yolov10n.pt") results = model("image.jpg") results[0].show()Para veres mais exemplos de utilização, visita a secção Exemplos de utilização.
O YOLOv10 oferece várias variantes de modelo para responder a diferentes casos de utilização:
- YOLOv10n: adequado para ambientes com recursos extremamente limitados
- YOLOv10s: equilibra velocidade e precisão
- YOLOv10m: utilização geral
- YOLOv10b: maior precisão com uma largura aumentada
- YOLOv10l: alta precisão à custa de recursos computacionais
- YOLOv10x: precisão e desempenho máximos
Cada variante foi concebida para diferentes necessidades computacionais e requisitos de precisão, tornando-as versáteis para diversas aplicações. Explora a secção Variantes do modelo para obteres mais informações.
O YOLOv10 é treinado com atribuições duplas consistentes, de modo que a sua cabeça um-para-um produza uma única previsão de melhor qualidade por objeto, eliminando a necessidade de supressão não máxima (NMS) durante a inferência. Por predefinição, a predição e a validação do Ultralytics usam a cabeça um-para-muitos com NMS; define
nms=Falsepara selecionar a cabeça sem NMS e eliminar a etapa de NMS. Para uma explicação detalhada, consulta a secção Atribuições duplas consistentes para treino sem NMS.O YOLOv10 suporta vários formatos de exportação, incluindo TorchScript, ONNX, OpenVINO e TensorRT. No entanto, nem todos os formatos de exportação disponibilizados pelo Ultralytics são atualmente compatíveis com o YOLOv10 devido às suas novas operações. Para obteres detalhes sobre os formatos suportados e instruções de exportação, visita a secção Exportar YOLOv10.
O YOLOv10 supera versões anteriores do YOLO e outros modelos de última geração em precisão e eficiência. Por exemplo, o YOLOv10s é 1.8x mais rápido do que o RT-DETR-R18, com um AP semelhante no conjunto de dados COCO. O YOLOv10b apresenta uma latência 46% inferior e 25% menos parâmetros do que o YOLOv9-C, com o mesmo desempenho. Podes encontrar resultados de referência detalhados na secção Comparações.