sst

Cadre de détection d'objets Darknet et YOLO

Logos !darknet et hank.ai

Darknet est un framework de réseau neuronal open source écrit en C, C++ et CUDA. Il constitue une base puissante pour développer et déployer des modèles de détection d'objets.

YOLO (You Only Look Once) est un système de détection d'objets en temps réel de pointe construit sur le framework Darknet. Il excelle en termes de vitesse et de précision, ce qui en fait un choix populaire pour diverses applications.

Vous voulez en savoir plus sur la façon dont Hank.ai contribue à la communauté Darknet/YOLO ?

Explorez le site officiel Darknet/YOLO :

Plongez dans la FAQ complète Darknet/YOLO :

Rejoignez la dynamique communauté Darknet/YOLO Discord :

Papiers

YOLOv7 : lien vers l'article

Scaled-YOLOv4 : lien vers l'article

YOLOv4 : lien vers l'article

YOLOv3 : lien vers l'article

Informations générales

Le framework Darknet/YOLO continue d'être un leader en matière de détection d'objets, offrant systématiquement des avantages en termes de vitesse et de précision par rapport aux autres frameworks et versions de YOLO.

Principales caractéristiques :

1. Open Source et gratuit : ce framework est entièrement gratuit et open source, vous permettant de l'intégrer de manière transparente dans vos projets sans aucune restriction de licence.

2. Hautes performances : Darknet V3 (« Jazz »), sorti en octobre 2024, atteint des performances impressionnantes, atteignant jusqu'à 1 000 FPS pour l'ensemble de données LEGO en utilisant un GPU NVIDIA RTX 3090.

3. Déploiement polyvalent : Darknet/YOLO est compatible avec divers appareils, allant du Raspberry Pi et des serveurs cloud aux ordinateurs de bureau et aux plates-formes de formation haut de gamme.

4. Prise en charge multiplateforme : il est connu pour fonctionner parfaitement sur les systèmes d'exploitation Linux, Windows et Mac.

Besoin d'aide ou souhaitez discuter de Darknet/YOLO ? Rejoignez la communauté dynamique sur Discord :

Version Darknet

L'évolution du Darknet peut être retracée à travers ses versions :

1. Version 0.x (2013-2017) : L'outil Darknet original développé par Joseph Redmon n'avait pas de numéro de version formel.

2. Version 1.x (2017-2021) : Cette version était maintenue par Alexey Bochkovskiy et manquait également de numéro de version.

3. Version 2.x « OAK » (2023) : Le référentiel Darknet, sponsorisé par Hank.ai et maintenu par Stéphane Charette, a introduit une commande de version. Cette version a apporté des améliorations significatives, notamment :

* Étapes de construction unifiées utilisant CMake pour Windows et Linux.

* Conversion vers le compilateur C++.

* Visualisation chart.png améliorée pendant la formation.

* Corrections de bugs et optimisations des performances pour l'efficacité de la formation.

4. Version 2.1 : La branche finale de la base de code v2.

5. Version 3.x « JAZZ » (octobre 2024) : Cette dernière version introduit :

* Optimisations des performances pour la formation et l'inférence.

* Une API C héritée modifiée nécessitant des adaptations mineures pour les applications utilisant l'API Darknet d'origine.

* Une nouvelle API Darknet V3 C et C++.

* Nouvelles applications et exemples de code dans le répertoire src-examples.

Pour des raisons de compatibilité avec les anciennes versions, la branche v2 est toujours accessible. Si vous devez utiliser des commandes spécifiques des versions précédentes, faites-le-nous savoir et nous explorerons la possibilité de les rajouter.

Poids pré-entraînés MSCOCO

Plusieurs versions populaires de YOLO sont pré-entraînées sur l'ensemble de données MSCOCO, offrant un point de départ pratique pour expérimenter le framework. MSCOCO contient 80 classes, répertoriées dans le fichier cfg/coco.names.

Poids pré-entraînés disponibles :

YOLOv2 (novembre 2016) :

* yolov2-tiny.weights

* yolov2-full.weights

YOLOv3 (mai 2018) :

* yolov3-tiny.weights

* yolov3-full.weights

YOLOv4 (mai 2020) :

* yolov4-tiny.weights

* yolov4-full.weights

YOLOv7 (août 2022) :

* yolov7-tiny.weights

