rusthw

Cadre de détection d'objets Darknet et YOLO

Darknet est un framework de réseau neuronal open source développé principalement en C et C++, avec prise en charge de l'accélération CUDA.

YOLO (You Only Look Once), un système de détection d'objets en temps réel de pointe, est une implémentation importante dans le cadre Darknet.

En savoir plus sur la façon dont Hank.ai contribue à la communauté Darknet/YOLO :

Annonce de Darknet V3 "Jazz" : https://darknetcv.ai/blog/announcing-darknet-v3-jazz

Site Web Darknet/YOLO : https://darknetcv.ai/

FAQ Darknet/YOLO : https://darknetcv.ai/faq/

Serveur Discord Darknet/YOLO : https://discord.gg/zSq8rtW

Papiers

1. YOLOv7 : https://arxiv.org/abs/2207.02696

2. Mise à l'échelle-YOLOv4 : https://arxiv.org/abs/2102.12725

3. YOLOv4 : https://arxiv.org/abs/2004.10934

4. YOLOv3 : https://pjreddie.com/media/files/papers/YOLOv3.pdf

Informations générales

Le framework Darknet/YOLO maintient sa position comme l'un des systèmes de détection d'objets les plus rapides et les plus précis.

Principaux avantages du Darknet/YOLO :

Gratuit et Open Source : Darknet/YOLO est entièrement open source, permettant une intégration gratuite dans des projets existants, y compris commerciaux.

Hautes performances : Darknet V3 (« Jazz »), sorti en octobre 2024, démontre des performances remarquables, atteignant jusqu'à 1 000 FPS sur l'ensemble de données LEGO avec un GPU NVIDIA RTX 3090.

Polyvalence : la version CPU de Darknet/YOLO peut être déployée sur diverses plates-formes, notamment Raspberry Pi, des serveurs cloud, des ordinateurs de bureau, des ordinateurs portables et de puissantes plates-formes de formation. La version GPU nécessite un GPU NVIDIA compatible CUDA.

Compatibilité multiplateforme : Darknet/YOLO est connu pour fonctionner de manière transparente sous Linux, Windows et Mac.

Gestion des versions Darknet

Darknet 0.x : il s'agit de l'outil Darknet original développé par Joseph Redmon entre 2013 et 2017. Il lui manquait un numéro de version formel.

Darknet 1.x : Cette version a été maintenue par Alexey Bochkovskiy de 2017 à 2021. Il lui manquait également un numéro de version formel.

Darknet 2.x « OAK » : Cette version a été sponsorisée par Hank.ai et maintenue par Stéphane Charette à partir de 2023. Il s'agissait de la première version à introduire une commande de version. Il a renvoyé la version 2.x jusqu'à fin 2024.

Darknet 3.x « JAZZ » : Cette version, sortie en octobre 2024, a marqué une phase de développement importante, introduisant une nouvelle API C et C++, des performances améliorées et de nombreuses corrections de bugs.

Poids pré-entraînés MSCOCO

Diverses versions populaires de YOLO ont été pré-entraînées sur l'ensemble de données MSCOCO. Cet ensemble de données se compose de 80 classes, qui peuvent être trouvées dans le fichier cfg/coco.names.

Poids pré-entraînés disponibles en téléchargement :

1. YOLOv2 (novembre 2016)

* YOLOv2-minuscule

* YOLOv2-complet

2. YOLOv3 (mai 2018)

* YOLOv3-minuscule

* YOLOv3-complet

3. YOLOv4 (mai 2020)

* YOLOv4-minuscule

* YOLOv4-complet

4. YOLOv7 (août 2022)

* YOLOv7-minuscule

* YOLOv7-complet

Exemple d'utilisation :

`

wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights

darknet02displayannotatedimages coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg

darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi

DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg

DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi

`

Remarque : Les poids pré-entraînés MSCOCO sont fournis principalement à des fins de démonstration. La formation de réseaux personnalisés est fortement encouragée, MSCOCO étant généralement utilisé pour vérifier la fonctionnalité du système.

Construire le Darknet

Darknet s'appuie sur C++ 17 ou version ultérieure, OpenCV et utilise CMake pour générer des fichiers de projet.

Processus de construction :

1. Google Colab : les instructions de Google Colab sont les mêmes que celles de Linux. Reportez-vous au sous-répertoire colab pour les notebooks Jupyter présentant des tâches spécifiques.

