Cadre de détection d'objets Darknet et YOLO
Darknet est un framework de réseau neuronal open source conçu en C, C++ et CUDA. Il sert de base à YOLO (You Only Look Once), un système de détection d'objets en temps réel de pointe réputé pour sa rapidité et sa précision.
Découvrez comment Hank.ai renforce la communauté Darknet/YOLO : [lien vers le blog Hank.ai]
Explorez le site officiel Darknet/YOLO : [lien vers le site Web Darknet]
Plongez dans la FAQ complète Darknet/YOLO : [lien vers la FAQ]
Rejoignez la dynamique communauté Darknet/YOLO sur Discord : [lien vers le serveur Discord]
Papiers
1. YOLOv7 : [lien vers l'article]
2. Scaled-YOLOv4 : [lien vers l'article]
3. YOLOv4 : [lien vers l'article]
4. YOLOv3 : [lien vers l'article]
Informations générales
Le framework Darknet/YOLO continue de dominer les autres frameworks et versions YOLO en termes de vitesse et de précision. Sa nature open source et son absence totale de frais de licence permettent une intégration transparente dans les projets et produits commerciaux existants.
Darknet V3 (« Jazz »), sorti en octobre 2024, atteint des performances remarquables, traitant les vidéos de l'ensemble de données LEGO à une vitesse incroyable de 1 000 FPS à l'aide d'un GPU NVIDIA RTX 3090. Cela se traduit par un temps de traitement inférieur à 1 milliseconde par image vidéo.
Rejoignez le serveur Discord actif Darknet/YOLO sur [lien vers le serveur Discord] pour obtenir de l'aide, des discussions et un apprentissage collaboratif.
Darknet/YOLO s'adresse à une large gamme d'appareils, du Raspberry Pi aux plates-formes de formation haut de gamme, prenant en charge les versions CPU et GPU. La version GPU nécessite un GPU compatible CUDA de NVIDIA.
Darknet/YOLO est compatible avec les systèmes d'exploitation Linux, Windows et Mac. Trouvez les instructions de construction détaillées ci-dessous.
Version Darknet
L’outil Darknet original, développé par Joseph Redmon entre 2013 et 2017, n’avait pas de numéro de version. Nous désignons cette version comme 0.x.
Alexey Bochkovskiy a continué à maintenir le populaire référentiel Darknet de 2017 à 2021, toujours sans numéro de version. Nous appelons cela la version 1.x.
Le référentiel Darknet, sponsorisé par Hank.ai et maintenu par Stéphane Charette depuis 2023, a introduit la commande « version ». Entre 2023 et fin 2024, il a rendu la version 2.x « OAK ».
Les objectifs de développement étaient de minimiser les perturbations des fonctionnalités existantes tout en nous familiarisant avec la base de code. Les principales améliorations comprennent :
Processus de build unifié : étapes de build réécrites pour un processus de build cohérent basé sur CMake sous Windows et Linux.
Base de code C++ : conversion de la base de code pour exploiter le compilateur C++.
Graphique d'entraînement amélioré : visualisation chart.png améliorée pendant l'entraînement.
Corrections de bugs et optimisations : améliorations liées aux performances, axées sur la réduction du temps de formation.
La dernière branche de cette base de code est la version 2.1, résidant dans la branche "v2".
La phase suivante de développement a commencé à la mi-2024 et a culminé avec la sortie en octobre 2024 de la version 3.x « JAZZ ».
Vous pouvez toujours accéder à la branche "v2" précédente pour exécuter des commandes à partir de ces versions. Veuillez nous informer si vous rencontrez des commandes manquantes et nous étudierons leur réintégration.
Les changements importants dans Darknet V3 incluent :
Suppression de commandes : suppression des commandes obsolètes et rarement utilisées.
Optimisations des performances : améliorations des performances d’entraînement et d’inférence.
Modification de l'API C héritée : Modification de l'API C héritée ; les applications utilisant l'API Darknet d'origine peuvent nécessiter des ajustements mineurs.
Nouvelle API C/C++ : Introduction d'une nouvelle API Darknet V3 C et C++.
Exemple de code mis à jour : inclusion de nouvelles applications et d'exemples de code dans le répertoire "src-examples".
Pour des informations détaillées sur la nouvelle API : [lien vers la documentation de l'API Darknet V3]
Explorez l'exemple de code mis à jour : [lien vers les fichiers de l'API Darknet V3]
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 comprend 80 classes, facilement identifiables dans le fichier texte "cfg/coco.names".
Au-delà de MSCOCO, Darknet/YOLO fournit des pondérations pré-entraînées pour des ensembles de données plus simples comme LEGO Gears et Rolodex, vous permettant d'expérimenter divers scénarios. Reportez-vous à la FAQ Darknet/YOLO pour plus de détails.
Les poids pré-entraînés MSCOCO sont accessibles à partir de plusieurs sources, y compris ce référentiel :
YOLOv2 (novembre 2016) :
YOLOv2-tiny : [lien vers les poids]
YOLOv2-full : [lien vers les poids]
YOLOv3 (mai 2018) :
YOLOv3-tiny : [lien vers les poids]
YOLOv3-full : [lien vers les poids]
YOLOv4 (mai 2020) :
YOLOv4-tiny : [lien vers les poids]
YOLOv4-full : [lien vers les poids]
YOLOv7 (août 2022) :
YOLOv7-tiny : [lien vers les poids]
YOLOv7-full : [lien vers les poids]
Ces poids pré-entraînés sont principalement destinés à des fins de démonstration. 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 la formation de vos propres réseaux est encouragée. MSCOCO sert avant tout de benchmark pour confirmer le bon fonctionnement de votre installation.
Bâtiment
Les différentes méthodes de build utilisées avant 2023 ont été regroupées en une seule solution unifiée. Darknet s'appuie sur C++ 17 ou version ultérieure, OpenCV et utilise CMake pour générer les fichiers de projet nécessaires.
Construire, installer et exécuter Darknet/YOLO ne nécessite pas d'expertise en C++, comme conduire une voiture sans être mécanicien.
Google Colab
Les instructions de Google Colab sont identiques aux instructions de Linux. Plusieurs notebooks Jupyter présentent diverses tâches, telles que la formation d'un nouveau réseau.
Explorez les notebooks dans le sous-répertoire « colab » ou suivez les instructions Linux ci-dessous.
Méthode Linux CMake
Tutoriel de construction Darknet pour Linux
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).
Vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
N'oubliez pas de reconstruire Darknet.
Darknet peut fonctionner sans lui, mais si vous souhaitez former un réseau personnalisé, CUDA ou CUDA+cuDNN est requis.
1. Installez les prérequis :
`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 :
`bash
mkdir buildcd construire
`
4. Configurez CMake :
`bash
cmake -DCMAKEBUILDTYPE=Version ..
`
5. Créez le Darknet :
`bash
faire -j4
`
6. Forfait Darknet :
`bash
emballer
`
7. Installez le package :
`bash
sudo dpkg -i darknet-VERSION.deb
`
Si vous utilisez une ancienne version de CMake, vous devrez mettre à niveau CMake avant de pouvoir exécuter la commande cmake ci-dessus. La mise à niveau de CMake sur Ubuntu peut être effectuée avec les commandes suivantes :
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Si vous utilisez bash comme shell de commande, vous souhaiterez redémarrer votre shell à ce stade. Si vous utilisez du poisson, il doit immédiatement suivre le nouveau chemin.
Utilisateurs avancés :
Si vous préférez un package d'installation RPM au lieu d'un fichier DEB, modifiez les lignes correspondantes dans "CM_package.cmake". Avant d'exécuter "make -j4 package", ajustez ces lignes :
`cmake
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
`
Pour les distributions comme Centos et OpenSUSE, modifiez ces lignes comme suit :
`cmake
ENSEMBLE (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Installez le package construit à l'aide du gestionnaire de packages de votre distribution. Pour 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 principal de Darknet. Exécutez la « version darknet » à partir de la CLI pour confirmer la réussite de l’installation.
/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/... : stocke tous les modèles .cfg.
Félicitations! Darknet a été construit et installé dans /usr/bin/. Exécutez la "version darknet" pour vérifier l'installation.
Si vous n'avez pas /usr/bin/darknet, cela signifie que vous l'avez seulement construit, pas installé. Assurez-vous d'installer le fichier .deb ou .rpm comme décrit ci-dessus.
Méthode Windows CMake
Ces instructions supposent une toute nouvelle installation de Windows 11 22H2.
1. Installez les prérequis à l'aide de Winget :
`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 sur « Oui ».
3. Installez Microsoft VCPKG :
- Une fois l'installation terminée, 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, cela entraînerait des problèmes !
- Utilisateurs avancés : au lieu d'utiliser l'invite de commande du développeur, vous pouvez exécuter une invite de commande normale ou SSH sur l'appareil et exécuter manuellement "Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".
4. Installez OpenCV à l'aide de VCPKG :
`bash
CDC:
mkdir c:srccd c:src
clone git https://github.com/microsoft/vcpkgcd vcpkg
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 pendant cette étape car le téléchargement et la création de dépendances peuvent prendre beaucoup de temps.
Utilisateurs avancés :
- Notez qu'il existe de nombreux autres modules facultatifs 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.
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).
Vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
N'oubliez pas de reconstruire Darknet.
Darknet peut fonctionner sans lui, 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.
2. 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.
3. Vérifiez l'installation de CUDA :
Après avoir installé CUDA, assurez-vous de pouvoir exécuter nvcc.exe et nvidia-smi.exe. Vous devrez peut-être ajuster votre variable PATH.
4. Intégrez cuDNN :
Décompressez l'archive cuDNN téléchargée et copiez les répertoires "bin", "include" et "lib" dans C:Program FilesNVIDIA GPU Computing ToolkitCUDA[version]. Vous devrez peut-être écraser les fichiers existants.
5. Installez CUDA après Visual Studio :
- CUDA doit être installé après Visual Studio. Si vous mettez à niveau Visual Studio, n'oubliez pas de réinstaller CUDA.
6. Clonez Darknet et construisez :
`bash
cdc:src
clone git https://github.com/hank-ai/darknet.gitcd darknet
mkdir buildcd construire
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. Gérez les DLL CUDA/cuDNN manquantes :
- Si vous rencontrez des erreurs concernant des DLL CUDA ou cuDNN manquantes (par exemple, cublas64_12.dll), copiez manuellement les fichiers CUDA .dll pertinents dans le même répertoire que darknet.exe. Par exemple:
`bash
copier "C:Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Ceci est un exemple. Vérifiez votre version CUDA et exécutez la commande appropriée.)
- Réexécutez la dernière commande msbuild.exe pour générer le package d'installation NSIS.
Utilisateurs avancés :
Le résultat de la commande cmake est un fichier de solution Visual Studio standard (Darknet.sln). Si vous préférez utiliser l'interface graphique de Visual Studio au lieu de msbuild.exe pour la création, vous pouvez charger le projet Darknet dans Visual Studio et ignorer les étapes de ligne de commande.
Vous devriez maintenant avoir l'exécutable C:srcDarknetbuildsrc-cliReleasedarknet.exe. Exécutez la version C:srcDarknetbuildsrc-cliReleasedarknet.exe pour tester l'installation.
Pour installer Darknet correctement, y compris les bibliothèques, les fichiers d'inclusion et les DLL nécessaires, exécutez l'assistant d'installation NSIS créé à la dernière étape. Localisez le fichier darknet-VERSION.exe dans le répertoire de construction, par exemple darknet-2.0.31-win64.exe.
Le package d'installation de 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 (par exemple, à partir d'OpenCV).
Installez les fichiers Darknet .dll, .lib et .h nécessaires pour utiliser darknet.dll à partir d'autres applications.
Installez les fichiers modèles .cfg.
Vous avez maintenant terminé ! Une fois l'assistant d'installation terminé, Darknet sera installé dans C:Program FilesDarknet. Exécutez la version C:Program FilesDarknetbindarknet.exe pour vérifier l'installation.
Si vous n'avez pas C:/Program Files/darknet/bin/darknet.exe, cela indique que vous l'avez seulement construit, pas installé. Assurez-vous de parcourir chaque panneau de l'assistant d'installation NSIS comme décrit précédemment.
Utiliser le Darknet
CLI
Il ne s'agit pas d'une liste exhaustive de toutes les commandes prises en charge par Darknet.
En plus de la CLI Darknet, notons la CLI du projet DarkHelp, qui propose une interface alternative pour Darknet/YOLO. Il comprend plusieurs fonctionnalités avancées non directement disponibles dans Darknet. Vous pouvez utiliser simultanément la CLI Darknet et la CLI DarkHelp ; ils ne s’excluent pas mutuellement.
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 neuronal pré-entraîné à partir de ressources accessibles au public. Voici quelques exemples :
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)
Voici quelques exemples de commandes et leur utilisation :
Commandes de base :
Aide:
`bash
aide sur le darknet
`
Version:
`bash
version darknet
`
Prédiction d'images :
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
`
Entrée webcam :
V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -c 0
`
V3 :
`bash
darknet08display_webcam animaux
`
Enregistrement des 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 :
carte:
`bash
Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...
`
- Cette commande affichera la précision moyenne (AP) pour chaque classe de l'ensemble de données.
mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
- Cette commande calcule le mAP à un seuil IoU de 0,75.
Calcul des ancres :
La meilleure pratique pour le recalcul des ancres consiste à utiliser DarkMark, car il exécute 100 calculs consécutifs et sélectionne les ancres optimales. Cependant, vous pouvez utiliser l’ancienne méthode Darknet :
`bash
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
Former un nouveau réseau :
Formation de base :
`bash
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
- Les meilleurs poids seront enregistrés sous le nom cats_best.weights et la progression de l'entraînement est visible dans chart.png.
Formation verbeuse :
`bash
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
- Cette commande fournit des informations plus détaillées pendant l'entraînement.
Entraînement
Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :
Configuration des fichiers et répertoires : [lien vers la section FAQ]
Choisir le bon fichier de configuration : [lien vers la section FAQ]
Commande de formation : [lien vers la section FAQ]
Le moyen le plus simple d’annoter et de former consiste à utiliser DarkMark pour créer tous les fichiers Darknet nécessaires. Il s’agit de l’approche recommandée pour former un nouveau réseau neuronal.
Configuration manuelle de l'entraînement :
1. Créer un dossier : Créez un nouveau dossier pour stocker vos fichiers de formation. Par exemple, ~/nn/animaux/.
2. Copiez le fichier de configuration : Copiez un fichier de configuration Darknet comme modèle (par exemple, cfg/yolov4-tiny.cfg) dans votre dossier. Vous avez maintenant ~/nn/animaux/animaux.cfg.
3. Créez le fichier .names : Créez un fichier texte animaux.names dans le même dossier.
- Modifiez le fichier pour lister les classes que vous souhaitez détecter. Chaque classe doit être sur une ligne distincte, sans lignes vides ni commentaires. Par exemple:
`
chien
chat
oiseau
cheval
`
4. Créez le fichier .data : Créez un fichier texte animaux.data dans le même dossier.
- Le fichier .data définit les ensembles de données de formation et de validation, les noms de classe et le répertoire 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 le dossier d'images et d'annotations : créez un dossier (par exemple, ~/nn/animals/dataset) pour stocker vos images et annotations.
- Chaque image nécessite un fichier .txt correspondant contenant des annotations. Le format des annotations est spécifique ; il ne peut pas être créé manuellement. Utilisez DarkMark ou un logiciel similaire pour annoter les images.
- Le format d'annotation YOLO est expliqué dans la FAQ Darknet/YOLO.
6. Créez les fichiers « train » et « valide » : Créez les fichiers texte « train » et « valide » mentionnés dans le fichier .data.
- Ces fichiers répertorient les images utilisées respectivement pour la formation et la validation. Chaque image doit être sur une ligne distincte. Vous pouvez utiliser des chemins relatifs ou absolus.
7. Modifiez le fichier de configuration :
- Ouvrez votre fichier .cfg avec un éditeur de texte et effectuez les ajustements suivants :
- batch=64 : Cette valeur est généralement correcte.
- subdivisions : Commencez par subdivisions=1. Vous devrez peut-être augmenter cette valeur en fonction de la mémoire de votre GPU et des dimensions du réseau. Consultez la FAQ Darknet/YOLO pour obtenir des conseils.
- maxbatches : définissez ceci sur 2000 * nombre de classes. Par exemple, avec 4 classes, maxbatches=8000.
- étapes : définissez ceci sur 80 % et 90 % des lots maximum. Par exemple, avec maxbatches=8000, steps=6400,7200.
- largeur et hauteur : Ce sont les dimensions du réseau. Consultez la FAQ Darknet/YOLO pour obtenir des conseils sur le calcul des dimensions.
- classes : modifiez la ligne classes=... pour qu'elle corresponde au nombre de classes dans votre fichier .names (dans cet exemple, classes=4).
- filters : Modifiez la ligne filters=... dans chaque section [convolutionnelle] avant chaque section [yolo]. La valeur est calculée comme suit : (nombre de classes + 5) * 3. Par exemple, avec 4 classes, filtres = 27.
8. Commencez la formation :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
- La formation peut prendre un certain temps. Les meilleurs poids seront enregistrés sous le nom animaux_best.weights. La progression de la formation est visible dans le fichier chart.png. Reportez-vous à la FAQ Darknet/YOLO pour des paramètres de formation supplémentaires.
- 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 : cet outil vous aide à gérer vos projets Darknet/YOLO, à annoter les images, à vérifier les annotations et à générer les fichiers nécessaires à la formation Darknet.
DarkHelp : une CLI alternative robuste pour Darknet qui fournit des fonctionnalités telles que la mosaïque d'images, le suivi d'objets dans les vidéos et une API C++ robuste pour les applications commerciales.
FAQ Darknet/YOLO : Une ressource précieuse pour répondre à vos questions sur Darknet/YOLO.
Chaîne YouTube de Stéphane : Retrouvez de nombreux tutoriels et exemples de vidéos.
Serveur Discord Darknet/YOLO : rejoignez le serveur pour poser des questions d'assistance et vous connecter avec d'autres utilisateurs Darknet/YOLO.
Feuille de route
Dernière mise à jour : 2024-10-30
Complété
Remplacez qsort() : remplacement de qsort() par std::sort() dans les parties pertinentes de la base de code. (Certaines instances restantes utilisent toujours qsort())
Supprimez les fonctions obsolètes : suppression de check_mistakes, getchar() et system().
Base de code C++ : conversion de Darknet pour utiliser le compilateur C++ (g++ sous Linux, VisualStudio sous Windows).
Construction Windows : correction du processus de construction de Windows.
Prise en charge de Python : correction de l'intégration de Python.
Bibliothèque Darknet : création de la bibliothèque Darknet.
Etiquettes de prédiction : étiquettes réactivées sur les prédictions (le code "alphabet").
Code CUDA/GPU : fonctionnalité CUDA/GPU réactivée.
CUDNN : prise en charge réactivée de CUDNN.
Moitié CUDNN : prise en charge de demi-précision CUDNN réactivée.
Architecture CUDA : suppression du codage en dur de l'architecture CUDA.
Informations sur la version CUDA : informations sur la version CUDA améliorées.
AVX : prise en charge AVX réactivée.
Fichiers hérités supprimés : suppression des anciennes solutions et du Makefile.
Dépendance OpenCV : OpenCV est devenu une dépendance obligatoire.
Bibliothèque pthread : suppression de la dépendance à l'ancienne bibliothèque pthread.
STB : suppression de la dépendance STB.
CMakeLists.txt : réécriture de CMakeLists.txt pour utiliser la nouvelle méthode de détection CUDA.
Suppression des fichiers obsolètes : suppression de l'ancien code "alphabet" et suppression des plus de 700 images dans les données/étiquettes.
Construction hors source : constructions hors source activées.
Numéro de version : affichage du numéro de version amélioré.
Performance de la formation : optimisations des performances pour la formation (tâche en cours).
Performances d'inférence : optimisations des performances pour l'inférence (tâche en cours).
Passage par référence : utilisation du passage par référence lorsque cela est possible pour une efficacité améliorée.
Nettoyage du code : nettoyage des fichiers .hpp.
darknet.h réécrit : mise à jour du fichier d'en-tête de l'API Darknet.
Utilisation de cv::Mat : utilisé cv::Mat comme objet C++ approprié au lieu de le convertir en void*.
Structure de l'image : correction d'incohérences et de problèmes liés à la structure interne de l'image.
Prise en charge de Jetson : correction des versions pour les appareils Jetson basés sur ARM.
- Il est peu probable que les anciens appareils Jetson soient réparés en raison de l'arrêt du support par NVIDIA (pas de compilateur C++17).
- Les nouveaux appareils Jetson Orin fonctionnent.
API Python dans V3 : Correction de l'API Python dans Darknet V3.
Objectifs à court terme
Remplacez printf() : remplacez printf() par std::cout (en cours).
Prise en charge de la caméra Zed : revisitez et améliorez la prise en charge de la caméra Zed.
Analyse de ligne de commande : implémentation d'une analyse de ligne de commande plus robuste et cohérente (en cours).
Objectifs à moyen terme
Supprimer le code de caractère : éliminez tout le code de caractère et remplacez-le par std::string.
Avertissements du compilateur : ne masquez pas les avertissements et corrigez les avertissements du compilateur (en cours).
Utilisation de cv::Mat : Améliorer l'utilisation de cv::Mat au lieu de la structure d'image personnalisée en C (en cours).
Fonctionnalité de liste : remplacez l'ancienne fonctionnalité de liste par std :: vector ou std :: list.
Prise en charge des images en niveaux de gris : correction de la prise en charge des images en niveaux de gris à 1 canal.
Prise en charge des images à canal N : ajoutez la prise en charge des images avec plus de 3 canaux (par exemple, canaux de profondeur ou thermiques).
Nettoyage du code en cours : poursuivez le nettoyage du code en cours (en cours).
Objectifs à long terme
Problèmes CUDA/CUDNN : résolvez les problèmes de compatibilité CUDA/CUDNN sur différents GPU.
Réécrivez le code CUDA/CUDNN : réécrivez le code CUDA/CUDNN pour améliorer les performances et la compatibilité.
Prise en charge des GPU non NVIDIA : étudiez la prise en charge des GPU non NVIDIA.
Cadres de délimitation pivotés : implémentez la prise en charge des cadres de délimitation pivotés ou des informations d'angle.
Points clés/squelettes : ajoutez la prise en charge des points clés et des squelettes.
Heatmaps : implémentation du support des heatmaps (en cours).
Segmentation : ajoutez la prise en charge de la segmentation.