* yolov7-full.weights

N'oubliez pas : bien que ces poids pré-entraînés soient utiles pour les démonstrations, il est essentiel de former vos propres réseaux pour des solutions sur mesure. MSCOCO est principalement utilisé pour vérifier que votre configuration fonctionne correctement.

Exemples de commandes utilisant des poids pré-entraînés :

`bash

Afficher les images annotées

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

Afficher des vidéos avec des annotations

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

Utiliser la CLI DarkHelp

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

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

`

Bâtiment

Darknet exploite CMake pour rationaliser le processus de création pour Windows et Linux. Il nécessite C++17 ou un compilateur plus récent, ainsi qu'OpenCV.

Les instructions de construction sont désormais unifiées, remplaçant les méthodes plus anciennes et plus complexes.

Remarque : Si vous rencontrez des problèmes avec d'anciens didacticiels ou des étapes de création qui ne correspondent pas à ce guide, veuillez vous référer aux dernières instructions fournies ici.

Les développeurs de logiciels sont encouragés à visiter https://darknetcv.ai/ pour obtenir un aperçu du fonctionnement interne du framework Darknet/YOLO.

Google Colab

Les instructions de Google Colab reflètent les instructions de Linux.

Explorez les blocs-notes dans le sous-répertoire colab ou suivez les instructions Linux ci-dessous.

Méthode Linux CMake

1. Installez les packages nécessaires :

`bash

sudo apt-get install build-essential git libopencv-dev cmake

`

2. Clonez le référentiel Darknet :

`bash

mkdir ~/src

cd ~/src

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

cd darknet

mkdir construire

construction de CD

`

3. Configurez CMake :

`bash

cmake -DCMAKEBUILDTYPE=Version ..

`

4. Créez le Darknet :

`bash

faire -j4

`

5. Forfait Darknet :

`bash

emballer

sudo dpkg -i darknet-VERSION.deb

`

Facultatif : CUDA ou CUDA+cuDNN pour l'accélération GPU

Visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.

Visitez https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview pour télécharger et installez cuDNN.

Après avoir installé CUDA, assurez-vous que nvcc et nvidia-smi sont accessibles. Vous devrez peut-être ajuster votre variable PATH.

Si vous installez CUDA ou CUDA+cuDNN ultérieurement ou mettez à niveau le logiciel NVIDIA :

Supprimez le fichier CMakeCache.txt dans votre répertoire de construction Darknet pour forcer CMake à retrouver les dépendances.

Reconstruisez le Darknet.

Pour mettre à niveau CMake sur Ubuntu :

`bash

sudo apt-get purge cmake

sudo snap install cmake --classic

`

Utilisateurs avancés :

Pour créer un fichier d'installation RPM au lieu d'un fichier DEB, modifiez le CPACKGENERATOR dans CMpackage.cmake en "RPM".

Pour Centos et OpenSUSE, remplacez CPACK_GENERATOR par « RPM ».

Après avoir créé le package d'installation, utilisez le gestionnaire de packages approprié pour l'installer.

Vérification:

Exécutez la version darknet à partir de la ligne de commande pour confirmer l'installation.

Méthode Windows CMake

1. Installez le logiciel requis :

`bash

Winget installe Git.Git

Winget installe Kitware.CMake

Winget installe nsis.nsis

Winget installe Microsoft.VisualStudio.2022.Community

`

2. Modifiez l'installation de Visual Studio :

* Ouvrez « Programme d'installation de Visual Studio ».

* Cliquez sur "Modifier".

* Sélectionnez « Développement de postes de travail avec C++ ».

* Cliquez sur « Modifier » puis sur « Oui ».

3. Ouvrez l'invite de commande du développeur pour VS 2022 :

* N'utilisez pas PowerShell.

4. Installez Microsoft VCPKG :

`bash

CDC:

mkdir c:src

cdc:src

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

cdvcpkg

bootstrap-vcpkg.bat

.vcpkg.exe installation intégrée

.vcpkg.exe intègre PowerShell

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

`

5. Facultatif : CUDA ou CUDA+cuDNN pour l'accélération GPU

* Installez CUDA en suivant les instructions sur https://developer.nvidia.com/cuda-downloads.

* Installez cuDNN en suivant les instructions sur https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows.