2. Méthode Linux CMake :

* Prérequis :

* Outils essentiels à la construction : sudo apt-get install build-essential

* Git : sudo apt-get install git

* OpenCV : sudo apt-get install libopencv-dev

* CMake : sudo apt-get install cmake

*Installation :

* Créer des répertoires de travail : mkdir ~/srccd ~/src

* Cloner le dépôt : git clone https://github.com/hank-ai/darknet

* Accédez au répertoire Darknet : cd darknet

* Créez un répertoire de build : mkdir build

* Construire le Darknet :

* construction de CD

* cmake -DCMAKEBUILDTYPE=Version ..

* faire -j4

* emballer

* Installez le package : sudo dpkg -i darknet-VERSION.deb

* Facultatif : installation CUDA/cuDNN

* Téléchargez et installez CUDA depuis https://developer.nvidia.com/cuda-downloads

* Téléchargez et installez cuDNN depuis https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager- aperçu de l'installation

* Assurez-vous que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.

* Si vous installez CUDA ou cuDNN ultérieurement ou si vous effectuez une mise à niveau vers une version plus récente, assurez-vous de reconstruire Darknet après avoir modifié votre environnement.

3. Méthode Windows CMake :

* Prérequis :

* Git : Winget installe Git.Git

* CMake : Winget installe Kitware.CMake

* NSIS : winget installe nsis.nsis

* Visual Studio 2022 Community Edition : installation Winget Microsoft.VisualStudio.2022.Community

* Modifiez l'installation de Visual Studio pour inclure la prise en charge de C++ :

* Ouvrez le programme d'installation de Visual Studio

* Cliquez sur "Modifier"

* Sélectionnez "Développement Desktop avec C++"

* Cliquez sur "Modifier" puis sur "Oui"

*Installation :

* Ouvrez l'invite de commande du développeur pour VS 2022 (pas PowerShell).

* Installez Microsoft VCPKG :

* CDC:

* mkdir c:srccd c:src

* clone git https://github.com/microsoft/vcpkg

* cdvcpkg

* bootstrap-vcpkg.bat .vcpkg.exe intégrer

* installer .vcpkg.exe intégrer powershell.vcpkg.exe installer opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows

* Clonez Darknet et construisez :

*cdc:src

* clone git https://github.com/hank-ai/darknet.git

* cd darknet

* construction mkdir

* construction de CD

* cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..

* msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln

* msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj

* Facultatif : installation CUDA/cuDNN

* Téléchargez et installez CUDA depuis https://developer.nvidia.com/cuda-downloads

* Téléchargez et installez cuDNN depuis https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows

* Décompressez cuDNN et copiez les répertoires bin, include et lib dans C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[version] (en écrasant les fichiers existants si nécessaire).

* Assurez-vous que vous pouvez exécuter nvcc.exe. Vous devrez peut-être modifier votre variable PATH.

Utiliser le Darknet

CLI (interface de ligne de commande)

Utilisation générale : Darknet propose une interface de ligne de commande (CLI) pour interagir avec ses fonctionnalités. Ce n'est pas exhaustif; reportez-vous à la CLI du projet DarkHelp pour des fonctionnalités supplémentaires.

Modèles pré-entraînés : pour la plupart des commandes, vous aurez besoin du fichier .weights ainsi que des fichiers .names et .cfg correspondants. Vous pouvez soit former votre propre réseau (fortement recommandé), soit utiliser des modèles pré-formés disponibles en ligne. Les exemples incluent :

