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.
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 : https://hank.ai/
Annonce de Darknet V3 "Jazz" : https://darknetcv.ai/
Veuillez lire la FAQ Darknet/YOLO : https://darknetcv.ai/faq/
Rejoignez le serveur Discord Darknet/YOLO : https://discord.gg/zSq8rtW
Papiers
1. Papier YOLOv7 : https://arxiv.org/abs/2207.02670
2. Papier à l'échelle-YOLOv4 : https://arxiv.org/abs/2103.05293
3. Papier YOLOv4 : https://arxiv.org/abs/2004.10934
4. Papier YOLOv3 : https://pjreddie.com/media/files/papers/YOLOv3.pdf
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 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. Cela signifie que chaque image vidéo est lue, redimensionnée et traitée par Darknet/YOLO en 1 milliseconde ou moins.
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
1. Version 0.x : L'outil Darknet original écrit par Joseph Redmon en 2013-2017.
2. Version 1.x : Le prochain dépôt Darknet populaire maintenu par Alexey Bochkovskiy entre 2017-2021.
3. Version 2.x « OAK » : Le repo Darknet sponsorisé par Hank.ai et maintenu par Stéphane Charette à partir de 2023. C'était le premier avec une commande de version. Cette version a apporté les modifications suivantes :
- Réécriture des étapes de construction pour une approche CMake unifiée sous Windows et Linux.
- Conversion de la base de code pour utiliser le compilateur C++.
- Amélioration de la génération de chart.png pendant la formation.
- Corrections de bugs et optimisations de performances liées au temps de formation.
4. Version 2.1 : La dernière branche de la base de code 2.x, trouvée dans la branche v2.
5. Version 3.x « JAZZ » : La prochaine phase de développement, sortie en octobre 2024.
- Suppression de nombreuses commandes anciennes et non maintenues.
- Implémentation d'optimisations de performances pour la formation et l'inférence.
- Modification de l'ancienne API C. Les applications utilisant l'API Darknet d'origine nécessiteront des modifications mineures. https://darknetcv.ai/api/api.html
- Introduction d'une nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
- Ajout de nouvelles applications et d'exemples de code dans src-examples : https://darknetcv.ai/api/files.html
Vous pouvez toujours extraire la branche v2 précédente si vous devez exécuter l'une des commandes de cette version. Faites-nous savoir si vous rencontrez des commandes manquantes afin que nous puissions étudier leur ajout.
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, y compris ce référentiel :
YOLOv2 (novembre 2016) :
yolov2-tiny.poids
yolov2-full.poids
YOLOv3 (mai 2018) :
yolov3-tiny.poids
yolov3-full.poids
YOLOv4 (mai 2020) :
yolov4-tiny.poids
yolov4-full.poids
YOLOv7 (août 2022) :
yolov7-tiny.poids
yolov7-full.poids
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 vous êtes encouragés à former vos propres réseaux. MSCOCO est principalement 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, tout comme vous n'avez pas besoin d'être mécanicien pour conduire une voiture.
Google Colab
Les instructions de Google Colab sont les mêmes que celles de Linux. Plusieurs notebooks Jupyter sont disponibles montrant comment effectuer diverses tâches, telles que la formation d'un nouveau réseau.
Consultez les blocs-notes dans le sous-répertoire colab ou suivez les instructions Linux ci-dessous.
Méthode Linux CMake
Tutoriel de construction Darknet pour Linux
1. Facultatif : si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer soit CUDA, soit CUDA+cuDNN à ce stade. S'il est installé, Darknet utilisera votre GPU pour accélérer le traitement des images (et des vidéos).
2. Installez les packages nécessaires :
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
3. Clonez le référentiel Darknet :
`bash
mkdir ~/srccd ~/src
clone git https://github.com/hank-ai/darknet
`
4. Créez un répertoire de construction :
`bash
cd darknet
mkdir construire
construction de CD
`
5. Générez des fichiers de projet CMake :
`bash
cmake -DCMAKEBUILDTYPE=Version ..
`
Important : vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
6. Créez le Darknet :
`bash
créer le paquet -j4
`
7. Installez le package Darknet :
`bash
sudo dpkg -i darknet-VERSION.deb
`
Installation de CUDA et cuDNN (facultatif)
Darknet peut fonctionner sans CUDA, mais si vous souhaitez former un réseau personnalisé, CUDA ou CUDA+cuDNN est requis.
1. Installez CUDA :
- Visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.
- Assurez-vous que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.
2. Installez cuDNN :
- 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échargez et installez cuDNN.
Mise à niveau de CUDA ou cuDNN
Si vous installez CUDA ou CUDA+cuDNN ultérieurement, ou si vous effectuez une mise à niveau vers une version plus récente du logiciel NVIDIA :
1. Reconstruisez Darknet :
- Supprimez le fichier CMakeCache.txt de votre répertoire de build Darknet.
- Exécutez cmake et effectuez à nouveau les commandes.
Utilisateurs avancés
Pour créer un fichier d'installation RPM au lieu d'un fichier DEB, modifiez les lignes pertinentes dans CM_package.cmake avant d'exécuter le package make -j4.
`cmake
# SET (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Pour installer le package d'installation une fois sa construction terminée, utilisez le gestionnaire de packages habituel de votre distribution. Par exemple, sur les systèmes basés sur Debian tels qu'Ubuntu :
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Test de l'installation
Après l'installation, vous devriez avoir les fichiers suivants :
/usr/bin/darknet : L'exécutable Darknet. Exécutez la version darknet à partir de la CLI pour confirmer qu'elle est correctement installée.
/usr/include/darknet.h : L'API Darknet pour les développeurs C, C++ et Python.
/usr/include/darknet_version.h : contient des informations de version pour les développeurs.
/usr/lib/libdarknet.so : la bibliothèque avec laquelle établir des liens pour les développeurs C, C++ et Python.
/opt/darknet/cfg/... : Où tous les modèles .cfg sont stockés.
Exécutez la commande suivante pour tester l'installation :
`bash
version darknet
`
Méthode Windows CMake
Tutoriel de création de Darknet pour Windows
1. Installez le logiciel requis :
- Ouvrez une fenêtre d'invite de commande cmd.exe normale et exécutez les commandes suivantes :
`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 exécutez "Visual Studio Installer".
- Cliquez sur "Modifier".
- Sélectionnez « Développement de postes de travail avec C++ ».
- Cliquez sur « Modifier » en bas à droite, puis cliquez sur « Oui ».
3. Installez Microsoft VCPKG :
- Une fois que tout est téléchargé et installé, cliquez à nouveau 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 !
- Exécutez les commandes suivantes :
`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
`
Important : soyez patient lors de cette dernière étape car son exécution peut prendre beaucoup de temps. Il doit télécharger et construire beaucoup de choses.
4. Facultatif : installez CUDA et cuDNN
- Si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer soit CUDA, soit CUDA+cuDNN à ce stade. S'il est installé, Darknet utilisera votre GPU pour accélérer le traitement des images (et des vidéos).
- Vous devez supprimer le fichier CMakeCache.txt de votre répertoire de build Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
- N'oubliez pas de reconstruire Darknet.
5. Installez CUDA :
- Visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.
- Assurez-vous que vous pouvez exécuter nvcc.exe et nvidia-smi.exe. Vous devrez peut-être modifier votre variable PATH.
6. Installez cuDNN :
- Visitez https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows pour télécharger et installer cuDNN.
- Une fois que vous avez téléchargé cuDNN, décompressez et copiez les répertoires bin, include et lib dans C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[version]/. Vous devrez peut-être écraser certains fichiers.
7. Clonez le référentiel Darknet et construisez :
`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
`
8. Copiez les DLL CUDA (facultatif) :
- Si vous obtenez une erreur concernant certaines DLL CUDA ou cuDNN manquantes, telles que cublas64_12.dll, copiez manuellement les fichiers CUDA .dll dans le même répertoire de sortie que darknet.exe. Par exemple:
`bash
copier "C: Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
9. Réexécutez msbuild.exe pour générer le package d'installation NSIS :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Utilisateurs avancés
Au lieu d'exécuter l'invite de commande du développeur, vous pouvez utiliser une invite de commande normale ou ssh sur l'appareil et exécuter manuellement Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat.
Vous pouvez ajouter de nombreux autres modules optionnels lors de la création d'OpenCV. Exécutez .vcpkg.exe search opencv pour voir la liste complète.
La sortie de la commande cmake est un fichier de solution Visual Studio normal, Darknet.sln. Vous pouvez ignorer la ligne de commande et charger le projet Darknet dans Visual Studio si vous êtes un développeur de logiciels qui utilise régulièrement l'interface graphique de Visual Studio.
Test de l'installation
Vous devriez maintenant avoir le fichier suivant : C:srcDarknetbuildsrc-cliReleasedarknet.exe. Exécutez la commande suivante pour tester l'installation :
`bash
C: version srcDarknetbuildsrc-cliReleasedarknet.exe
`
Pour installer correctement Darknet, les bibliothèques, les fichiers d'inclusion et les DLL nécessaires, exécutez l'assistant d'installation NSIS créé à la dernière étape. Voir le fichier darknet-VERSION.exe dans le répertoire build. Par exemple:
`bash
darknet-2.0.31-win64.exe
`
L'installation du package d'installation NSIS :
Créez un répertoire appelé Darknet, tel que C:Program FilesDarknet.
Installez l'application CLI, darknet.exe et d'autres exemples d'applications.
Installez les fichiers .dll tiers requis, tels que ceux d'OpenCV.
Installez les fichiers Darknet .dll, .lib et .h nécessaires pour utiliser darknet.dll à partir d'une autre application.
Installez les fichiers modèles .cfg.
Exécutez la commande suivante pour tester l'installation après avoir exécuté l'assistant NSIS :
`bash
C:Program FilesDarknetbindarknet.exe version
`
Utiliser le Darknet
CLI
Ce qui suit n'est pas une liste complète de toutes les commandes prises en charge par Darknet.
En plus de la CLI Darknet, notez 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 ; ils 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 former 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 :
LEGO Gears (trouver des objets dans une image)
Rolodex (trouver du texte dans une image)
MSCOCO (détection d'objets standard de classe 80)
Commandes à exécuter
1. Obtenez de l'aide :
`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. 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écution sur un GPU spécifique :
- V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4
`
10. Vérification de la précision 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. Vérification de la précision mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
12. Recalcul des ancres :
- DarkMark : Il est préférable de recalculer les ancres dans DarkMark, car il s'exécute 100 fois consécutives et sélectionne les meilleures ancres parmi toutes celles calculées.
- Darknet : Si vous souhaitez utiliser l'ancienne méthode dans Darknet :
`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 ?
Utilisation de DarkMark pour l'annotation et la formation (recommandé)
Le moyen le plus simple d'annoter et de s'entraîner est d'utiliser DarkMark, qui crée tous les fichiers Darknet nécessaires. Ceci est fortement recommandé pour former un nouveau réseau neuronal.
Configuration manuelle de fichiers pour former un réseau personnalisé
Si vous préférez la configuration manuelle, procédez comme suit :
1. Créez un nouveau dossier :
- Créez un nouveau dossier pour stocker vos fichiers de formation. Par exemple, vous pouvez créer ~/nn/animals/ pour former un réseau à la détection d'animaux.
2. Copiez un modèle de fichier de configuration :
- Copiez l'un des fichiers de configuration Darknet de cfg/ comme modèle. Par exemple, vous pouvez utiliser cfg/yolov4-tiny.cfg. Placez-le dans le dossier que vous avez créé. Vous devriez maintenant avoir ~/nn/animals/animals.cfg.
3. Créez un fichier animaux.names :
- Créez un fichier texte appelé animaux.names dans le même dossier que le fichier de configuration.
4. Modifiez le fichier animaux.names :
- Listez les classes que vous souhaitez détecter, une entrée par ligne, sans lignes vides ni commentaires. Par exemple:
`
chien
chat
oiseau
cheval
`
5. Créez un fichier animaux.data :
- Créez un fichier texte appelé animaux.data dans le même dossier.
- Par exemple, le fichier animaux.data pourrait contenir :
`
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
`
6. Créez un dossier d'ensemble de données :
- Créez un dossier pour stocker vos images et annotations. Par exemple, vous pouvez créer ~/nn/animals/dataset.
7. Annoter les images :
- Chaque image nécessite un fichier .txt correspondant avec des annotations. Le format de ces fichiers .txt est spécifique et nécessite les coordonnées exactes des annotations. Utilisez DarkMark ou un logiciel similaire pour annoter vos images.
8. Créez animauxtrain.txt et animauxvalid.txt :
- Ces fichiers texte répertorient les images utilisées respectivement pour la formation et la validation. Chaque image doit être sur une ligne distincte, avec des chemins relatifs ou absolus.
9. Modifiez le fichier de configuration :
- Ouvrez animaux.cfg avec un éditeur de texte et apportez les modifications suivantes :
- batch=64 : assurez-vous que cette valeur est définie.
- subdivisions : la meilleure valeur à utiliser est 1. Vous devrez peut-être augmenter cette valeur en fonction de la mémoire de votre GPU et des dimensions du réseau.
- maxbatches : définissez cette valeur sur une valeur raisonnable, généralement 2 000 fois le nombre de classes. Pour cet exemple, utilisez maxbatches=8000 (4 classes * 2000).
- étapes : définissez-les sur 80 % et 90 % des lots maximum. Pour cet exemple, utilisez steps=6400,7200 (puisque maxbatches=8000).
- largeur et hauteur : définissez-les selon les dimensions de réseau souhaitées. Consultez la FAQ Darknet/YOLO pour obtenir des conseils sur le choix de la meilleure taille.
- classes : recherchez toutes les instances de cette ligne et modifiez-la pour qu'elle corresponde au nombre de classes dans votre fichier .names (dans cet exemple, classes=4).
- filtres : recherchez toutes les instances de cette ligne dans les sections [convolutionnelles] avant chaque section [yolo]. La valeur à utiliser est (numberofclasses + 5) 3. Pour cet exemple, utilisez filters=27 (4 + 5 3).
10. Commencer la formation :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
11. Suivi des progrès de la formation :
- Sois patient! Les meilleurs poids seront enregistrés sous le nom animaux_best.weights.
- Vous pouvez suivre la progression de l'entraînement 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 pendant l'entraînement.
12. Ajout de verbosité aux résultats de la formation :
`bash
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
Autres outils et liens
DarkMark : pour gérer des projets Darknet/YOLO, annoter des images, vérifier des annotations et générer des fichiers pour la formation Darknet.
DarkHelp : pour une CLI alternative robuste à Darknet, utilisant la mosaïque d'images, le suivi d'objets dans les vidéos et une API C++ robuste qui peut être utilisée dans des applications commerciales.
FAQ Darknet/YOLO : https://darknetcv.ai/faq/
Chaîne YouTube de Stéphane : https://www.youtube.com/channel/UCYQ2k0L3X0c56l9gE2r1RQ
Serveur Discord Darknet/YOLO : https://discord.gg/zSq8rtW
Feuille de route
Dernière mise à jour le 30/10/2024 :
Complété
Remplacement de qsort() par std::sort() lorsqu'il était utilisé pendant la formation (certains obscurs restent).
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.
Correction du support Python.
Bibliothèque Darknet construite.
Étiquettes réactivées sur les prédictions (code "alphabet").
Code CUDA/GPU réactivé.
CUDNN réactivé.
Réactivation de la moitié CUDNN.
Ne codez pas en dur l’architecture CUDA.
Informations sur la version CUDA améliorées.
AVX réactivé.
Suppression des anciennes solutions et du Makefile.
Rendu OpenCV non facultatif.
Suppression de la dépendance à l'ancienne bibliothèque pthread.
STB supprimé.
Réécriture de CMakeLists.txt pour utiliser la nouvelle détection CUDA.
Suppression de l'ancien code "alphabet" et suppression des plus de 700 images dans les données/étiquettes.
Construit hors source.
Sortie améliorée du numéro de version.
Optimisations des performances liées à la formation (tâche continue).
Optimisations des performances liées à l'inférence (tâche en cours).
Passage par référence utilisé lorsque cela est possible.
Fichiers .hpp nettoyés.
Réécriture de darknet.h.
Ne convertissez pas cv::Mat en void* mais utilisez-le comme un objet C++ approprié.
Correction ou cohérence de la manière dont la structure interne de l'image est utilisée.
Version corrigée pour les appareils Jetson basés sur ARM.
- Il est peu probable que les appareils Jetson d'origine soient réparés car ils ne sont plus pris en charge par NVIDIA (pas de compilateur C++17).
- Les nouveaux appareils Jetson Orin fonctionnent.
API Python fixe dans la V3.
Prise en charge améliorée de Python. (Des développeurs Python souhaitent-ils aider ?)
Objectifs à court terme
Remplacez printf() par std::cout (en cours).
Regardez l'ancien support de caméra ZED.
Améliorer et rendre cohérente l'analyse de la ligne de commande (en cours).
Objectifs à moyen terme
Supprimez tout le code char* et remplacez-le par std::string.
Ne masquez pas les avertissements et nettoyez les avertissements du compilateur (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.
Correction de la prise en charge des images en niveaux de gris à 1 canal.
Ajoutez la prise en charge des images à canal N où N > 3 (par exemple, images avec une profondeur supplémentaire ou un canal thermique).
Nettoyage du code en cours (en cours).
Objectifs à long terme
Résolvez les problèmes CUDA/CUDNN avec tous les GPU.
Réécrivez le code CUDA+cuDNN.
Pensez à ajouter la prise en charge des GPU non NVIDIA.
Cadres de délimitation pivotés, ou une sorte de support "d'angle".
Points clés/squelettes.
Cartes thermiques (en cours).
Segmentation.