Après l'installation, assurez-vous que nvcc.exe et nvidia-smi.exe sont accessibles. Vous devrez peut-être modifier votre variable PATH.

Si vous installez CUDA ou CUDA+cuDNN ultérieurement ou mettez à niveau le logiciel NVIDIA :

* Assurez-vous que CUDA est installé après Visual Studio.

* Réinstallez CUDA si Visual Studio est mis à niveau.

6. Clonez Darknet et construisez-le :

`bash

cdc:src

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

cd darknet

mkdir construire

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

`

7. Copiez les DLL CUDA (si nécessaire) :

* Si vous obtenez des erreurs concernant des DLL CUDA ou cuDNN manquantes, copiez-les manuellement dans le répertoire de sortie Darknet. Par exemple:

`bash

copier "C: Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease

`

8. Réexécutez la commande msbuild.exe pour générer le package d'installation NSIS :

`bash

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

`

Utilisateurs avancés :

Vous pouvez utiliser le fichier de solution Darknet.sln généré par CMake dans l'interface graphique de Visual Studio au lieu des outils de ligne de commande.

Vérification:

Exécutez la version C:srcDarknetbuildsrc-cliReleasedarknet.exe pour confirmer l'installation.

Pour installer Darknet, exécutez l'assistant d'installation NSIS :

Recherchez le fichier darknet-VERSION.exe dans le répertoire de construction.

Exécutez l'assistant d'installation pour installer l'application CLI, les bibliothèques, les fichiers d'inclusion et les DLL nécessaires.

Utiliser le Darknet

CLI

Remarque : Les commandes suivantes ne sont pas exhaustives.

En plus de la CLI Darknet, envisagez d'utiliser la CLI du projet DarkHelp, qui offre des fonctionnalités alternatives et avancées.

La plupart des commandes nécessitent le fichier .weights ainsi que ses fichiers .names et .cfg correspondants. Vous pouvez former votre propre réseau ou télécharger des modèles pré-entraînés sur Internet. 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 :

1. Aide :

`bash

aide sur le darknet

`

2. Version :

`bash

version darknet

`

3. Prédiction à l’aide d’une image :

*V2 :

`bash

Test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg

`

*V3 :

`bash

darknet02displayannotatedimages cars.cfg image1.jpg

`

* Aide sombre :

`bash

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

`

4. Coordonnées de sortie :

*V2 :

`bash

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

`

*V3 :

`bash

darknet01inference_images animaux chien.jpg

`

* Aide sombre :

`bash

DarkHelp --json animaux.cfg animaux.names animaux_best.weights chien.jpg

`

5. Travailler avec des vidéos :

*V2 :

`bash

Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput test.mp4

`

*V3 :

`bash

darknet03display_videos animaux.cfg test.mp4

`

* Aide sombre :

`bash

DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4

`

6. Lecture depuis une webcam :

*V2 :

`bash

Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -c 0

`

*V3 :

`bash

darknet08display_webcam animaux

`

7. Enregistrer les résultats dans une vidéo :

*V2 :

`bash

Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights test.mp4 -outfilename res.avi

`

*V3 :

`bash

darknet05processvideosmultithreaded animaux.cfg animaux.noms animaux_best.weights test.mp4

`

* Aide sombre :

`bash

DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4

`

8. Sortie JSON :

*V2 :

`bash

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

`

*V3 :

`bash

darknet06imagestojson animaux image1.jpg

`

* Aide sombre :

`bash

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

`

9. Exécuté sur un GPU spécifique :

`bash

Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4

`

10. Vérification de l'exactitude du réseau neuronal :

`bash

Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...

`

11. Calcul de mAP@IoU=75 :

`bash

carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75

`

12. Recalcul des ancres :

`bash

détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256

`

13. Former un nouveau réseau :

`bash

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

`

Entraînement

Pour une annotation et une formation simplifiées, utilisez DarkMark. C'est l'approche recommandée pour créer de nouveaux réseaux de neurones.

Configuration manuelle de l'entraînement (si vous préférez) :

1. Créez un dossier de projet :

* Par exemple, ~/nn/animals/ pour la détection des animaux.

2. Copiez un fichier de configuration Darknet comme modèle :

* Par exemple, cfg/yolov4-tiny.cfg.

3. Créez un fichier texte animaux.names :

* Répertoriez chaque classe, une entrée par ligne, sans lignes vides ni commentaires. Exemple:

