Cadre de détection d'objets Darknet et YOLO
Logos !darknet et hank.ai
Darknet est un framework de réseau neuronal open source principalement écrit en C et CUDA.
YOLO (You Only Look Once) est un système de détection d'objets en temps réel 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 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.
Darknet V3 (« Jazz »), sorti en octobre 2024, peut traiter 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.
Rejoignez le serveur Discord Darknet/YOLO pour obtenir de l'aide ou des discussions : https://discord.gg/zSq8rtW
La version CPU de Darknet/YOLO fonctionne sur divers appareils, notamment Raspberry Pi, des serveurs cloud et Colab, des ordinateurs de bureau, des ordinateurs portables et des 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 Darknet 2.x incluent :
Réécriture des étapes de build pour une build unifiée basée sur CMake sur Windows et Linux.
Conversion de la base de code pour utiliser le compilateur C++.
Amélioration de la visualisation chart.png pendant la formation.
Corrections de bugs et optimisations des performances, principalement axées sur la réduction du temps de formation.
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-nous savoir si vous rencontrez des commandes manquantes.
Les principaux changements apportés à Darknet 3.x incluent :
Suppression de nombreuses commandes anciennes et non maintenues.
Optimisations significatives des performances pour la formation et l'inférence.
Modification de l'ancienne API C, nécessitant des modifications mineures pour les applications utilisant l'API Darknet d'origine. Consultez la documentation API mise à jour ici : https://darknetcv.ai/api/api.html
Introduction d'une nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
Nouvelles applications et exemples de code dans le répertoire 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, qui peuvent être trouvées 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 divers emplacements, y compris ce référentiel :
YOLOv2 (novembre 2016)
YOLOv2-minuscule
YOLOv2-complet
YOLOv3 (mai 2018)
YOLOv3-minuscule
YOLOv3-complet
YOLOv4 (mai 2020)
YOLOv4-minuscule
YOLOv4-complet
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 :
`
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
`
N'oubliez pas que vous êtes encouragé à 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.
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 pour démontrer des tâches telles que 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
Tutoriel de construction Darknet pour Linux
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
`
3. Créez un répertoire de build et exécutez CMake :
`bash
mkdir construire
construction de CD
cmake -DCMAKEBUILDTYPE=Version ..
`
4. Créez le Darknet :
`bash
faire -j4
`
5. Facultatif : installez CUDA ou CUDA+cuDNN
Si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer soit CUDA, soit CUDA+cuDNN. Cela permettra à Darknet d'utiliser votre GPU pour un traitement d'image et vidéo plus rapide.
- 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.
Important : si vous installez CUDA ou CUDA+cuDNN après avoir créé Darknet, vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction et réexécuter cmake pour vous assurer que CMake peut trouver les fichiers nécessaires.
Remarque : Darknet peut fonctionner sans CUDA, mais si vous souhaitez former un réseau personnalisé, CUDA ou CUDA+cuDNN est requis.
6. Packagez et installez Darknet :
`bash
faire un paquet
sudo dpkg -i darknet-VERSION.deb
`
Important : si vous utilisez une ancienne version de CMake, vous devrez peut-être la mettre à niveau avant d'exécuter la commande cmake. Mettez à niveau CMake sur Ubuntu en utilisant :
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Utilisateurs avancés :
- Si vous souhaitez créer un fichier d'installation RPM au lieu d'un fichier DEB, modifiez les deux lignes suivantes dans CM_package.cmake avant d'exécuter make package :
`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 de votre distribution. Par exemple, sur les systèmes basés sur Debian comme Ubuntu :
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
- L'installation du package .deb copiera les fichiers suivants :
- /usr/bin/darknet : L'exécutable Darknet.
- /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/... : Emplacement de tous les modèles .cfg.
- Vous avez maintenant terminé ! Darknet a été construit et installé dans /usr/bin/. Exécutez la version darknet à partir de la CLI pour confirmer l'installation.
Méthode Windows CMake
Ces instructions supposent une toute nouvelle installation de Windows 11 22H2.
1. Installez le logiciel requis :
`PowerShell
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 le menu "Démarrer de Windows" et exécutez "Visual Studio Installer".
- Cliquez sur "Modifier".
- Sélectionnez "Développement Desktop avec C++".
- Cliquez sur « Modifier » en bas à droite puis sur « Oui ».
3. Installez Microsoft VCPKG :
- Ouvrez 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.
- 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.
- Exécutez les commandes suivantes :
`PowerShell
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
`
- Soyez patient lors de cette dernière étape car l'exécution peut être longue. Il doit télécharger et construire beaucoup de choses.
- Utilisateurs avancés : notez qu'il existe de nombreux autres modules optionnels que vous souhaiterez peut-être ajouter lors de la création d'OpenCV. Exécutez .vcpkg.exe search opencv pour voir la liste complète.
4. Facultatif : installez CUDA ou CUDA+cuDNN
Si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer soit CUDA, soit CUDA+cuDNN. Cela permettra à Darknet d'utiliser votre GPU pour un traitement d'image et vidéo plus rapide.
- 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.
Important : si vous installez CUDA ou CUDA+cuDNN après avoir créé Darknet, vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction et réexécuter cmake pour vous assurer que CMake peut trouver les fichiers nécessaires.
Remarque : Darknet peut fonctionner sans CUDA, mais si vous souhaitez former un réseau personnalisé, CUDA ou CUDA+cuDNN est requis.
5. Clonez Darknet et construisez-le :
`PowerShell
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
`
Important:
- Installation de CUDA : CUDA doit être installé après Visual Studio. Si vous mettez à niveau Visual Studio, n'oubliez pas de réinstaller CUDA.
- DLL manquantes : si vous rencontrez des erreurs concernant des DLL CUDA ou cuDNN manquantes (par exemple, cublas64_12.dll), copiez manuellement les fichiers CUDA .dll dans le même répertoire de sortie que darknet.exe. Par exemple:
`PowerShell
copier "C:Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Ceci est un exemple ; vérifiez la version de CUDA que vous utilisez et ajustez le chemin en conséquence.)
- Réexécutez msbuild.exe : après avoir copié les fichiers .dll, réexécutez la dernière commande msbuild.exe pour générer le package d'installation NSIS :
`PowerShell
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
- Utilisateurs avancés : notez que la sortie de la commande cmake est un fichier de solution Visual Studio normal (darknet.sln). Si vous utilisez régulièrement l'interface graphique de Visual Studio au lieu de msbuild.exe, vous pouvez ignorer les étapes de ligne de commande et charger le projet Darknet dans Visual Studio.
- Vous devriez maintenant avoir un fichier que vous pouvez exécuter : C:srcDarknetbuildsrc-cliReleasedarknet.exe. Exécutez ceci pour tester : version C:srcDarknetbuildsrc-cliReleasedarknet.exe.
6. Installez Darknet :
- Exécutez l'assistant d'installation NSIS créé à la dernière étape. Recherchez le fichier darknet-VERSION.exe dans le répertoire de construction. Par exemple:
`
darknet-2.0.31-win64.exe
`
- Le package d'installation NSIS :
- Créez un répertoire appelé Darknet, par exemple 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.
- Vous avez maintenant terminé ! Une fois l'assistant d'installation terminé, Darknet aura été installé dans C:Program FilesDarknet. Exécutez ceci pour tester : version C:Program FilesDarknetbindarknet.exe.
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, pensez également à la CLI du projet DarkHelp, qui propose une CLI alternative à Darknet/YOLO avec des fonctionnalités avancées non disponibles directement dans Darknet. Vous pouvez utiliser à la fois la CLI Darknet et la CLI DarkHelp.
Pour la plupart des commandes ci-dessous, 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 télécharger un réseau pré-entraîné depuis Internet. Voici des exemples d'ensembles de données pré-entraînés :
LEGO Gears (pour trouver des objets dans une image)
Rolodex (pour rechercher du texte dans une image)
MSCOCO (détection d'objets standard de classe 80)
Commandes à exécuter :
Obtenez de l'aide :
`bash
aide sur le darknet
`
Vérifiez la version :
`bash
version darknet
`
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
`
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
`
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
`
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
`
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
`
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
`
Exécuté sur un GPU spécifique :
V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4
`
Vérification de la précision du réseau neuronal :
`bash
Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...
`
Exemple de sortie :
`
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 .8377 0.8513 0.9046 0.0954 2 vélo 89.0912 570 124 104 3548 0.9475 0.0525 0.8457 0.8213 0.9715 0.0285 3 personne 76,7937 7072 1727 2574 27523 0,8894 0,1106 0,7332 0,8037 0,9145 0,0855 4 plusieurs véhicules 64,3089 1068 509 733 11288 0,9087 0,0913 0,593 0 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 feu 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
`
Vérification de la précision mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
Recalcul des ancres :
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. Cependant, si vous souhaitez utiliser l'ancienne version dans Darknet :
`bash
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
Former un nouveau réseau :
`bash
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
(Voir aussi la section Formation ci-dessous)
Entraînement
Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :
Comment dois-je configurer mes fichiers et répertoires ?
Quel fichier de configuration dois-je utiliser ?
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 est d'utiliser DarkMark, qui crée tous les fichiers Darknet nécessaires. C'est 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 :
- Choisissez un dossier pour stocker vos fichiers. Pour cet exemple, nous allons créer un réseau de neurones pour détecter les animaux, le répertoire sera donc ~/nn/animals/.
2. Copiez un fichier de configuration Darknet :
- Copiez un fichier de configuration Darknet comme modèle. Par exemple, utilisez cfg/yolov4-tiny.cfg. Placez-le dans le dossier que vous avez créé. Maintenant, vous devriez avoir ~/nn/animals/animals.cfg.
3. Créez un fichier texte animaux.names :
- Créez un fichier texte animaux.names dans le même dossier que le fichier de configuration. Vous avez maintenant ~/nn/animals/animals.names.
4. Modifiez le fichier animaux.names :
- Editez le fichier animaux.names à l'aide d'un éditeur de texte. Répertoriez les classes que vous souhaitez détecter, avec exactement une entrée par ligne, sans ligne vide ni commentaire. Pour cet exemple, le fichier .names contiendra quatre lignes :
`
chien
chat
oiseau
cheval
`
5. Créez un fichier texte animaux.data :
- Créez un fichier texte animaux.data dans le même dossier. Pour cet exemple, le fichier .data contiendra :
`
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
`
6. Créez un dossier pour les images et les annotations :
- Créez un dossier pour stocker vos images et annotations. Par exemple, cela pourrait être ~/nn/animals/dataset.
- Chaque image nécessitera un fichier .txt correspondant décrivant les annotations de cette image. Le format de ces fichiers d'annotations .txt est très spécifique. Vous ne pouvez pas les créer à la main, car chaque annotation nécessite les coordonnées exactes. Utilisez DarkMark ou un logiciel similaire pour annoter vos images. Le format d'annotation YOLO est décrit dans la FAQ Darknet/YOLO.
7. Créez des fichiers texte « train » et « valide » :
- Créez les fichiers texte "train" et "valide" nommés dans le fichier .data.
- Ces deux fichiers texte doivent lister toutes les images que Darknet utilisera pour la formation et la validation (pour le calcul de mAP%).
- Chaque ligne doit contenir exactement un chemin d'image et un nom de fichier. Vous pouvez utiliser des chemins relatifs ou absolus.
8. Modifiez le fichier .cfg :
- Utilisez un éditeur de texte pour modifier votre fichier .cfg :
- Assurez-vous que batch=64.
- Subdivisions : En fonction des dimensions du réseau et de la mémoire GPU, vous devrez peut-être ajuster les subdivisions. Commencez par subdivisions=1 et référez-vous à la FAQ Darknet/YOLO si cela ne fonctionne pas.
- Maxbatches : définissez une bonne valeur de départ pour maxbatches à 2000 fois le nombre de classes. Pour cet exemple, nous avons 4 animaux, donc max_batches=8000.
- Étapes : définissez les étapes sur 80 % et 90 % de max_batches. Dans ce cas, nous utiliserions steps=6400,7200.
- Largeur et Hauteur : Ce sont les dimensions du réseau. La FAQ Darknet/YOLO explique comment calculer la meilleure taille.
- Classes : recherchez toutes les instances de classes=... et mettez-la à jour avec le nombre de classes dans votre fichier .names. Dans cet exemple, nous utiliserions classes=4.
- Filtres : recherchez toutes les instances de filters=... dans les sections [convolutionnelles] avant chaque section [yolo]. La valeur à utiliser est (numberofclasses + 5) 3. Pour cet exemple, (4 + 5) 3 = 27. Nous utiliserions donc filters=27 sur les lignes appropriées.
9. Commencez la formation :
- Accédez au répertoire ~/nn/animals/ :
`bash
cd ~/nn/animaux/
`
- Exécutez la commande suivante pour démarrer l'entraînement :
`bash
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. Vous pouvez suivre la progression de l'entraînement en observant le fichier chart.png. Reportez-vous à la FAQ Darknet/YOLO pour connaître les paramètres supplémentaires que vous souhaiterez peut-être utiliser pendant la formation.
- Si vous souhaitez des informations de formation plus détaillées, ajoutez le paramètre --verbose :
`bash
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
Autres outils et liens
DarkMark : pour gérer vos projets Darknet/YOLO, annoter des images, vérifier les annotations et générer des fichiers pour la formation avec 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 adaptée aux applications commerciales.
FAQ Darknet/YOLO : une ressource complète pour répondre à vos questions.
Chaîne YouTube de Stéphane : De nombreux tutoriels et exemples de vidéos.
Serveur Discord Darknet/YOLO : rejoignez la communauté 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() pendant la formation (il en reste d'autres obscurs).
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 de Windows.
Prise en charge de Python fixe.
Construction de la bibliothèque darknet.
Étiquettes réactivées sur les prédictions (code "alphabet").
Code CUDA/GPU réactivé.
CUDNN réactivé.
Réactivation de la 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 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.
Activation des builds hors source.
Sortie améliorée du numéro de version.
Implémentation d'optimisations de performances liées à la formation (en cours).
Implémentation d'optimisations de performances liées à l'inférence (en cours).
Passage par référence utilisé lorsque cela est possible.
Fichiers .hpp nettoyés.
Réécriture de darknet.h.
Évité de convertir cv::Mat en void*, en l'utilisant comme un objet C++ approprié.
Cohérence fixe ou améliorée dans l’utilisation de la structure d’image interne.
Correction des versions 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).
Correction de l'API Python dans la V3.
Prise en charge améliorée de Python. (Des développeurs Python sont-ils prêts à aider ?)
Objectifs à court terme
Remplacez printf() par std::cout (en cours).
Étudiez la prise en charge des anciennes caméras Zed.
Améliorer et rendre l'analyse en ligne de commande plus cohérente (en cours).
Objectifs à moyen terme
Supprimez tout le code char* et remplacez-le par std::string.
Évitez de masquer 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 des canaux thermiques).
Poursuivre le 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.
Ajoutez des cadres de délimitation pivotés ou un support "d'angle".
Implémenter des points clés/squelettes.
Ajouter des cartes thermiques (en cours).
Mettre en œuvre la segmentation.
