YOLOv10: deteção de objetos de ponta a ponta em tempo real#
O YOLOv10, lançado em maio de 2024 e desenvolvido com base no Ultralytics Python package por investigadores da Universidade de Tsinghua, introduz uma nova abordagem à deteção de objetos em tempo real, resolvendo tanto as deficiências do pós-processamento como as da arquitetura dos modelos encontradas nas 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 desempenho excelente com uma sobrecarga computacional significativamente reduzida no momento do seu lançamento. O seu design de ponta a ponta sem NMS introduziu uma abordagem que foi posteriormente desenvolvida no YOLO26.

Watch: How to Train YOLOv10 on SKU-110k Dataset using Ultralytics | Retail Dataset
Visão geral#
A deteção de objetos em tempo real procura prever com precisão as categorias e as posições dos objetos nas imagens, com baixa latência. A série YOLO tem estado na vanguarda desta investigação devido ao seu equilíbrio entre desempenho e eficiência. No entanto, a dependência de NMS e as ineficiências arquiteturais têm limitado o 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 de modelos orientada pela eficiência e pela precisão.
Arquitetura#
A arquitetura do YOLOv10 baseia-se nos pontos fortes dos modelos YOLO anteriores, introduzindo simultaneamente várias inovações importantes. A arquitetura do modelo é composta pelos seguintes componentes:
- Backbone: Responsável pela extração de características, o backbone do YOLOv10 utiliza uma versão melhorada da CSPNet (Rede Parcial entre Estágios) para melhorar o fluxo dos gradientes e reduzir a redundância computacional.
- Neck: O neck foi concebido para agregar características de diferentes escalas e passá-las ao head. Inclui camadas PAN (Rede de Agregação de Caminhos) para uma fusão eficaz de características multiescala.
- Head de um para muitos: Gera várias previsões por objeto durante o treino para fornecer sinais de supervisão ricos e melhorar a precisão da aprendizagem.
- Head de um para um: Gera uma única previsão ideal por objeto durante a inferência para eliminar a necessidade de NMS, reduzindo assim a latência e melhorando a eficiência.
Principais funcionalidades#
- Treino sem NMS: Utiliza atribuições duplas consistentes para eliminar a necessidade de NMS, reduzindo a latência de 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, subamostragem desacoplada de canal espacial e design de bloco guiado por rank.
- Capacidades melhoradas do modelo: Incorpora convoluções de kernel grande e módulos de autoatenção parcial para melhorar o desempenho sem um custo computacional significativo.
Variantes do modelo#
O YOLOv10 está disponível em várias escalas de modelo para responder 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 utilização geral.
- YOLOv10b: Versão equilibrada com maior largura para obter mais precisão.
- YOLOv10l: Versão Large para maior precisão, à custa de recursos computacionais adicionais.
- YOLOv10x: Versão Extra-large para obter a máxima precisão e desempenho.
Desempenho#
O YOLOv10 supera as versões anteriores do YOLO e outros modelos de vanguarda em termos de precisão e eficiência. Por exemplo, o YOLOv10s é 1.8x mais rápido do que o RT-DETR-R18, com AP semelhante no conjunto de dados COCO, e o YOLOv10b tem menos 46% de latência e menos 25% de parâmetros do que o YOLOv9-C, com o mesmo desempenho.
Latência medida com TensorRT FP16 numa GPU T4.
| Modelo | Tamanho da 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 treino sem NMS#
O YOLOv10 emprega atribuições de rótulos duplas, combinando estratégias de um para muitos e de um para um durante o treinamento para garantir supervisão rica e implantação eficiente de ponta a ponta. A previsão e a validação do Ultralytics usam o cabeçote de um para muitos com NMS por padrão; define nms=False para selecionar o cabeçote sem NMS. A métrica de correspondência consistente alinha a supervisão entre ambas as estratégias, aprimorando a qualidade das previsões durante a inferência.
Design de modelos orientado holisticamente pela eficiência e pela precisão#
Melhorias de eficiência#
- Head de classificação leve: Reduz a sobrecarga computacional do head de classificação através do uso de convoluções separáveis em profundidade.
- Subamostragem Desacoplada de Canal Espacial: 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 pela hierarquia: Adapta o design dos blocos com base na redundância intrínseca das etapas, garantindo uma utilização ideal dos parâmetros.
Melhorias de precisão#
- Convolução de kernel grande: Aumenta o campo recetivo para melhorar a capacidade de extração de características.
- Autoatenção parcial (PSA): Incorpora módulos de autoatenção para melhorar a aprendizagem de representações globais com uma sobrecarga mínima.
Experiências 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 vanguarda em diferentes variantes, evidenciando melhorias significativas na latência e na precisão em comparação com versões anteriores e outros detetores contemporâneos.
Comparações#

