Cadre de détection d'objets Darknet et YOLO
Darknet est un framework de réseau neuronal open source écrit en C, C++ et CUDA.
YOLO (You Only Look Once) est un système de détection d'objets en temps réel de pointe, qui fonctionne dans le cadre Darknet.
Découvrez comment Hank.ai aide la communauté Darknet/YOLO
Annonce du Darknet V3 "Jazz"
Voir le site Darknet/YOLO
Veuillez lire la FAQ Darknet/YOLO
Rejoignez le serveur discord Darknet/YOLO
Papiers
1. Papier YOLOv7
2. Papier à l'échelle-YOLOv4
3. Papier YOLOv4
4. Papier YOLOv3
Informations générales
Le framework Darknet/YOLO continue d'être à la fois plus rapide et plus précis que les autres frameworks et versions de YOLO.
Ce framework est à la fois entièrement gratuit et open source. Vous pouvez intégrer Darknet/YOLO dans des projets et produits existants – y compris commerciaux – sans licence ni paiement de frais.
Darknet V3 (« Jazz ») sorti en octobre 2024 peut exécuter avec précision les vidéos de l'ensemble de données LEGO jusqu'à 1 000 FPS lors de l'utilisation d'un GPU NVIDIA RTX 3090, ce qui signifie que chaque image vidéo est lue, redimensionnée et traitée par Darknet/YOLO en 1 milliseconde ou moins.
Veuillez rejoindre le serveur Discord Darknet/YOLO si vous avez besoin d'aide ou si vous souhaitez discuter de Darknet/YOLO : https://discord.gg/zSq8rtW
La version CPU de Darknet/YOLO peut fonctionner sur des appareils simples tels que le Raspberry Pi, les serveurs cloud et Colab, les ordinateurs de bureau, les ordinateurs portables et les plates-formes de formation haut de gamme. La version GPU de Darknet/YOLO nécessite un GPU compatible CUDA de NVIDIA.
Darknet/YOLO est connu pour fonctionner sous Linux, Windows et Mac. Voir les instructions de construction ci-dessous.
Version Darknet
L'outil Darknet original écrit par Joseph Redmon en 2013-2017 n'avait pas de numéro de version. Nous considérons cette version 0.x.
Le prochain dépôt Darknet populaire maintenu par Alexey Bochkovskiy entre 2017 et 2021 n'avait pas non plus de numéro de version. Nous considérons cette version 1.x.
Le repo Darknet sponsorisé par Hank.ai et maintenu par Stéphane Charette à partir de 2023 a été le premier doté d'une commande de version. De 2023 à fin 2024, il a renvoyé la version 2.x « OAK ».
L'objectif était d'essayer de briser le moins possible les fonctionnalités existantes tout en se familiarisant avec la base de code.
Les principaux changements dans cette version incluent :
1. Réécriture des étapes de construction pour disposer d'une manière unifiée de créer à l'aide de CMake sous Windows et Linux.
2. Conversion de la base de code pour utiliser le compilateur C++.
3. Chart.png amélioré pendant l'entraînement.
4. Corrections de bugs et optimisations liées aux performances, principalement liées à la réduction du temps nécessaire à la formation d'un réseau.
La dernière branche de cette base de code est la version 2.1 dans la branche v2.
La phase suivante de développement a commencé mi-2024 et a été publiée en octobre 2024. La commande de version renvoie désormais 3.x « JAZZ ».
Vous pouvez toujours effectuer une extraction de la branche v2 précédente si vous devez exécuter l'une de ces commandes. Faites-le-nous savoir afin que nous puissions étudier la réintégration des commandes manquantes.
Les principaux changements dans cette version incluent :
1. Suppression de nombreuses commandes anciennes et non maintenues.
2. De nombreuses optimisations de performances, à la fois lors de l'entraînement et lors de l'inférence.
3. L'API C héritée a été modifiée ; les applications qui utilisent l'API Darknet d'origine nécessiteront des modifications mineures : https://darknetcv.ai/api/api.html
4. Nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
5. Nouvelles applications et exemples de code dans src-examples : https://darknetcv.ai/api/files.html
Poids pré-entraînés MSCOCO
Plusieurs versions populaires de YOLO ont été pré-entraînées pour plus de commodité sur l'ensemble de données MSCOCO. Cet ensemble de données contient 80 classes, visibles dans le fichier texte cfg/coco.names.
Il existe plusieurs autres ensembles de données plus simples et poids pré-entraînés disponibles pour tester Darknet/YOLO, tels que LEGO Gears et Rolodex. Consultez la FAQ Darknet/YOLO pour plus de détails.
Les poids pré-entraînés MSCOCO peuvent être téléchargés à partir de plusieurs emplacements différents et sont également disponibles en téléchargement à partir de ce dépôt :
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
Les poids pré-entraînés MSCOCO sont fournis à des fins de démonstration uniquement. Les fichiers .cfg et .names correspondants pour MSCOCO se trouvent dans le répertoire cfg. Exemples de commandes :
`bash
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
`
Notez que les gens sont censés former leurs propres réseaux. MSCOCO est normalement utilisé pour confirmer que tout fonctionne correctement.
Bâtiment
Les différentes méthodes de construction disponibles dans le passé (avant 2023) ont été fusionnées en une seule solution unifiée. Darknet nécessite C++ 17 ou version ultérieure, OpenCV et utilise CMake pour générer les fichiers de projet nécessaires.
Vous n'avez pas besoin de connaître le C++ pour créer, installer ou exécuter Darknet/YOLO, de la même manière que vous n'avez pas besoin d'être mécanicien pour conduire une voiture.
Méfiez-vous si vous suivez d'anciens didacticiels avec des étapes de construction plus compliquées, ou si vous construisez des étapes qui ne correspondent pas à ce qui est contenu dans ce fichier Lisez-moi. Les nouvelles étapes de construction décrites ci-dessous ont commencé en août 2023.
Les développeurs de logiciels sont encouragés à visiter https://darknetcv.ai/ pour obtenir des informations sur les composants internes du framework de détection d'objets Darknet/YOLO.
Google Colab
Les instructions de Google Colab sont les mêmes que celles de Linux. Plusieurs notebooks Jupyter sont disponibles montrant comment effectuer certaines tâches, comme la formation d'un nouveau réseau.
Consultez les notebooks dans le sous-répertoire colab et/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 ~/srccd ~/src
git clone https://github.com/hank-ai/darknetcd darknet
`
3. Créez un répertoire de build et exécutez CMake :
`bash
mkdir buildcd construire
cmake -DCMAKEBUILDTYPE=Version ..
`
4. Créez le Darknet :
`bash
faire -j4
`
5. Packagez et installez Darknet :
`bash
emballer
sudo dpkg -i darknet-VERSION.deb
`
6. Vérifiez l'installation :
`bash
version darknet
`
Méthode Windows CMake
1. Installez les packages nécessaires :
`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 :
- Cliquez sur le menu "Démarrer de Windows" et lancez "Visual Studio Installer".
- Cliquez sur Modifier.
- Sélectionnez Développement de bureau avec C++.
- Cliquez sur Modifier dans le coin inférieur droit, puis cliquez sur Oui.
3. Ouvrez l'invite de commande du développeur pour VS 2022 :
- Cliquez sur le menu « Démarrer de Windows » et sélectionnez Invite de commandes du développeur pour VS 2022. N'utilisez pas PowerShell pour ces étapes.
4. Installez Microsoft VCPKG :
`bash
cd c: mkdir c: srccd c: src git clone https://github.com/microsoft/vcpkgcd vcpkg
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
`
5. Cloner le référentiel Darknet :
`bash
cdc:src
clone git https://github.com/hank-ai/darknet.gitcd darknet
`
6. Créez un répertoire de build et exécutez CMake :
`bash
mkdir buildcd construire
cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
7. Créez le Darknet :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
`
8. Générez le package d'installation NSIS :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
9. Exécutez l'assistant d'installation NSIS :
- Ouvrez le fichier darknet-VERSION.exe dans le répertoire build. Par exemple : darknet-2.0.31-win64.exe.
10. Vérifiez l'installation :
`bash
C:Program FilesDarknetbindarknet.exe version
`
Utiliser le Darknet
CLI
Ce qui suit n'est pas la liste complète de toutes les commandes prises en charge par Darknet.
En plus de la CLI Darknet, notez également la CLI du projet DarkHelp qui fournit une CLI alternative à Darknet/YOLO. La CLI DarkHelp possède également plusieurs fonctionnalités avancées qui ne sont pas disponibles directement dans Darknet. Vous pouvez utiliser à la fois la CLI Darknet et la CLI DarkHelp ensemble, elles ne s'excluent pas mutuellement.
Pour la plupart des commandes présentées ci-dessous, vous aurez besoin du fichier .weights avec les fichiers .names et .cfg correspondants. Vous pouvez soit entraîner votre propre réseau (fortement recommandé !), soit télécharger un réseau neuronal que quelqu'un a déjà formé et mis à disposition gratuitement sur Internet. Voici des exemples d'ensembles de données pré-entraînés :
1. LEGO Gears (trouver des objets dans une image)
2. Rolodex (trouver du texte dans une image)
3. MSCOCO (détection d'objets standard de classe 80)
Les commandes à exécuter incluent :
1. Répertoriez quelques commandes et options possibles à exécuter :
`bash
aide sur le darknet
`
2. Vérifiez la version :
`bash
version darknet
`
3. Prédire à 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. Enregistrez 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.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. Pour vérifier l'exactitude du réseau neuronal :
`bash
Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...
`
Sortir:
`
Id Nom AvgPrecision TP FN FP TN Précision ErrorRate Précision Rappel Spécificité FalsePosRate
-- ---- ------------ ------ ------ ------ ------ -------- --------- --------- ------ ----------- ------------
0 véhicule 91,2495 32648 3903 5826 65129 0,9095 0,0905 0,8486 0,8932 0,9179 0,0821
1 moto 80.4499 2936 513 569 5393 0,8850 0,1150 0,8377 0,8513 0,9046 0,0954
2 vélos 89,0912 570 124 104 3548 0,9475 0,0525 0,8457 0,8213 0,9715 0,0285
3 personnes 76,7937 7072 1727 2574 27523 0,8894 0,1106 0,7332 0,8037 0,9145 0,0855
4 nombreux véhicules 64,3089 1068 509 733 11288 0,9087 0,0913 0,5930 0,6772 0,9390 0,0610
5 feu vert 86,8118 1969 239 510 4116 0,8904 0,1096 0,7943 0,8918 0,8898 0,1102
6 lumière jaune 82,0390 126 38 30 1239 0,9525 0,0475 0,8077 0,7683 0,9764 0,0236
7 feu rouge 94.1033 3449 217 451 4643 0.9237 0.0763 0.8844 0.9408 0.9115 0.0885
`
11. Pour vérifier l'exactitude mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
12. Recalcul des ancres :
- Mieux fait dans DarkMark.
- Dans le Darknet, utilisez :
`bash
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
13. Former un nouveau réseau :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
Entraînement
Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :
1. Comment dois-je configurer mes fichiers et répertoires ?
2. Quel fichier de configuration dois-je utiliser ?
3. Quelle commande dois-je utiliser lors de la formation de mon propre réseau ?
Le moyen le plus simple d’annoter et de s’entraîner consiste à utiliser DarkMark pour créer tous les fichiers Darknet nécessaires. C'est certainement la méthode recommandée pour former un nouveau réseau neuronal.
Si vous préférez configurer manuellement les différents fichiers pour entraîner un réseau personnalisé :
1. Créez un nouveau dossier pour votre projet :
- Pour cet exemple, un réseau de neurones sera créé pour détecter les animaux, donc le répertoire suivant est créé : ~/nn/animals/.
2. Copiez un fichier de configuration Darknet comme modèle :
- Par exemple, copiez cfg/yolov4-tiny.cfg dans le dossier du projet. Vous aurez maintenant ~/nn/animals/animals.cfg.
3. Créez un fichier texte animaux.names :
- Ce fichier contiendra la liste des classes que vous souhaitez détecter, une par ligne. Par exemple:
`
chien
chat
oiseau
cheval
`
4. Créez un fichier texte animaux.data :
- Ce fichier précise les chemins d'accès aux données de formation et de validation, ainsi que les noms et répertoires de sauvegarde. Par 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. Créez un dossier pour vos images et annotations :
- Par exemple, cela pourrait être ~/nn/animals/dataset. Chaque image aura besoin d'un fichier .txt correspondant qui décrit les annotations de cette image. Le format des fichiers d'annotations .txt est très spécifique. Vous ne pouvez pas créer ces fichiers manuellement puisque chaque annotation doit contenir les coordonnées exactes de l'annotation. Consultez DarkMark ou un autre logiciel similaire pour annoter vos images. Le format d'annotation YOLO est décrit dans la FAQ Darknet/YOLO.
6. Créez les fichiers texte « train » et « valide » :
- Ces deux fichiers texte doivent lister individuellement toutes les images que Darknet doit utiliser pour l'entraînement et pour la validation lors du calcul du mAP%. Exactement une image par ligne. Le chemin et les noms de fichiers peuvent être relatifs ou absolus.
7. Modifiez votre fichier .cfg :
- lot : réglé sur 64.
- subdivisions : commencez par 1. Consultez la FAQ Darknet/YOLO si vous devez ajuster cela en fonction de la disponibilité de la mémoire.
- maxbatches : Une bonne valeur de départ est 2000 numberof_classes. Pour cet exemple, nous avons 4 animaux, donc 4 2000 = 8000.
- étapes : définies sur 80 % et 90 % des lots maximum. Pour cet exemple, nous utiliserions steps=6400,7200 puisque maxbatches a été défini sur 8000.
- largeur et hauteur : Ce sont les dimensions du réseau. La FAQ Darknet/YOLO explique comment calculer la meilleure taille à utiliser.
- classes : Modifiez cette ligne avec le nombre de classes dans votre fichier .names. Pour cet exemple, nous utiliserions classes=4.
- filters : Dans la section [convolutional] avant chaque section [yolo], modifiez filters=... avec la valeur (numberofclasses + 5) * 3. Pour cet exemple, nous utiliserions filters=27.
8. Commencez la formation :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
Sois patient. Les meilleurs poids seront enregistrés sous le nom animaux_best.weights. La progression de la formation peut être observée en visualisant le fichier chart.png. Consultez la FAQ Darknet/YOLO pour connaître les paramètres supplémentaires que vous souhaiterez peut-être utiliser lors de la formation d'un nouveau réseau.
Si vous souhaitez voir plus de détails pendant l'entraînement, ajoutez le paramètre --verbose. Par exemple:
`bash
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
Autres outils et liens
1. DarkMark : Pour gérer vos projets Darknet/YOLO, annotez les images, vérifiez vos annotations et générez les fichiers nécessaires pour vous entraîner avec Darknet.
2. DarkHelp : pour une CLI alternative robuste à Darknet, pour utiliser la mosaïque d'images, pour le suivi d'objets dans vos vidéos ou pour une API C++ robuste qui peut facilement être utilisée dans des applications commerciales.
3. FAQ Darknet/YOLO : pour vous aider à répondre à vos questions.
4. Chaîne YouTube de Stéphane : Pour des tutoriels et des exemples de vidéos.
5. Serveur Discord Darknet/YOLO : Pour discuter avec d'autres utilisateurs Darknet/YOLO et demander de l'aide.
Feuille de route
Dernière mise à jour le 30/10/2024 :
Complété
1. Remplacez qsort() par std::sort() lorsqu'il est utilisé pendant la formation.
2. Débarrassez-vous de check_mistakes, getchar() et system().
3. Convertissez Darknet pour utiliser le compilateur C++.
4. Corrigez la version de Windows.
5. Corrigez la prise en charge de Python.
6. Créez une bibliothèque darknet.
7. Réactivez les étiquettes sur les prédictions (code "alphabet").
8. Réactivez le code CUDA/GPU.
9. Réactivez CUDNN.
10. Réactivez la moitié CUDNN.
11. Ne codez pas en dur l'architecture CUDA.
12. Meilleures informations sur la version CUDA.
13. Réactivez AVX.
14. Supprimez les anciennes solutions et Makefile.
15. Rendre OpenCV non facultatif.
16. Supprimez la dépendance à l'ancienne bibliothèque pthread.
17. Retirez le STB.
18. Réécrivez CMakeLists.txt pour utiliser la nouvelle détection CUDA.
19. Supprimez l'ancien code "alphabet" et supprimez les plus de 700 images dans les données/étiquettes.
20. Construisez hors source.
21. Avoir une meilleure sortie du numéro de version.
22. Optimisations des performances liées à la formation (tâche continue).
23. Optimisations des performances liées à l'inférence (tâche en cours).
24. Passage par référence lorsque cela est possible.
25. Nettoyez les fichiers .hpp.
26. Réécrivez darknet.h.
27. Ne convertissez pas cv::Mat en void* mais utilisez-le comme un objet C++ approprié.
28. Corrigez ou soyez cohérent dans la façon dont la structure interne de l'image est utilisée.
29. Correction de la version pour les appareils Jetson basés sur ARM.
30. Les nouveaux appareils Jetson Orin fonctionnent.
31. Corrigez l'API Python dans la V3.
Objectifs à court terme
1. Remplacez printf() par std::cout.
2. Recherchez l'ancien support de caméra Zed.
3. Analyse de ligne de commande meilleure et plus cohérente.
Objectifs à moyen terme
1. Supprimez tout le code char* et remplacez-le par std::string.
2. Ne masquez pas les avertissements et nettoyez les avertissements du compilateur.
3. Meilleure utilisation de cv::Mat au lieu de la structure d'image personnalisée en C.
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.
7. Nettoyage du code 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. Envisagez d'ajouter la prise en charge des GPU non NVIDIA.
4. Cadres de délimitation pivotés, ou une sorte de support "d'angle".
5. Points clés/squelettes.
6. Cartes thermiques.
7. Segmentation.
