Meituan YOLOv6
Présentation#
Meituan YOLOv6, publié en 2022, est un modèle de détection d’objets qui offre un excellent équilibre entre vitesse et précision, ce qui en fait un choix populaire pour les applications en temps réel. Ce modèle apporte plusieurs améliorations notables à son architecture et à son schéma d’entraînement, notamment la mise en œuvre d’un module de concaténation bidirectionnelle (BiC), une stratégie d’entraînement assistée par ancres (AAT), ainsi qu’une conception améliorée du backbone et du neck pour une grande précision sur le jeu de données COCO.
Présentation de YOLOv6. Schéma de l'architecture du modèle illustrant les composants du réseau repensés et les stratégies d'entraînement qui ont permis d'obtenir des améliorations significatives des performances. (a) Le neck de YOLOv6 (N et S sont représentés). Remarque : pour M/L, RepBlocks est remplacé par CSPStackRep. (b) La structure d'un module BiC. (c) Un bloc SimCSPSPPF. (source).
Fonctionnalités clés#
- Module de concaténation bidirectionnelle (BiC) : YOLOv6 introduit un module BiC dans le neck du détecteur, qui renforce les signaux de localisation et améliore les performances avec une dégradation négligeable de la vitesse.
- Stratégie d’entraînement assisté par ancres (AAT) : AAT combine les avantages des paradigmes avec ancres et sans ancres sans compromettre l’efficacité de l’inférence.
- Conception améliorée du backbone et du neck : En approfondissant YOLOv6 par l'ajout d'une étape au backbone et au neck, ce modèle a obtenu de solides performances sur le jeu de données COCO avec des entrées haute résolution lors de sa sortie.
- Stratégie d’auto-distillation : une nouvelle stratégie d’auto-distillation est mise en œuvre pour améliorer les performances des modèles YOLOv6 de petite taille. Elle renforce la branche de régression auxiliaire pendant l’entraînement et la supprime lors de l’inférence afin d’éviter une baisse notable de la vitesse.
Indicateurs de performance#
YOLOv6 propose plusieurs modèles préentraînés de différentes tailles :
- YOLOv6-N : 37,5 % d'AP sur COCO val2017 à 1 187 FPS avec un GPU NVIDIA T4.
- YOLOv6-S : 45,0 % d'AP à 484 FPS.
- YOLOv6-M : 50,0 % d'AP à 226 FPS.
- YOLOv6-L : 52,8 % d'AP à 116 FPS.
- YOLOv6-L6 : précision de pointe en temps réel.
YOLOv6 propose également des modèles quantifiés avec différents niveaux de précision numérique, ainsi que des modèles optimisés pour les plateformes mobiles.
Exemples d'utilisation#
Cet exemple présente des exemples simples d’entraînement et d’inférence avec YOLOv6.
Les fichiers *.yaml de YOLOv6 peuvent être transmis à la classe YOLO() pour créer le modèle correspondant en Python :
from ultralytics import YOLO
# Créer un modèle YOLOv6n à partir de zéro
model = YOLO("yolov6n.yaml")
# Afficher les informations du modèle (facultatif)
model.info()
# Entraîner le modèle sur le jeu de données d'exemple COCO8 pendant 100 époques
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Exécuter l'inférence avec le modèle YOLOv6n sur l'image 'bus.jpg'
results = model("path/to/bus.jpg")Tâches et modes pris en charge#
La série YOLOv6 propose différents modèles, chacun optimisé pour la détection d’objets, afin de répondre à divers budgets de calcul et exigences de précision.
| Modèle | Noms de fichiers | Tâches | Entraînement | Validation | Inférence | Export |
|---|---|---|---|---|---|---|
| YOLOv6-N | yolov6n.yaml | Détection d'objets | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-S | yolov6s.yaml | Détection d'objets | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-M | yolov6m.yaml | Détection d'objets | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-L | yolov6l.yaml | Détection d'objets | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-X | yolov6x.yaml | Détection d'objets | ✅ | ✅ | ✅ | ✅ |
Ce tableau récapitule les variantes de modèles YOLOv6 et leur prise en charge des modes Training, Validation, Inference et Export. Ultralytics fournit uniquement les fichiers YAML des modèles YOLOv6 ; les modèles sont donc entraînés à partir de zéro.
Citations et remerciements#
Nous tenons à saluer les auteurs pour leurs contributions majeures au domaine de la détection d'objets en temps réel :
@misc{li2023yolov6,
title={YOLOv6 v3.0: A Full-Scale Reloading},
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
year={2023},
eprint={2301.05586},
archivePrefix={arXiv},
primaryClass={cs.CV}
}L'article original sur YOLOv6 est disponible sur arXiv. Les auteurs ont rendu leurs travaux accessibles au public, et le code source est disponible sur GitHub. Nous saluons leurs efforts pour faire progresser le domaine et rendre leurs travaux accessibles à l'ensemble de la communauté.
FAQ#
Lancé en 2022, Meituan YOLOv6 est un détecteur d'objets qui équilibre vitesse et précision et qui est conçu pour les applications en temps réel. Il comporte des améliorations architecturales notables, comme le module de concaténation bidirectionnelle (BiC) et une stratégie d'entraînement assisté par ancres (AAT). Ces innovations améliorent considérablement les performances avec un impact minime sur la vitesse, faisant de YOLOv6 un choix compétitif pour les tâches de détection d'objets.
Le module de concaténation bidirectionnelle (BiC) de YOLOv6 renforce les signaux de localisation dans le neck du détecteur et améliore les performances avec un impact négligeable sur la vitesse. Ce module combine efficacement différentes cartes de caractéristiques, augmentant la capacité du modèle à détecter les objets avec précision. Pour en savoir plus sur les fonctionnalités de YOLOv6, consulte la section Fonctionnalités clés.
Tu peux entraîner un modèle YOLOv6 avec Ultralytics à l'aide de commandes Python ou CLI simples. Par exemple :
Exemplefrom ultralytics import YOLO # Créer un modèle YOLOv6n à partir de zéro model = YOLO("yolov6n.yaml") # Entraîner le modèle sur le jeu de données d'exemple COCO8 pendant 100 époques results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Pour en savoir plus, consulte la page Entraînement.
YOLOv6 propose plusieurs versions, chacune optimisée pour répondre à différents besoins de performance :
- YOLOv6-N : 37,5 % d'AP à 1 187 FPS
- YOLOv6-S : 45,0 % d'AP à 484 FPS
- YOLOv6-M : 50,0 % d'AP à 226 FPS
- YOLOv6-L : 52,8 % d'AP à 116 FPS
- YOLOv6-L6 : précision de pointe dans des scénarios en temps réel
Ces modèles sont évalués sur le jeu de données COCO avec un GPU NVIDIA T4. Pour en savoir plus sur les métriques de performance, consulte la section Métriques de performance.
L'entraînement assisté par ancres (AAT) de YOLOv6 combine des éléments des approches avec ancres et sans ancres, améliorant les capacités de détection du modèle sans compromettre l'efficacité de l'inférence. Cette stratégie exploite les ancres pendant l'entraînement pour améliorer les prédictions des boîtes englobantes, ce qui rend YOLOv6 efficace pour diverses tâches de détection d'objets.
YOLOv6 prend en charge les modes Entraînement, Validation, Inférence et Exportation.
Commentaires14
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
AkaashSamson
Hey, So I have actually trained my YOLOv6 model with the original repo, now I have a .pt file. using this file is there any way of getting my model in ultralytics format. mainly I want to run the ultralytics validation on my model as the original repo eval.py doesn't provide sufficient metrics.
Glenn JocherUltralyticsDirect conversion of Meituan YOLOv6 .pt checkpoints to Ultralytics format isn’t supported; to use Ultralytics metrics, either train/fine-tune the matching yolov6*.yaml in Ultralytics and run validation, or export your Meituan model’s detections to COCO JSON and compute P/R via the COCO API; the metrics Ultralytics reports are outlined in the Val mode docs at Ultralytics validation.
tino926(modifié)
I want to replicate your training accuracy of the YOLOv6-N model. Is this the correct command:
yolo train model=yolov6n.yaml data=coco.yaml epochs=400 optimizer=SGD cos_lr=True lr0=0.02? According to YOLOv6's repo https://github.com/meituan/YOLOv6/blob/main/docs/Train_coco_data.md, they have to use anchor-aid and distilling techniques to achieve this accuracy. But I can't find the corresponding parameters in ultralytics'.
Glenn JocherUltralytics@tino926 to achieve the training accuracy of the YOLOv6-N model as described in the YOLOv6 repository, you would indeed use the anchor-aided training (AAT) and self-distillation strategies, which are not explicitly parameterized in the Ultralytics YOLO interface. Ensure you are using the latest version and check the YOLOv6 documentation for any updates on incorporating these strategies. For precise replication, consider following the original YOLOv6 GitHub instructions alongside Ultralytics for any additional settings or configurations.
tino926
@glenn-jocher, thanks for your response.
I apologize if I misunderstood your explanation, as I am not a native English speaker. Could you please clarify if the phrase "which are not explicitly parameterized in the Ultralytics YOLO interface" means that AAT and self-distillation cannot currently be implemented solely through the Ultralytics YOLO interface? Therefore I should manually add anchor branches and implement distillation with additional code?
Glenn JocherUltralyticsThank you for your question. Yes, that's correct. The current Ultralytics YOLO interface does not explicitly support anchor-aided training (AAT) and self-distillation, so you would need to implement these strategies manually by modifying the code to include anchor branches and self-distillation techniques. If you need further guidance on implementing these, referring to the original YOLOv6 repository might be helpful.
kadirnar
Does ultralytics library support yolov6 model?
ModuleNotFoundError: No module named 'yolov6'
Paula DerrengerUltralytics(modifié)@kadirnar hi there!
Yes, the Ultralytics library does support YOLOv6 models. It seems like you might be encountering a
ModuleNotFoundErrorbecause the YOLOv6 model isn't being recognized. Let's ensure you're using the latest versions oftorchandultralytics. Please update your packages and try again:pip install --upgrade torch ultralyticsHere's a quick example to get you started with YOLOv6 using the Ultralytics library:
Python
from ultralytics import YOLO # Load a YOLOv6n model model = YOLO("yolov6n.yaml") # 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 trained model on an image results = model("path/to/bus.jpg")CLI
# Train YOLOv6n model yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640 # Run inference with your trained weights yolo predict model=path/to/best.pt source=path/to/bus.jpgIf you continue to face issues, please provide a minimum reproducible example so we can better assist you. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.
Feel free to reach out if you have any more questions! 😊
akhilesh99sharma
There are AP and AR values for results but not precision and recall. I need to compare precision and recall values for different YOLO versions (v5,v6,v7 etc.) on my custom dataset. How to get precision and recall values for YOLOv6 evaluation?
Paula DerrengerUltralytics(modifié)Hey there! 👋
You don't need to compute precision and recall by hand: validation already reports them. After
model.val(), the results object holds them directly:from ultralytics import YOLO # Load your trained model model = YOLO("path/to/your/custom-yolov6-model.pt") # Run validation results = model.val(data="path/to/your/dataset.yaml") print(f"Precision: {results.box.mp}, Recall: {results.box.mr}") # mean over all classes print(results.box.p, results.box.r) # per-class precision and recallHope this helps, and happy comparing across YOLO versions! 🚀
akhilesh99sharma
Hello , I tried but was still not able to get these values, could you please help me with that?
Paula DerrengerUltralytics(modifié)Hey there! 😊
Precision and recall are reported by Ultralytics validation, so you don't need to count TP/FP/FN yourself. After
results = model.val(data="path/to/dataset.yaml"), useresults.box.mp(mean precision),results.box.mr(mean recall), andresults.box.p/results.box.rfor per-class values.If you need them computed from raw counts, precision = TP / (TP + FP) and recall = TP / (TP + FN), where the counts come from matching predictions to ground-truth boxes at an IoU threshold.
Hope this helps! Let me know if there's anything else I can do for you. Happy modeling! 🚀
akhilesh99sharma
Hello, I tried doing it but was not able to do so. I get the predictions json file in the val folder but don't know how to compare it with the labels to get TP, FP etc. Can you please help me with that? I need to compare results of YOLOv6 with v8, v9 but I am not getting precision and recall values in v6 , I get average precision and average recall
Paula DerrengerUltralytics(modifié)@akhilesh99sharma hey there! 🌞
You can get precision and recall directly from validation without processing the predictions JSON yourself. After
results = model.val(data="path/to/dataset.yaml"), useresults.box.mp(mean precision),results.box.mr(mean recall), andresults.box.p/results.box.rfor per-class values.If you still need TP, FP and FN counts from the saved predictions JSON, you will have to match predicted boxes to ground-truth boxes per image using an IoU threshold. The confusion matrix saved in the run folder (
confusion_matrix.png, ormodel.val(plots=True)) also shows these counts per class.For comparing across YOLO versions, run each model with consistent settings on your custom dataset and read the same metrics from each.
I hope this simplifies the process for you! 🚀 Let me know if you need further assistance.