Système de financement participatif RaiseDreams v191113
191113
Cadre de détection d'objets Darknet et YOLO
Darknet est un framework de réseau neuronal open source écrit en C, C++ et CUDA.
YOLO (You Only Look Once) est un système de détection d'objets en temps réel de pointe qui fonctionne dans le cadre Darknet.
Découvrez comment Hank.ai renforce la communauté Darknet/YOLO !
Annonce du Darknet V3 "Jazz"
Visitez le site Web Darknet/YOLO
Explorez la FAQ Darknet/YOLO
Rejoignez le serveur Discord Darknet/YOLO
Papiers
1. Papier YOLOv7 : lien vers le papier
2. Paper Scaled-YOLOv4 : lien vers le papier
3. Papier YOLOv4 : lien vers le papier
4. Papier YOLOv3 : lien vers le papier
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 de manière transparente Darknet/YOLO dans vos projets et produits existants, y compris commerciaux, sans aucun frais de licence.
Darknet V3 (« Jazz »), sorti en octobre 2024, atteint des performances remarquables, en exécutant les vidéos de l'ensemble de données LEGO jusqu'à 1 000 FPS sur un GPU NVIDIA RTX 3090. Cela se traduit par le traitement par Darknet/YOLO de chaque image vidéo, y compris le redimensionnement et le traitement, en moins d'une milliseconde.
Rejoignez le serveur Discord Darknet/YOLO pour obtenir de l'aide et des discussions : https://discord.gg/zSq8rtW
La version CPU de Darknet/YOLO fonctionne efficacement sur divers appareils, notamment Raspberry Pi, les serveurs cloud et Colab, les ordinateurs de bureau, les ordinateurs portables et les plates-formes de formation haut de gamme. Cependant, la version GPU de Darknet/YOLO nécessite un GPU compatible CUDA de NVIDIA.
Darknet/YOLO est compatible avec les systèmes d'exploitation Linux, Windows et Mac. Reportez-vous aux instructions de construction ci-dessous pour des conseils détaillés.
Version Darknet
L’outil Darknet original développé par Joseph Redmon entre 2013 et 2017 n’avait pas de numéro de version. Nous appelons cette version 0.x.
Le référentiel Darknet populaire ultérieur, maintenu par Alexey Bochkovskiy de 2017 à 2021, manquait également 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 a introduit pour la première fois, à partir de 2023, une commande de version. De 2023 à fin 2024, il a renvoyé la version 2.x « OAK ».
L'équipe de développement s'est concentrée sur la minimisation des perturbations des fonctionnalités existantes tout en se familiarisant avec la base de code.
Les principaux changements mis en œuvre au cours de cette période comprennent :
1. Processus de construction unifié : étapes de construction réécrites pour rationaliser le processus à l'aide de CMake pour Windows et Linux.
2. Conversion C++ : la base de code a été convertie pour utiliser le compilateur C++.
3. Amélioration du graphique : la visualisation chart.png a été améliorée pendant la formation.
4. Corrections de bugs et optimisations : de nombreuses corrections de bugs et optimisations liées aux performances ont été mises en œuvre, 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 phase de développement a commencé mi-2024 et a culminé avec la sortie de la version 3.x « JAZZ » en octobre 2024. La commande de version renvoie désormais 3.x.
Vous pouvez toujours revenir à la branche v2 précédente si vous devez exécuter des commandes spécifiques à partir de cette version. Veuillez informer l'équipe de développement si vous rencontrez des commandes manquantes, et elle étudiera leur ajout.
Modifications significatives introduites dans la version 3.x "JAZZ" :
1. Suppression des commandes : de nombreuses commandes obsolètes et non prises en charge ont été supprimées.
2. Optimisations des performances : de nombreuses optimisations des performances ont été appliquées à la fois pour la formation et l'inférence.
3. Modification de l'API : l'ancienne API C a subi des modifications. Les applications utilisant l'API Darknet d'origine peuvent nécessiter des ajustements mineurs. https://darknetcv.ai/api/api.html
4. Nouvelle API C/C++ : Darknet V3 introduit une nouvelle API C et C++. https://darknetcv.ai/api/api.html
5. Exemple de code amélioré : de nouvelles applications et des exemples de code sont disponibles dans les exemples src. 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 comprend 80 classes, répertoriées dans le fichier texte cfg/coco.names.
En plus de MSCOCO, divers 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 diverses sources, 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 résident dans le répertoire cfg.
Voici quelques 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
`
Les utilisateurs sont encouragés à former leurs propres réseaux. MSCOCO sert avant tout d'outil pour vérifier que tout fonctionne correctement.
Bâtiment
Les différentes 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 exploite CMake pour générer les fichiers de projet requis.
Construire Darknet/YOLO ne nécessite pas de connaissances en C++. C'est comme conduire une voiture sans être mécanicien.
Google Colab
Les instructions de Google Colab reflètent celles de Linux. Plusieurs notebooks Jupyter sont disponibles pour démontrer des tâches spécifiques, telles que la formation d'un nouveau réseau.
Explorez 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. Conditions préalables : assurez-vous que les packages suivants sont installés :
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Cloner Darknet : clonez le référentiel Darknet :
`bash
mkdir ~/srccd ~/src
clone git https://github.com/hank-ai/darknet
cd darknet
`
3. Créer un répertoire de construction : Créez un répertoire de construction :
`bash
mkdir construire
construction de CD
`
4. Configurez avec CMake : Exécutez CMake pour configurer la build :
`bash
cmake -DCMAKEBUILDTYPE=Version ..
`
5. Construire : Construisez le projet :
`bash
faire -j4
`
6. Paquet : Créez un paquet Debian :
`bash
faire un paquet
`
7. Installer : installez le package :
`bash
sudo dpkg -i darknet-VERSION.deb
`
Facultatif : CUDA/cuDNN pour l'accélération GPU
1. Installez CUDA : Si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer CUDA pour l'accélération GPU. Téléchargez et installez CUDA depuis https://developer.nvidia.com/cuda-downloads.
2. Installez cuDNN : 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- présentation de l'installation du gestionnaire de packages.
3. Vérifiez l'installation de CUDA : assurez-vous que vous pouvez exécuter nvcc et nvidia-smi après avoir installé CUDA. Vous devrez peut-être ajuster votre variable PATH.
4. Configuration de CMake (si CUDA est installé après CMake) : Si vous installez CUDA ou CUDA+cuDNN après avoir configuré CMake, vous devez supprimer le fichier CMakeCache.txt dans le répertoire de construction Darknet pour forcer CMake à retrouver les fichiers nécessaires. Ensuite, réexécutez CMake et reconstruisez Darknet.
Utilisateurs avancés
Package RPM : pour créer un fichier d'installation RPM au lieu d'un fichier DEB, modifiez les lignes suivantes dans CM_package.cmake :
`cmake
# SET (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Distributions comme Centos et OpenSUSE : pour les distributions comme Centos et OpenSUSE, remplacez les lignes dans CM_package.cmake par :
`cmake
# SET (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Package d'installation : Pour installer le package après la construction, utilisez le gestionnaire de packages de votre distribution. Par exemple, sur les systèmes basés sur Debian comme Ubuntu, utilisez sudo dpkg -i darknet-2.0.1-Linux.deb.
Fichiers clés installés :
/usr/bin/darknet : L'exécutable principal de Darknet. Confirmez l'installation en exécutant la version darknet dans la CLI.
/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.
Méthode Windows CMake
Tutoriel de création pour Windows (en supposant une nouvelle installation de Windows 11 22H2)
1. Conditions préalables à l'installation : installez les composants nécessaires à l'aide de Winget :
`bash
Winget installe Git.Git
Winget installe Kitware.CMake
Winget installe nsis.nsis
Winget installe Microsoft.VisualStudio.2022.Community
`
2. Installez la prise en charge de Visual Studio C++ : modifiez l'installation de Visual Studio pour inclure la prise en charge de C++ :
* Ouvrez 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. Invite de commandes du développeur : lancez « Invite de commandes du développeur pour VS 2022 » à partir du menu « Démarrer de Windows ». N'utilisez pas PowerShell pour ces étapes !
4. Installez Microsoft VCPKG : Installez VCPKG 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ègre PowerShell
.vcpkg.exe installe opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
* Soyez patient, cette étape peut prendre beaucoup de temps car elle nécessite le téléchargement et la construction de nombreux composants.
5. Facultatif : CUDA/cuDNN pour l'accélération GPU : suivez les mêmes étapes décrites dans la section Linux.
6. Cloner Darknet : clonez le référentiel Darknet :
`bash
cdc:src
clone git https://github.com/hank-ai/darknet.git
cd darknet
mkdir construire
construction de CD
`
7. Configurer avec CMake : configurez la build à l'aide de CMake :
`bash
cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
8. Construire avec msbuild : Construisez le projet à l'aide de msbuild :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Dépannage : 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 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
`
* N'oubliez pas d'ajuster la commande en fonction de votre version CUDA.
Réexécutez la commande msbuild.exe après avoir copié les DLL.
Utilisateurs avancés
Solution Visual Studio : CMake génère un fichier de solution Visual Studio (Darknet.sln). Les développeurs de logiciels qui préfèrent utiliser l'interface graphique de Visual Studio peuvent charger le projet Darknet dans Visual Studio au lieu d'utiliser la ligne de commande.
Vérification et installation
Vérification : exécutez la commande suivante pour vérifier si Darknet est correctement construit :
`bash
C: version srcDarknetbuildsrc-cliReleasedarknet.exe
`
Installation : exécutez l'assistant d'installation NSIS généré à la dernière étape pour installer correctement Darknet, les bibliothèques, les fichiers d'inclusion et les DLL nécessaires. Localisez le fichier darknet-VERSION.exe dans le répertoire de construction. Par exemple : darknet-2.0.31-win64.exe.
Fichiers clés installés :
C:Program FilesDarknetbin/darknet.exe : L'application CLI Darknet.
C:Program FilesDarknet/bin : contient d'autres exemples d'applications.
C:Program FilesDarknet : inclut les fichiers .dll tiers requis (OpenCV), les fichiers Darknet .dll, .lib et .h, ainsi que les fichiers modèles .cfg.
Utiliser le Darknet
CLI
La liste suivante n'est pas exhaustive de toutes les commandes prises en charge par Darknet.
En plus de la CLI Darknet, pensez à la CLI du projet DarkHelp, qui propose une CLI alternative avec plusieurs fonctionnalités avancées non directement disponibles dans Darknet. Vous pouvez utiliser les deux CLI simultanément.
Prérequis essentiels :
Pour la plupart des commandes, vous avez besoin d'un fichier .weights ainsi que des fichiers .names et .cfg correspondants.
Formez votre propre réseau (fortement recommandé !) ou téléchargez un réseau pré-entraîné depuis Internet.
Exemples d'ensembles de données pré-entraînés :
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.
Exemples de commandes :
1. Obtenez de l'aide :
`bash
aide sur le darknet
`
2. Vérifiez la version :
`bash
version darknet
`
3. 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
`
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. Traitement vidéo :
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. Traitement des webcams :
V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -c 0
`
V3 :
`bash
darknet08display_webcam animaux
`
7. Sortie 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. GPU spécifique :
V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4
`
10. Évaluation de la précision :
carte:
`bash
Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...
`
mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
11. Calcul de l'ancre :
DarkMark : utilisez DarkMark pour recalculer les ancres pour des performances optimales.
Darknet (ancienne méthode) :
`bash
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
12. Former un nouveau réseau :
DarkMark (recommandé) : utilisez DarkMark pour l'annotation et la formation.
Configuration manuelle :
1. Création de répertoire : créez un dossier pour votre projet (par exemple, ~/nn/animals/).
2. Fichier de configuration : copiez un fichier de configuration Darknet comme modèle (par exemple, cfg/yolov4-tiny.cfg).
3. Fichier .names : Créez un fichier texte .names répertoriant vos classes (par exemple, ~/nn/animals/animals.names).
4. Fichier .data : Créez un fichier texte .data dans le même dossier que le fichier de configuration (par exemple, ~/nn/animals/animals.data).
5. Dossier Dataset : créez un dossier pour vos images et annotations (par exemple, ~/nn/animals/dataset).
6. Annotations .txt : générez des fichiers .txt pour chaque image, contenant les coordonnées des annotations. Utilisez DarkMark ou d'autres outils d'annotation.
7. Fichiers train/valid : Créez des fichiers catstrain.txt et catsvalid.txt répertoriant vos images de formation et de validation.
8. Modifier le fichier .cfg : ajustez le fichier de configuration en fonction de votre ensemble de données.
* Définir le lot = 64.
* Ajustez les subdivisions en fonction de la mémoire de votre GPU.
Définissez max_batches sur 2 000 classes.
* Définissez les étapes à 80 % et 90 % de max_batches.
* Ajustez la largeur et la hauteur en fonction des dimensions du réseau.
* Définissez classes=... sur le nombre de classes dans votre fichier .names.
Ajustez les filtres =... dans les sections [convolutionnelles] avant chaque section [yolo] à (nombre de classes + 5) 3.
9. Formation : Commencer la formation :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
* Les meilleurs poids seront enregistrés sous le nom cats_best.weights.
* Consultez le fichier chart.png pour suivre la progression de la formation.
Autres outils et liens
Ressources clés :
DarkMark : pour gérer des projets Darknet/YOLO, annoter des images, vérifier des annotations et générer des fichiers de formation.
DarkHelp : une CLI alternative robuste à Darknet, avec des fonctionnalités telles que 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 : trouvez des réponses aux questions et solutions courantes.
Chaîne YouTube de Stéphane : découvrez des tutoriels et des exemples de vidéos.
Serveur Discord Darknet/YOLO : connectez-vous avec d'autres utilisateurs de Darknet/YOLO pour obtenir de l'aide et des discussions.
Feuille de route
Dernière mise à jour le 30/10/2024 :
Tâches terminées :
1. Remplacement de qsort() par std::sort() dans les sections de formation pertinentes.
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 Windows.
5. Correction du support Python.
6. Bibliothèque Darknet construite.
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. Suppression de l'architecture CUDA codée en dur.
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 non facultatif.
16. Suppression de la dépendance à l'ancienne bibliothèque pthread.
17. Suppression du STB.
18. Réécriture de CMakeLists.txt pour utiliser la nouvelle détection CUDA.
19. Suppression de l'ancien code "alphabet" et des images supprimées dans les données/étiquettes.
20. Activation de la construction hors source.
21. Sortie améliorée du numéro de version.
22. Optimisations des performances liées à la formation (en cours).
23. Optimisations des performances liées à l'inférence (en cours).
24. Passage par référence mis en œuvre le cas échéant.
25. Fichiers .hpp nettoyés.
26. Réécriture de darknet.h.
27. Élimination de la conversion de cv::Mat en void*, en l'utilisant comme un objet C++ approprié.
28. Amélioration de la cohérence 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. Correction de l'API Python dans la V3.
Objectifs à court terme :
1. Remplacez printf() par std::cout (en cours).
2. Examinez l'ancien support de caméra Zed.
3. Améliorer et standardiser l'analyse des lignes de commande (en cours).
Objectifs à moyen terme :
1. Supprimez tout le code char* et remplacez-le par std::string.
2. Supprimez les avertissements du compilateur (en cours).
3. Améliorer l'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 des canaux thermiques).
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éécriture du code CUDA+cuDNN.
3. Explorez la prise en charge des GPU non NVIDIA.
4. Implémentez des cadres de délimitation pivotés ou un support « d'angle ».
5. Prise en charge des points clés/squelettes.
6. Prise en charge des cartes thermiques (en cours).
7. Segmentation.
