YOLOv12 : un outil open source pour la détection de cibles en temps réel dans les images et les vidéos

Introduction générale

YOLOv12 est un projet open source développé par l'utilisateur de GitHub sunsmarterjie, qui se concentre sur la technologie de détection de cibles en temps réel. Le projet est basé sur la série de cadres YOLO (You Only Look Once), l'introduction du mécanisme d'attention pour optimiser la performance des réseaux neuronaux convolutionnels traditionnels (CNN), non seulement dans la détection de la précision améliorée, mais maintient également une vitesse d'inférence élevée . YOLOv12 pour une variété de scénarios , tels que les systèmes de surveillance , la conduite automatisée et l'analyse d'image , etc, pour fournir Nano, Small , pour fournir des modèles de taille nano, petite, moyenne, grande et extra-grande afin de répondre aux différentes exigences en matière de puissance de calcul et d'application. Le projet est placé sous licence GNU AGPL-3.0, ce qui permet aux utilisateurs de télécharger gratuitement le code et de le personnaliser en fonction de leurs besoins. L'équipe de développeurs comprend des chercheurs de l'université de Buffalo et de l'Académie chinoise des sciences. La documentation technique et le guide d'installation sont détaillés, ce qui permet aux utilisateurs de démarrer rapidement.

Liste des fonctions

• Détection efficace des cibles en temps réelSur un GPU T4, YOLOv12-N atteint 40,6% mAP avec une latence d'inférence de seulement 1,64ms.
• Sélection multi-modèleCinq modèles (de Nano à Extra-Large) sont disponibles pour s'adapter à une large gamme d'environnements matériels, des appareils à faible consommation d'énergie aux serveurs à haute performance.
• Optimisation du mécanisme d'attentionIntroduction des modules Area Attention et R-ELAN pour améliorer la précision de la détection et réduire la complexité des calculs.
• Modèle ExportSupport pour l'exportation de modèles d'entraînement au format ONNX ou TensorRT pour un déploiement facile dans les environnements de production.
• Entraînement personnalisé des ensembles de donnéesLes utilisateurs peuvent former des modèles avec leurs propres ensembles de données, adaptés à des tâches spécifiques de détection de cibles.
• Aide à la visualisation: Intégration d'outils de supervision pour faciliter la présentation des résultats des tests et l'évaluation des performances.

Utiliser l'aide

Processus d'installation