Em comparação com outros detetores de vanguarda:
- YOLOv10s / x são 1.8× / 1.3× mais rápidos do que RT-DETR-R18 / R101, com precisão semelhante
- O YOLOv10b tem menos 25% de parâmetros e menos 46% de latência do 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
As figuras abaixo são as reportadas no artigo do YOLOv10, medidas de acordo com o respetivo protocolo, pelo que não são diretamente comparáveis com os valores nas páginas de modelos da Ultralytics:
| Modelo | Parâmetros (M) | FLOPs (G) | mAPval 50-95 | Latência (ms) | Latência prioritária (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 | 39.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.8 | 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.3 | 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.4 | 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 referem-se ao modelo fundido após model.fuse(), que combina as camadas Conv e BatchNorm e remove o head de deteção auxiliar de um para muitos. Os checkpoints pré-treinados mantêm a arquitetura completa de treino e podem apresentar contagens superiores.
Exemplos de utilização#
Para prever novas imagens com o YOLOv10. Também podes treinar modelos em GPUs na nuvem através da Ultralytics Platform:
from ultralytics import YOLO
# Load a pretrained YOLOv10n model
model = YOLO("yolov10n.pt")
# Perform object detection on an image
results = model("image.jpg")
# Display the results
results[0].show()Para treinar o YOLOv10 num conjunto de dados personalizado:
from ultralytics import YOLO
# Load YOLOv10n model from scratch
model = YOLO("yolov10n.yaml")
# Train the model
model.train(data="coco8.yaml", epochs=100, imgsz=640)Tarefas e modos suportados#
A série de modelos YOLOv10 oferece uma variedade de modelos, cada um otimizado para deteção de objetos de alto desempenho. Estes modelos respondem a diferentes necessidades computacionais e requisitos de precisão, tornando-os versáteis para uma ampla variedade de aplicações.
| Modelo | Nomes dos ficheiros | Tarefas | Treino | Validação | Inferência | Exportação |
|---|---|---|---|---|---|---|
| YOLOv10 | yolov10n.pt yolov10s.pt yolov10m.pt yolov10b.pt yolov10l.pt yolov10x.pt | Deteção de objetos | ✅ | ✅ | ✅ | ✅ |
Exportar o YOLOv10#
Devido às novas operações introduzidas com o YOLOv10, nem todos os formatos de exportação fornecidos pela Ultralytics são atualmente suportados. A tabela seguinte indica quais os formatos que foram convertidos com êxito utilizando a Ultralytics para o YOLOv10. Podes abrir um pull request se conseguires contribuir com uma alteração para adicionar suporte de exportação a formatos adicionais para o YOLOv10.
| Formato de exportação | Suporte de exportação | Inferência do modelo exportado | Notas |
|---|---|---|---|
| TorchScript | ✅ | ✅ | Formato de modelo PyTorch padrão. |
| ONNX | ✅ | ✅ | Amplamente suportado para implementação. |
| OpenVINO | ✅ | ✅ | Otimizado para hardware Intel. |
| TensorRT | ✅ | ✅ | Otimizado para GPUs NVIDIA. |
| CoreML | ✅ | ✅ | Limitado a dispositivos Apple. |
| TF SavedModel | ✅ | ✅ | Formato de modelo padrão do TensorFlow. |
| TF GraphDef | ✅ | ✅ | Formato legado do TensorFlow. |
| LiteRT | ✅ | ✅ | Otimizado para dispositivos móveis, sistemas incorporados e navegadores (LiteRT.js). |
| TF Edge TPU | ✅ | ✅ | Específico para dispositivos Edge TPU da Google. |
| PaddlePaddle | ❌ | ❌ | Popular na China; suporte global mais limitado. |
| NCNN | ✅ | ❌ | O operador torch.topk não é suportado pelo tempo de execução NCNN. |
Conclusão#
O YOLOv10 estabeleceu um novo padrão na deteção de objetos em tempo real aquando do seu lançamento, ao resolver as limitações das versões anteriores do YOLO e incorporar estratégias de design inovadoras. A sua abordagem sem NMS foi pioneira na deteção de objetos de ponta a ponta na família YOLO. Para conhecer o modelo Ultralytics mais recente, com desempenho melhorado e inferência sem NMS, consulta o YOLO26.
Citações e agradecimentos#
Gostaríamos de reconhecer os autores do YOLOv10 da Universidade de Tsinghua pela sua extensa investigação e pelas suas contribuições significativas para a estrutura 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 investigação do YOLOv10 e o repositório do GitHub da equipa da Universidade de Tsinghua.
Perguntas frequentes#
O YOLOv10, desenvolvido por investigadores da Universidade de Tsinghua, introduz várias inovações importantes na deteção de objetos em tempo real. Elimina a necessidade de supressão não máxima (NMS) através da utilização de atribuições duplas consistentes durante o treino e de componentes de modelo otimizados, proporcionando um desempenho superior com menor sobrecarga computacional. Para obter mais detalhes sobre a sua arquitetura e principais funcionalidades, consulta a secção Visão geral do YOLOv10.
Para uma inferência fácil, podes utilizar a biblioteca Python Ultralytics YOLO ou a interface de linha de comandos (CLI). Seguem abaixo exemplos de previsão em novas imagens com o YOLOv10:
Exemplofrom ultralytics import YOLO # Load the pretrained YOLOv10n model model = YOLO("yolov10n.pt") results = model("image.jpg") results[0].show()Para ver 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 largura aumentada
- YOLOv10l: Elevada precisão à custa de mais recursos computacionais
- YOLOv10x: Máxima precisão e desempenho
Cada variante foi concebida para diferentes necessidades computacionais e requisitos de precisão, tornando-as versáteis para uma grande variedade de aplicações. Consulta a secção Variantes de modelo para obter mais informações.
O YOLOv10 treina com atribuições duplas consistentes para que sua cabeça um-para-um produza uma única melhor predição por objeto, o que elimina a necessidade de supressão de não-máximos (NMS) na inferência. A predição e validação do Ultralytics têm como padrão a cabeça um-para-muitos com NMS; define
nms=Falsepara selecionar a cabeça sem NMS e descartar a passagem de NMS. Para uma explicação detalhada, consulte a seção Consistent Dual Assignments for NMS-Free Training.O YOLOv10 é compatível com vários formatos de exportação, incluindo TorchScript, ONNX, OpenVINO e TensorRT. No entanto, nem todos os formatos de exportação disponibilizados pela Ultralytics são atualmente compatíveis com o YOLOv10 devido às suas novas operações. Para obter detalhes sobre os formatos compatíveis e instruções de exportação, visita a secção Exportar YOLOv10.
O YOLOv10 supera as versões anteriores do YOLO e outros modelos de última geração tanto em precisão como em eficiência. Por exemplo, o YOLOv10s é 1,8 vezes mais rápido do que o RT-DETR-R18, com um AP semelhante no conjunto de dados COCO. O YOLOv10b apresenta menos 46% de latência e menos 25% de parâmetros do que o YOLOv9-C, com o mesmo desempenho. Podes encontrar benchmarks detalhados na secção Comparações.