Cadre de détection d'objets Darknet et YOLO
Downcodes小编 Liste mise à jour des trackers BitTorrent publics
Listes
Ces listes sont automatiquement mises à jour quotidiennement. Dernière mise à jour le 31/10/2024 :
Rencontrez-vous des problèmes DNS ? Ces listes contiennent les mêmes trackers mais avec des adresses IP au lieu de domaines :
Remarques
Contribuer
Contact
ngosang [@] hotmail [.es]
Outils tiers
Outils en ligne tiers
exemple:
Licence Apache-2.0
Table des matières
Cadre de détection d'objets Darknet et YOLO
Papiers
Informations générales
Version Darknet
Poids pré-entraînés MSCOCO
Bâtiment
Google Colab
Méthode Linux CMake
Méthode Windows CMake
Utiliser le Darknet
CLI
Entraînement
Autres outils et liens
Feuille de route
Objectifs à court terme
Objectifs à moyen terme
Objectifs à long terme
Cadre de détection d'objets Darknet et YOLO
Darknet est un framework de réseau neuronal open source, principalement é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 fonctionnant dans le cadre Darknet.
Découvrez comment Hank.ai soutient la communauté Darknet/YOLO.
Explorez le site Web Darknet/YOLO.
Consultez la FAQ Darknet/YOLO pour obtenir des réponses aux questions courantes.
Rejoignez le serveur Discord Darknet/YOLO pour des discussions et de l'assistance.
Papiers
1. Papier YOLOv7
2. Papier à l'échelle-YOLOv4
3. Papier YOLOv4
4. Papier YOLOv3
Informations générales
Le framework Darknet/YOLO surpasse systématiquement les autres frameworks et versions YOLO en termes de vitesse et de précision.
Ce framework est entièrement gratuit et open source. Vous pouvez intégrer Darknet/YOLO dans vos projets et produits, même commerciaux, sans avoir besoin de licence ni payer de frais.
Darknet V3 (« Jazz »), sorti en octobre 2024, peut exécuter efficacement les vidéos de l'ensemble de données LEGO jusqu'à 1 000 FPS à l'aide d'un GPU NVIDIA RTX 3090. Cela signifie que Darknet/YOLO peut traiter chaque image vidéo (lecture, redimensionnement et traitement) en 1 milliseconde ou moins.
Rejoignez le serveur Discord Darknet/YOLO si vous avez besoin d'aide ou souhaitez discuter de Darknet/YOLO : 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 nécessite un GPU NVIDIA compatible CUDA.
Darknet/YOLO est connu pour être compatible avec Linux, Windows et Mac. Reportez-vous aux instructions de construction ci-dessous pour plus de détails.
Version Darknet
L’outil Darknet original développé par Joseph Redmon entre 2013 et 2017 n’avait pas de numéro de version. Nous considérons cette version 0.x.
Le référentiel Darknet populaire qui a suivi, maintenu par Alexey Bochkovskiy de 2017 à 2021, n'avait pas non plus de numéro de version. Nous considérons cette version 1.x.
Le référentiel Darknet sponsorisé par Hank.ai et maintenu par Stéphane Charette depuis 2023 a été le premier à inclure une commande de version. Il a renvoyé la version 2.x « OAK » de 2023 à fin 2024.
L'objectif principal était de minimiser les perturbations des fonctionnalités existantes tout en nous familiarisant avec la base de code.
Changements clés :
Construction unifiée : étapes de construction réécrites pour établir une méthode unique et cohérente à l'aide de CMake pour Windows et Linux.
Migration C++ : conversion de la base de code pour utiliser le compilateur C++.
Graphique amélioré : amélioration de la visualisation chart.png pendant la formation.
Corrections de bugs et optimisations : correction de nombreux bugs et mise en œuvre d'optimisations de 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, située dans la branche v2.
La prochaine étape de développement a commencé mi-2024 et a abouti à la sortie de la version 3.x « JAZZ » en octobre 2024.
Améliorations clés du Darknet V3 (« Jazz ») :
Performances : optimisations significatives des performances pendant la formation et l'inférence.
Modifications de l'API : modification de l'ancienne API C. Les applications utilisant l'API Darknet d'origine nécessiteront des ajustements mineurs. Voir : https://darknetcv.ai/api/api.html
Nouvelle API : introduction d'une nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
Exemples mis à jour : ajout de nouvelles applications et d'exemples de code dans le répertoire src-examples : https://darknetcv.ai/api/files.html
Vous pouvez toujours revenir à la branche v2 précédente si vous devez exécuter des commandes spécifiques. Veuillez nous informer si vous rencontrez des commandes manquantes afin que nous puissions envisager de les réintégrer.
Suppressions de clés Darknet V3 ("Jazz") :
Commandes obsolètes : suppression de nombreuses commandes obsolètes et non maintenues.
Poids pré-entraînés MSCOCO
Pour plus de commodité, plusieurs versions populaires de YOLO ont été pré-entraînées sur l'ensemble de données MSCOCO. Cet ensemble de données comprend 80 classes, que l'on retrouve dans le fichier texte cfg/coco.names.
Au-delà de MSCOCO, divers autres ensembles de données plus simples et poids pré-entraînés sont 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 sources, 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 uniquement à des fins de démonstration. Les fichiers .cfg et .names correspondants pour MSCOCO résident 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
`
N'oubliez pas que les utilisateurs sont encouragés à former leurs propres réseaux. MSCOCO est principalement utilisé pour valider que tout fonctionne correctement.
Bâtiment
Les diverses méthodes de construction utilisées avant 2023 ont été regroupées en une solution unifiée. Darknet nécessite C++17 ou une version plus récente, OpenCV, et utilise CMake pour générer les fichiers de projet nécessaires.
Vous n'avez pas besoin de maîtrise du 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 reflètent les instructions de Linux. Plusieurs notebooks Jupyter présentent diverses tâches, telles que la formation d'un nouveau réseau.
Explorez les blocs-notes dans le sous-répertoire colab ou suivez les instructions Linux fournies ci-dessous.
Méthode Linux CMake
Tutoriel de construction Darknet pour Linux
Facultatif : si vous possédez un GPU NVIDIA moderne, installez CUDA ou CUDA+cuDNN à ce stade. S'il est installé, Darknet exploitera 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 à redécouvrir tous les fichiers requis.
N'oubliez pas de reconstruire le Darknet.
Darknet peut fonctionner sans eux, mais CUDA ou CUDA+cuDNN est nécessaire si vous avez l'intention de former un réseau personnalisé.
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#cudnn-package-manager- présentation de l'installation pour télécharger et installer cuDNN.
Après avoir installé CUDA, assurez-vous de pouvoir exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.
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 :
Mettre à niveau CMake : si votre version de CMake est obsolète, mettez-la à niveau à l'aide des commandes suivantes :
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Redémarrer le shell : si vous utilisez bash comme shell de commande, redémarrez votre shell. Si vous utilisez du poisson, le chemin doit être automatiquement mis à jour.
Construire le Darknet :
`bash
sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/srccd ~/src
git clone https://github.com/hank-ai/darknetcd darknet
mkdir buildcd construire
cmake -DCMAKEBUILDTYPE=Version ..
faire -j4
emballer
sudo dpkg -i darknet-VERSION.deb
`
Utilisateurs avancés :
Installation RPM : Pour créer un fichier d'installation RPM au lieu d'un fichier DEB, modifiez les lignes appropriées dans CM_package.cmake. Avant d'exécuter le package make -j4, modifiez ces lignes :
`cmake
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
`
Pour les distributions comme CentOS et OpenSUSE, ajustez les lignes comme suit :
`cmake
ENSEMBLE (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Package d'installation : installez le package une fois sa construction terminée à l'aide du gestionnaire de packages de votre distribution. Pour les systèmes basés sur Debian (par exemple, 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 standard. Exécutez la version darknet à partir de la CLI pour confirmer son installation correcte.
/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 de liaison dans le développement 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.
S'il vous manque /usr/bin/darknet, vous avez uniquement construit Darknet, pas installé. Assurez-vous d'installer le fichier .deb ou .rpm comme indiqué ci-dessus.
Méthode Windows CMake
Ces instructions supposent une nouvelle installation de Windows 11 22H2.
1. Conditions préalables à l'installation : ouvrez une invite de commande cmd.exe standard et exécutez ces commandes :
`bash
Winget installe Git.Git
Winget installe Kitware.CMake
Winget installe nsis.nsis
Winget installe Microsoft.VisualStudio.2022.Community
`
2. Modifiez Visual Studio : configurez Visual Studio pour prendre en charge les applications C++ :
Cliquez sur le menu "Démarrer de Windows" et exécutez "Visual Studio Installer".
Sélectionnez "Modifier".
Choisissez « Développement de postes de travail avec C++ ».
Cliquez sur "Modifier" dans le coin inférieur droit, puis cliquez sur "Oui".
3. Invite de commandes du développeur : 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, car cela pourrait causer des problèmes !
Utilisateurs avancés :
Au lieu d'utiliser l'invite de commande du développeur, vous pouvez opter pour une invite de commande normale ou vous connecter via SSH et exécuter manuellement « Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat ».
4. Installez Microsoft VCPKG : exécutez les commandes suivantes dans l'invite de commande du développeur (et non dans PowerShell) pour installer Microsoft VCPKG, qui sera utilisé pour créer OpenCV :
`bash
CDC:
mkdir c:src
cdc:src
clone git https://github.com/microsoft/vcpkg
cdvcpkg
bootstrap-vcpkg.bat
.vcpkg.exe intégrer l'installation
.vcpkg.exe intégrer powershell.vcpkg.exe installer opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
Soyez patient lors de la dernière étape car cela peut prendre un temps considérable. Cela implique le téléchargement et la création de nombreux composants.
Utilisateurs avancés :
Notez qu'il existe de nombreux modules facultatifs que vous pouvez inclure lors de la création d'OpenCV. Exécutez la recherche .vcpkg.exe opencv pour afficher 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.
Visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.
Visitez https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows pour télécharger et installer cuDNN.
Une fois que vous avez installé CUDA, assurez-vous de pouvoir exécuter nvcc.exe et nvidia-smi.exe. Vous devrez peut-être modifier votre variable PATH.
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.
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 :
CUDA doit être installé après Visual Studio. Si vous mettez à niveau Visual Studio, n'oubliez pas de réinstaller CUDA.
5. Cloner et créer Darknet : Une fois les étapes précédentes terminées avec succès, clonez Darknet et créez-le. Au cours de cette étape, spécifiez l'emplacement VCPKG pour que CMake localise OpenCV et d'autres dépendances :
`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
`
Si vous rencontrez une erreur concernant les 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:
`bash
copier "C: Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Ceci est un exemple ! Vérifiez votre version en cours d’exécution et utilisez la commande appropriée à votre installation.)
Après avoir copié les fichiers, réexécutez la dernière commande msbuild.exe pour générer le package d'installation NSIS :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Utilisateurs avancés :
Notez que la sortie de la commande cmake est un fichier de solution Visual Studio standard (Darknet.sln). Si vous êtes un développeur de logiciels qui préfère utiliser l'interface graphique de Visual Studio plutôt que msbuild.exe pour créer des projets, vous pouvez ignorer les étapes de ligne de commande et charger le projet Darknet dans Visual Studio.
Vous devriez maintenant avoir l'exécutable C:srcDarknetbuildsrc-cliReleasedarknet.exe. Exécutez-le pour tester : version C:srcDarknetbuildsrc-cliReleasedarknet.exe.
Pour installer correctement Darknet, ses bibliothèques, les fichiers d'inclusion et les DLL requises, exécutez l'assistant d'installation NSIS généré à la dernière étape. Recherchez le fichier darknet-VERSION.exe dans le répertoire de construction. Par exemple:
`bash
darknet-2.0.31-win64.exe
`
L'installation du package d'installation NSIS :
Créez un répertoire appelé Darknet, comme C:Program FilesDarknet.
Installez l'application CLI (darknet.exe) et d'autres exemples d'applications.
Installez les fichiers .dll tiers nécessaires, tels que ceux d'OpenCV.
Installez les fichiers Darknet .dll, .lib et .h requis 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 sera installé dans C:Program FilesDarknet. Testez-le en exécutant : version C:Program FilesDarknetbindarknet.exe.
Si C:/Program Files/darknet/bin/darknet.exe est manquant, Darknet est uniquement construit, pas installé. Assurez-vous de remplir chaque panneau de l'assistant d'installation NSIS de l'étape précédente.
Utiliser le Darknet
CLI
Ce qui suit n'est pas une liste exhaustive de toutes les commandes prises en charge par Darknet.
En plus de la CLI Darknet, rappelons la CLI du projet DarkHelp, qui propose une CLI alternative à Darknet/YOLO. La CLI DarkHelp comprend diverses fonctionnalités avancées non directement accessibles 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 de ses 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é que quelqu'un a mis à disposition gratuitement en ligne. Certains ensembles de données pré-entraînés incluent :
LEGO Gears (détection d'objet dans une image)
Rolodex (détection de texte dans une image)
MSCOCO (détection d'objets standard de classe 80)
Commandes à exécuter :
Liste des commandes et options possibles :
`bash
aide sur le darknet
`
Vérifiez la version :
`bash
version darknet
`
Prédiction à l'aide d'une image :
V2 :
`bash
Test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg
`
V3 :
`bash
darknet02displayannotatedimages cars.cfg image1.jpg
`
Aide sombre :
`bash
DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg
`
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
`
Enregistrer les résultats dans une vidéo :
V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights test.mp4 -outfilename res.avi
`
V3 :
`bash
darknet05processvideosmultithreaded animaux.cfg animaux.noms animaux_best.weights test.mp4
`
Aide sombre :
`bash
DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4
`
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 ...
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
`
Pour vérifier l'exactitude mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
Recalcul des ancres : le recalcul des ancres est mieux effectué dans DarkMark, car il s'exécutera 100 fois consécutives et sélectionnera les meilleures ancres parmi toutes les options calculées. Cependant, si vous souhaitez 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 :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
(Voir la section formation ci-dessous pour plus de détails.)
Entraînement
Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :
Configuration des fichiers et répertoires : Comment dois-je configurer mes fichiers et répertoires ?
Fichiers de configuration : quel fichier de configuration dois-je utiliser ?
Commande de formation : 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. Cela simplifie le processus de création de tous les fichiers Darknet nécessaires. L'utilisation de DarkMark est fortement recommandée pour entraîner de nouveaux réseaux de neurones.
Si vous préférez la configuration manuelle des fichiers pour une formation réseau personnalisée :
1. Créer un dossier : créez un nouveau dossier pour stocker les fichiers. Pour cet exemple, nous allons créer un réseau de neurones pour détecter les animaux ; par conséquent, le répertoire suivant est créé : ~/nn/animals/.
2. Copier le fichier de configuration : copiez un fichier de configuration Darknet que vous souhaitez utiliser comme modèle. Par exemple, consultez cfg/yolov4-tiny.cfg. Placez-le dans le dossier créé. Dans cet exemple, nous avons maintenant ~/nn/animals/animals.cfg.
3. Créez des animaux.noms : créez un fichier texte nommé animaux.noms dans le même dossier que le fichier de configuration. Cet exemple a maintenant ~/nn/animals/animals.names.
4. Modifier animaux.names : Modifiez le fichier animaux.names à l'aide de votre éditeur de texte. Énumérez les classes que vous comptez utiliser. Chaque classe doit occuper une ligne distincte, sans aucune ligne vide ni commentaire. Dans cet exemple, le fichier .names contiendra quatre lignes :
`
chien
chat
oiseau
cheval
`
5. Créer 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. Dossier de jeux de données : créez un dossier pour stocker vos images et annotations. Par exemple, cela pourrait être ~/nn/animals/dataset. Chaque image nécessite un fichier .txt correspondant décrivant ses annotations. Le format des fichiers d'annotations .txt est très spécifique. Vous ne pouvez pas créer manuellement ces fichiers car chaque annotation nécessite des coordonnées précises. Utilisez DarkMark ou un logiciel similaire pour annoter vos images. Le format d'annotation YOLO est décrit dans la FAQ Darknet/YOLO.
7. Fichiers « train » et « valide » : Créez les fichiers texte « train » et « valide » mentionnés dans le fichier .data. Ces deux fichiers doivent répertorier individuellement toutes les images que Darknet utilisera pour la formation et la validation lors du calcul de mAP%. Incluez une image par ligne. Le chemin et les noms de fichiers peuvent être relatifs ou absolus.
8. Modifier le fichier .cfg : utilisez un éditeur de texte pour modifier votre fichier .cfg.
Assurez-vous que le lot = 64.
Observez les subdivisions. En fonction des dimensions de votre réseau et de la capacité de mémoire GPU, vous devrez peut-être augmenter les subdivisions. La valeur idéale est 1, alors commencez par cela. Consultez la FAQ Darknet/YOLO si 1 ne fonctionne pas pour vous.
Faites attention à maxbatches=..... Une bonne valeur de départ est 2000 fois le nombre de classes. Dans cet exemple, nous avons 4 animaux, donc 4 * 2000 = 8000, ce qui signifie maxbatches=8000.
Notez les étapes =..... Réglez ceci sur 80 % et 90 % des lots maximum. Dans cet exemple, avec maxbatches défini sur 8 000, nous utiliserions steps=6 400,7 200.
Notez width=... et height=..... Ce sont les dimensions du réseau. La FAQ Darknet/YOLO explique comment déterminer la meilleure taille.
Recherchez toutes les occurrences de la ligne classes=... et modifiez-la avec le nombre de classes dans votre fichier .names. Dans cet exemple, nous utiliserions classes=4.
Recherchez toutes les occurrences de la ligne filters=... dans la section [convolutionnelle] précédant chaque section [yolo]. La valeur doit être (numberofclasses + 5) 3. Dans cet exemple, (4 + 5) 3 = 27. Par conséquent, utilisez filters=27 sur les lignes appropriées.
9. Commencez la formation : exécutez les commandes suivantes :
`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. Les progrès de la formation peuvent être surveillés en visualisant le fichier chart.png. Consultez la FAQ Darknet/YOLO pour connaître les paramètres supplémentaires qui pourraient être utiles lors de la formation d'un nouveau réseau.
Pour afficher plus de détails sur la formation, ajoutez le paramètre --verbose. Par exemple:
`bash
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
Autres outils et liens
Pour gérer vos projets Darknet/YOLO, annoter des images, vérifier les annotations et générer les fichiers nécessaires à la formation avec Darknet, voir DarkMark.
Pour une alternative CLI robuste à Darknet, pour utiliser la mosaïque d'images, le suivi d'objets dans des vidéos ou une API C++ robuste pour les applications commerciales, explorez DarkHelp.
Vérifiez si la FAQ Darknet/YOLO peut répondre à vos questions.
Visionnez de nombreux tutoriels et exemples de vidéos sur la chaîne YouTube de Stéphane.
Si vous avez une demande d'assistance ou souhaitez interagir avec d'autres utilisateurs de Darknet/YOLO, rejoignez le serveur Discord Darknet/YOLO.
Feuille de route
Dernière mise à jour le 30/10/2024 :
Complété:
1. Remplacement de qsort() par std::sort() pendant la formation (certaines instances obscures subsistent).
2. Suppression de check_mistakes, getchar() et system().
3. Conversion de Darknet pour utiliser le compilateur C++ (g++ sous Linux, VisualStudio sous Windows).
4. Correction de la version de Windows.
5. Correction du support Python.
6. Construit la bibliothèque Darknet.
7. Réactivation des étiquettes sur les prédictions (code "alphabet").
8. Réactivation du code CUDA/GPU.
9. Réactivation de CUDNN.
10. Réactivation de la moitié CUDNN.
11. Évité de coder en dur l’architecture CUDA.
12. Informations améliorées sur la version CUDA.
13. Réactivation d'AVX.
14. Suppression des anciennes solutions et du Makefile.
15. Rendu OpenCV obligatoire.
16. Suppression de la dépendance à l'ancienne bibliothèque pthread.
17. Suppression du STB.
18. Réécriture de CMakeLists.txt pour intégrer la nouvelle détection CUDA.
19. Suppression de l'ancien code "alphabet" et suppression des plus de 700 images dans les données/étiquettes.
20. Construit hors source.
21. Sortie améliorée du numéro de version.
22. Implémentation d'optimisations de performances liées à la formation (tâche continue).
23. Implémentation d'optimisations de performances liées à l'inférence (tâche en cours).
24. Utilisation du passage par référence dans la mesure du possible.
25. Fichiers .hpp nettoyés.
26. Darknet.h réécrit.
27. J'ai évité de convertir cv::Mat en void* et je l'ai utilisé comme un objet C++ approprié.
28. Cohérence corrigée ou assurée 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. Il est peu probable que les appareils Jetson d'origine soient réparés car NVIDIA ne les prend plus en charge (pas de compilateur C++17).
31. Les nouveaux appareils Jetson Orin sont fonctionnels.
32. Correction de l'API Python dans la V3.
Objectifs à court terme :
1. Remplacez printf() par std::cout (en cours).
2. Revisitez l’ancien support de caméra zed.
3. Améliorer et améliorer la cohérence de l'analyse de la ligne de commande (en cours).
Objectifs à moyen terme :
1. Supprimez tout le code char* et remplacez-le par std::string.
2. Éliminez les avertissements cachés et nettoyez les avertissements du compilateur (en cours).
3. Meilleure utilisation de cv::Mat au lieu de la structure d'image personnalisée en C (en cours).
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 (par exemple, images avec une profondeur supplémentaire ou un canal thermique).
7. Nettoyage du code en cours (en cours).
Objectifs à long terme :
1. Résolvez les problèmes CUDA/CUDNN sur tous les GPU.
2. Réécrivez le code CUDA+cuDNN.
3. Envisagez d'ajouter la prise en charge des GPU non NVIDIA.
4. Introduisez des cadres de délimitation pivotés ou une forme de support « d'angle ».
5. Incorporez des points clés/squelettes.
6. Intégrer les heatmaps (en cours).
7. Mettre en œuvre la segmentation.