YOLOv12 n'a actuellement pas de paquetage PyPI autonome et doit être installé à partir de la source GitHub. Vous trouverez ci-dessous les étapes détaillées de l'installation pour Linux (les utilisateurs de Windows ou Mac devront adapter leur configuration d'environnement) :

1. Préparation de l'environnement
   • Assurez-vous que Python 3.11 ou une version ultérieure est installé sur votre système.
   • Installer Git :sudo apt install git(exemple Ubuntu).
   • Facultatif : installez le pilote GPU NVIDIA et CUDA (version 11.8 ou supérieure recommandée) pour accélérer l'entraînement et l'inférence.
2. entrepôt de clones
   Téléchargez le dépôt YOLOv12 localement en exécutant la commande suivante dans un terminal :

   git clone https://github.com/sunsmarterjie/yolov12.git
   cd yolov12

3. Créer un environnement virtuel
   Utilisez Conda ou venv pour créer des environnements Python distincts et éviter les conflits de dépendances :

   conda create -n yolov12 python=3.11
   conda activate yolov12
   

4. Installation des dépendances
   Installer les dépendances nécessaires au projet, y compris PyTorch, flash-attn, supervision, etc :

   wget https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.3/flash_attn-2.7.3+cu11torch2.2cxx11abiFALSE-cp311-cp311-linux_x86_64.whl
   pip install flash_attn-2.7.3+cu11torch2.2cxx11abiFALSE-cp311-cp311-linux_x86_64.whl
   pip install -r requirements.txt
   pip install -e .
   

5. Vérifier l'installation
   Exécutez la commande suivante pour vérifier que l'environnement est correctement configuré :

   python -c "from ultralytics import YOLO; print('YOLOv12 installed successfully')"
   

Utilisation

Formation de modèles personnalisés

YOLOv12 permet aux utilisateurs de s'entraîner avec leurs propres ensembles de données, adaptés aux tâches de détection de cibles spécifiques à une scène. Les étapes de l'opération sont les suivantes :

1. Préparation du jeu de données
   • Les données doivent être au format YOLO (contenant des dossiers d'images et d'étiquettes, des étiquettes sous forme de fichiers .txt, étiquetées avec les catégories de cibles et les coordonnées de la boîte de délimitation).
   • établir data.yaml en spécifiant l'ensemble d'entraînement, le chemin de l'ensemble de validation et le nom de la catégorie. Exemple :

     train: ./dataset/train/images
     val: ./dataset/val/images
     nc: 2  # 类别数量
     names: ['cat', 'dog']  # 类别名称
     

2. Charger le modèle et l'entraîner
   Utilisez un script Python pour charger le modèle pré-entraîné et commencer l'entraînement :

   from ultralytics import YOLO
   model = YOLO('yolov12s.pt')  # 可选 n/s/m/l/x 模型
   results = model.train(data='path/to/data.yaml', epochs=250, imgsz=640)
   

   • epochsNombre de cycles d'entraînement : plus de 250 cycles sont recommandés pour obtenir de meilleurs résultats.
   • imgsz: Saisissez la taille de l'image, par défaut 640x640.
3. Voir les résultats de la formation
   Une fois la formation terminée, les résultats sont enregistrés dans le fichier runs/detect/train y compris les poids des modèles (best.pt) et les matrices d'obscurcissement, etc. Exécutez le code suivant pour voir la matrice de confusion :

   from IPython.display import Image
   Image(filename='runs/detect/train/confusion_matrix.png', width=600)
   

Raisonnement et tests

Le modèle formé peut être utilisé pour la détection de cibles dans des images ou des vidéos :

1. Détection d'une seule image

   model = YOLO('path/to/best.pt')
   results = model('test.jpg')
   results.show()  # 显示检测结果
   results.save()  # 保存结果到 runs/detect/predict
   

2. Détection vidéo
   Utilisez la ligne de commande pour traiter les fichiers vidéo :

   python app.py --source 'video.mp4' --model 'path/to/best.pt'
   

3. Évaluation des performances
   L'ensemble de validation est évalué pour obtenir des mesures telles que mAP :

   results = model.val(data='path/to/data.yaml')
   print(results.box.map)  # 输出 mAP@0.5:0.95
   

Modèle Export

Exporter le modèle dans un format utilisable par l'environnement de production :

model.export(format='onnx', half=True)  # 导出为 ONNX，支持 FP16 加速

Les modèles exportés peuvent être déployés sur des périphériques ou des serveurs.

Fonction en vedette Fonctionnement

• Optimisation du mécanisme d'attention
  Le module "Area Attention" de YOLOv12 n'a pas besoin d'être configuré manuellement, mais optimise automatiquement l'extraction des caractéristiques pendant l'entraînement et l'inférence afin d'améliorer la détection des petites cibles. Les utilisateurs n'ont qu'à choisir la bonne taille de modèle (par exemple, Nano pour les appareils de faible puissance) pour bénéficier de la précision accrue de cette fonction.
• détection en temps réel
  L'inférence est extrêmement rapide lorsqu'elle est exécutée sur des GPU compatibles avec CUDA. Par exemple, l'exécution du modèle YOLOv12-N sur un GPU T4 permet de détecter une seule image en seulement 1,64 ms, et les utilisateurs peuvent visualiser la trame de détection et le niveau de confiance en temps réel à l'aide de l'outil de supervision :

  results = model('image.jpg')
  results.plot()  # 显示带标注的图像
  

• Adaptation multi-scène
  En ajustant la taille du modèle et les données d'entraînement, YOLOv12 peut être facilement adapté à différentes tâches. Par exemple, la détection de piétons dans un système de surveillance ou la reconnaissance de véhicules et de panneaux de signalisation dans le cadre de la conduite autonome.