`

chien

chat

oiseau

cheval

`

4. Créez un fichier texte animaux.data :

`

cours = 4

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

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

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

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

`

5. Créez un dossier pour les images et les annotations (par exemple, ~/nn/animals/dataset).

* Annotez les images à l'aide de DarkMark ou d'un logiciel similaire. Le format d'annotation YOLO est décrit dans la FAQ Darknet/YOLO.

6. Créez animauxtrain.txt et animauxvalid.txt :

* Répertoriez toutes les images utilisées pour la formation et la validation, une image par ligne.

7. Modifiez le fichier .cfg :

* Définir le lot = 64.

* Ajustez les subdivisions en fonction des dimensions de votre réseau et de la mémoire GPU. Commencez par subdivisions=1.

* Définissez max_batches sur 2 000 fois le nombre de classes (par exemple, 8 000 pour 4 classes).

* Définissez les étapes à 80 % et 90 % de max_batches.

* Ajustez la largeur et la hauteur pour correspondre aux dimensions de réseau souhaitées.

* Modifiez les classes pour refléter le nombre de classes dans votre fichier .names.

Mettre à jour les filtres dans les sections [convolutionnelles] avant chaque section [yolo] : (nombre de classes + 5) 3.

8. Commencez la formation :

`bash

cd ~/nn/animaux/

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

`

Pour plus de détails sur la formation et les paramètres avancés, reportez-vous à la FAQ Darknet/YOLO.

Autres outils et liens

DarkMark : gérez les projets Darknet/YOLO, annotez les images, vérifiez les annotations et générez des fichiers de formation.

DarkHelp : fournit une CLI alternative pour Darknet, permettant la mosaïque d'images, le suivi d'objets et une API C++ robuste pour les applications commerciales.

FAQ Darknet/YOLO : une ressource complète pour répondre à vos questions.

Chaîne YouTube de Stéphane : Accédez à de nombreux tutoriels et exemples de vidéos.

Serveur Discord Darknet/YOLO : connectez-vous avec d'autres utilisateurs pour obtenir de l'aide et des discussions.

Feuille de route

Dernière mise à jour le 30/10/2024 :

Complété:

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

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

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

Correction de la version Windows.

Étiquettes réactivées sur les prédictions (le code "alphabet").

Réactivation du code CUDA/GPU, CUDNN et moitié CUDNN.

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

Informations sur la version CUDA améliorées.

AVX réactivé.

Suppression des anciennes solutions et des Makefiles.

A fait d'OpenCV une dépendance non facultative.

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

STB supprimé.

Réécriture de CMakeLists.txt pour une détection CUDA améliorée.

Suppression de l'ancien code "alphabet" et des images associées.

Implémentation d'une version hors source.

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

Optimisations des performances pendant la formation (en cours).

Optimisations des performances lors de l'inférence (en cours).

Passage par référence implémenté lorsque cela est possible.

Fichiers .hpp nettoyés.

Réécriture de darknet.h.

Élimination du casting de cv::Mat en void et utilisation comme objet C++.

Correction d'incohérences dans la structure interne de l'image.

Version corrigée pour les appareils Jetson basés sur ARM (les nouveaux appareils Jetson Orin fonctionnent).

API Python fixe dans la V3.

Objectifs à court terme :

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

Revisitez l’ancien support de caméra Zed.

Améliorer la cohérence de l'analyse de la ligne de commande (en cours).

Objectifs à moyen terme :

Supprimez tout le code de caractères et remplacez-le par std :: string.

Éliminez les avertissements du compilateur et améliorez la clarté du code (en cours).

Améliorer l'utilisation de cv::Mat au lieu de la structure d'image personnalisée en C (en cours).

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

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

Étendre la prise en charge des images à canal N (N > 3, par exemple, canaux de profondeur ou thermiques).

Nettoyage du code en cours (en cours).

Objectifs à long terme :

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

Réécrivez le code CUDA+cuDNN.

Découvrez la prise en charge des GPU non NVIDIA.

Implémentez des cadres de délimitation pivotés ou un support "d'angle".

Ajoutez des points clés/squelettes.

Introduire des cartes thermiques (en cours).

Explorez la segmentation.

Restez à l'écoute des mises à jour et des contributions au framework Darknet/YOLO !