* LEGO Gears (détection d'objets dans les images)

* Rolodex (détection de texte dans les images)

* MSCOCO (détection d'objets standard de classe 80)

Commandes courantes :

Aide : aide sur le darknet

Version : version darknet

Prédiction avec une image :

* V2 : test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg

* V3 : darknet02displayannotatedimages cars.cfg image1.jpg

* DarkHelp : DarkHelp cars.cfg cars_best.weights image1.jpg

Coordonnées de sortie :

* V2 : test du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput dog.jpg

* V3 : darknet01inference_images animaux dog.jpg

* DarkHelp : DarkHelp --json animaux.cfg animaux.names animaux_best.weights dog.jpg

Traitement vidéo :

*V2 :

* Démo du détecteur darknet animal.data animaux.cfg animauxbest.weights -extoutput test.mp4 (prédiction vidéo)

* Démo du détecteur darknet animal.data animaux.cfg animaux_best.weights -c 0 (entrée webcam)

* Démonstration du détecteur darknet cats.data cats.cfg catsbest.weights test.mp4 -outfilename res.avi (Enregistrement des résultats dans la vidéo)

*V3 :

* darknet03display_videos cats.cfg test.mp4 (Prédiction vidéo)

* Animaux darknet08display_webcam (entrée webcam)

* darknet05processvideosmultithreaded animaux.cfg animaux.names animaux_best.weights test.mp4 (Enregistrement des résultats dans la vidéo)

* Aide sombre :

* DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4 (prédiction vidéo)

* DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4 (Enregistrement des résultats dans une vidéo)

Sortie JSON :

* V2 : démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput

* V3 : darknet06imagestojson animaux image1.jpg

* DarkHelp : DarkHelp --json animaux.names animaux.cfg animaux_best.weights image1.jpg

Sélection GPU : démo du détecteur darknet cats.data cats.cfg cats_best.weights -i 1 test.mp4

Évaluation de la précision :

* Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ... (mAP@IoU=50)

* Carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75 (mAP@IoU=75)

Calcul d'ancrage : (Utilisez DarkMark pour un recalcul d'ancrage optimal)

* Calcancres du détecteur Darknet Animals.data -numof_clusters 6 -largeur 320 -hauteur 256

Formation en réseau :

* détecteur darknet -map -dont_show train animaux.data animaux.cfg

Former un nouveau réseau

DarkMark : L'approche recommandée pour l'annotation et la formation consiste à utiliser DarkMark, qui automatise le processus de génération des fichiers Darknet nécessaires.

Configuration manuelle :

1. Créez un répertoire de projet : par exemple, ~/nn/animals/ pour former un réseau de détection d'animaux.

2. Copiez un fichier de configuration : sélectionnez un fichier de configuration modèle dans cfg/ (par exemple, cfg/yolov4-tiny.cfg) et placez-le dans le répertoire de votre projet.

3. Créez un fichier .names : Dans le même répertoire, créez un fichier texte nommé animaux.names. Répertoriez les classes que vous souhaitez détecter, une par ligne, sans lignes vides ni commentaires. Exemple:

`

chien

chat

oiseau

cheval

`

4. Créez un fichier .data : Dans le même répertoire, créez un fichier texte nommé animaux.data. Ce fichier contient des informations sur vos données d'entraînement. Exemple:

`

cours=4

train=/home/username/nn/animals/animals_train.txt

valid=/home/username/nn/animals/animals_valid.txt

noms=/home/username/nn/animaux/animaux.names

sauvegarde=/home/nom d'utilisateur/nn/animaux

`

5. Répertoire des ensembles de données : créez un répertoire pour stocker vos images et les annotations correspondantes (par exemple, ~/nn/animals/dataset). Chaque image nécessitera un fichier .txt associé décrivant les annotations. Ces fichiers .txt doivent suivre un format spécifique et sont mieux générés à l'aide de DarkMark ou d'un logiciel similaire.

6. Fichiers de formation et de validation : créez les fichiers texte « train » et « valide » comme spécifié dans votre fichier .data. Ces fichiers répertorient les images à utiliser respectivement pour la formation et la validation.

7. Modifiez le fichier de configuration :

* Taille du lot : définissez le lot = 64.

* Subdivisions : Commencez par subdivisions=1. Augmentez si nécessaire en fonction de la capacité de mémoire de votre GPU.

Lots maximum : utilisez maxbatches = 2 000 nombres de classes. Dans ce cas, maxbatches=8000.

* Étapes : définissez les étapes sur 80 % et 90 % de max_batches. Exemple : pas =6 400,7 200.

* Largeur et hauteur : ajustez les dimensions du réseau (largeur et hauteur). Reportez-vous à la FAQ Darknet/YOLO pour obtenir des conseils sur la détermination des tailles optimales.

* Classes : mettez à jour classes=... pour correspondre au nombre de classes dans votre fichier .names (dans ce cas, classes=4).

Filtres : ajustez filters=... dans les sections [convolutionnelles] avant chaque section [yolo]. Calculez en utilisant des filtres = (nombre de classes + 5) 3. Dans ce cas, filtres = 27.

8. Démarrez la formation : accédez au répertoire de votre projet et exécutez la commande suivante :

`

détecteur darknet -map -dont_show train animaux.data animaux.cfg

`

* Sortie verbeuse : pour des informations de formation plus détaillées, utilisez --verbose.

* Progression : les meilleurs poids seront enregistrés sous le nom "animals_best.weights" et la progression de l'entraînement pourra être suivie via le fichier chart.png.

Autres outils et liens

DarkMark : pour la gestion de projets Darknet/YOLO, l'annotation d'images, la vérification des annotations et la génération de fichiers de formation.

DarkHelp : une CLI alternative robuste à Darknet, avec des fonctionnalités telles que la mosaïque d'images, le suivi d'objets et une API C++ pour les applications commerciales.

FAQ Darknet/YOLO : https://darknetcv.ai/faq/

Chaîne YouTube de Stéphane Charette : Retrouvez des tutoriels et des exemples de vidéos : https://www.youtube.com/channel/UCOQ-nJ8l6kG3153g09XwY8g

Serveur Discord Darknet/YOLO : https://discord.gg/zSq8rtW

Feuille de route

Dernière mise à jour : 2024-10-30

Complété:

1. Remplacement de qsort() par std::sort() le cas échéant pendant la formation (quelques cas restants).

2. Suppression de check_mistakes, getchar() et system().

3. Conversion de Darknet pour utiliser le compilateur C++ (g++ sous Linux, VisualStudio sous Windows).

4. Correction de la version Windows.

5. Correction du support Python.

6. Bibliothèque Darknet construite.

7. Réactivation des étiquettes sur les prédictions (code "alphabet").

8. Réactivation du code CUDA/GPU.

9. Réactivation de CUDNN.

10. Réactivation de la moitié CUDNN.

11. Suppression de l'architecture CUDA codée en dur.

12. Informations améliorées sur la version CUDA.

13. Réactivation d'AVX.

14. Suppression des anciennes solutions et du Makefile.

15. Rendu OpenCV non facultatif.

16. Suppression de la dépendance à l'ancienne bibliothèque pthread.

17. Suppression du STB.

18. Réécrivez CMakeLists.txt pour utiliser la nouvelle détection CUDA.

19. Suppression de l'ancien code "alphabet" et suppression de plus de 700 images dans les données/étiquettes.

20. Implémentation d'une version hors source.

21. Sortie améliorée du numéro de version.

22. Optimisations des performances liées à la formation (en cours).

23. Optimisations des performances liées à l'inférence (en cours).

24. Passage par référence employé lorsque cela est possible.

25. Fichiers .hpp nettoyés.

26. Réécriture de darknet.h.

27. Utilisé cv::Mat comme objet C++ approprié au lieu de convertir en void*.

28. Correction ou standardisation de la façon dont la structure d'image interne est utilisée.

29. Correction de la version pour les appareils Jetson basés sur ARM (les nouveaux appareils Jetson Orin fonctionnent).

30. API Python améliorée dans la V3.

Objectifs à court terme :

1. Remplacez printf() par std::cout (en cours).

2. Examinez l'ancien support de caméra ZED.

3. Améliorer et standardiser l'analyse des lignes de commande (en cours).

Objectifs à moyen terme :

1. Supprimez tout le code char* et remplacez-le par std::string.

2. Éliminez les avertissements du compilateur et assurez une gestion cohérente des avertissements (en cours).

3. Utilisez cv::Mat plus efficacement au lieu des structures d'images personnalisées en C (en cours).

4. Remplacez l'ancienne fonctionnalité de liste par std :: vector ou std :: list.

5. Correction de la prise en charge des images en niveaux de gris à 1 canal.

6. Ajoutez la prise en charge des images à canal N où N > 3 (par exemple, images avec une profondeur supplémentaire ou un canal thermique).

7. Nettoyage du code en cours (en cours).

Objectifs à long terme :

1. Résolvez les problèmes CUDA/CUDNN avec tous les GPU.

2. Réécrivez le code CUDA+cuDNN.

3. Explorez l'ajout de la prise en charge des GPU non NVIDIA.

4. Implémentez la prise en charge des cadres de délimitation pivotés ou d'un attribut « angle ».

5. Ajoutez la prise en charge des points clés/squelettes.

6. Implémentation de cartes thermiques (en cours).

7. Mettre en œuvre la segmentation.