Dépôt principal Data.gov
Il s'agit du référentiel principal de la plateforme Data.gov. Il est principalement utilisé pour suivre le travail de l'équipe, mais également pour héberger le code à l'échelle de Datagov (modèles d'actions GitHub, sortie, etc.).
Si vous recherchez de la documentation sur les environnements cloud.gov, reportez-vous aux référentiels d'applications.
Actions et modèles GitHub
Plusieurs actions GitHub ont été refactorisées pour utiliser des modèles dans ce référentiel. Vous pouvez trouver ces modèles ici ainsi que des exemples de leur utilisation dans Inventaire et Catalogue.
Cadre de détection d'objets Darknet et YOLO
Darknet est un framework de réseau neuronal open source construit avec 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 soutient la communauté Darknet/YOLO.
Découvrez le site Darknet/YOLO.
Explorez la FAQ Darknet/YOLO.
Rejoignez le serveur Discord Darknet/YOLO.
Papiers
1. Article YOLOv7 (lien vers l'article)
2. Papier Scaled-YOLOv4 (lien vers l'article)
3. Article YOLOv4 (lien vers l'article)
4. Article YOLOv3 (lien vers l'article)
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. Il est entièrement gratuit et open source, vous permettant d'intégrer Darknet/YOLO dans vos projets et produits sans aucune restriction ni frais de licence.
Darknet V3 (« Jazz »), sorti en octobre 2024, peut traiter 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 chaque image vidéo est traitée 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 peut fonctionner 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 fonctionner sous Linux, Windows et Mac. Les instructions de construction sont fournies ci-dessous.
Version Darknet
Version 0.x : L'outil Darknet original créé par Joseph Redmon entre 2013 et 2017.
Version 1.x : le référentiel Darknet populaire maintenu par Alexey Bochkovskiy de 2017 à 2021.
Version 2.x (« OAK ») : Le référentiel Darknet sponsorisé par Hank.ai et maintenu par Stéphane Charette à partir de 2023. Cette version a introduit une commande de version.
Version 2.1 : La dernière branche de la base de code version 2, disponible dans la branche v2.
Version 3.x (« JAZZ ») : La dernière phase de développement sortie en octobre 2024.
Principaux changements dans la version 3.x :
1. Suppression de nombreuses commandes anciennes et non maintenues.
2. Optimisations significatives des performances pour la formation et l'inférence.
3. API C héritée modifiée ; les applications utilisant l'API Darknet d'origine peuvent nécessiter des ajustements mineurs.
4. Introduction de la nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
5. Nouvelles applications et exemples de code dans src-examples : https://darknetcv.ai/api/files.html
Poids pré-entraînés MSCOCO
Plusieurs versions populaires de YOLO sont pré-entraînées sur l'ensemble de données MSCOCO pour plus de commodité. Cet ensemble de données contient 80 classes, répertoriées dans le fichier texte cfg/coco.names.
D'autres ensembles de données plus simples et poids pré-entraînés, tels que LEGO Gears et Rolodex, sont disponibles pour tester Darknet/YOLO. Reportez-vous à la FAQ Darknet/YOLO pour plus de détails.
Vous pouvez télécharger les poids pré-entraînés MSCOCO à 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
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 méthodes de build disponibles avant 2023 ont été combinées en une solution unique et unifiée. Darknet nécessite C++ 17 ou version ultérieure, OpenCV et utilise CMake pour générer des fichiers de projet.
Vous n'avez pas besoin de connaître le C++ pour créer, installer ou exécuter Darknet/YOLO, tout comme vous n'avez pas besoin d'être mécanicien pour conduire une voiture.
Google Colab
Les instructions de Google Colab sont identiques aux instructions de Linux. Plusieurs notebooks Jupyter illustrant des tâches telles que la formation d'un nouveau réseau sont disponibles dans le sous-répertoire colab. Vous pouvez également suivre les instructions Linux ci-dessous.
Méthode Linux CMake
1. Facultatif : si vous disposez d'un GPU NVIDIA moderne, installez CUDA ou CUDA+cuDNN. Darknet utilisera votre GPU pour un traitement d'image et vidéo plus rapide.
2. Supprimez le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
3. Reconstruisez Darknet.
4. Installez CUDA (facultatif) : visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.
5. Installez cuDNN (facultatif) : visitez https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package -manager-installation-overview pour télécharger et installer cuDNN.
6. Vérifiez l'installation de CUDA : assurez-vous que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.
7. Installez les dépendances et clonez 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 construire
construction de CD
`
8. Configurez CMake :
`bash
cmake -DCMAKEBUILDTYPE=Version ..
`
9. Créez le Darknet :
`bash
créer le paquet -j4
`
10. Installez Darknet :
`bash
sudo dpkg -i darknet-VERSION.deb
`
11. Test d'installation :
`bash
version darknet
`
Notes supplémentaires :
Si vous utilisez une ancienne version de CMake, mettez-la à niveau avant d'exécuter la commande cmake :
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Redémarrez votre shell si vous utilisez bash, ou fish devrait automatiquement mettre à jour le chemin.
Pour créer un fichier d'installation RPM au lieu d'un fichier DEB, modifiez le fichier CM_package.cmake.
Une fois le package d'installation créé, utilisez le gestionnaire de packages de votre distribution pour l'installer (par exemple, sudo dpkg -i darknet-2.0.1-Linux.deb sur les systèmes basés sur Debian).
Méthode Windows CMake
1. Installez les outils nécessaires :
`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 :
- Ouvrez "Programme d'installation de Visual Studio".
- Cliquez sur "Modifier".
- Sélectionnez "Développement Desktop avec C++".
- Cliquez sur « Modifier » en bas à droite puis sur « Oui ».
3. Ouvrez l'invite de commande du développeur pour VS 2022 : n'utilisez pas PowerShell.
4. Installez Microsoft VCPKG :
`bash
cd c:mkdir c:srccd c:src
clone git https://github.com/microsoft/vcpkgcd vcpkg
bootstrap-vcpkg.bat
.vcpkg.exe intégrer
installer .vcpkg.exe intégrer powershell.vcpkg.exe installer opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
5. Facultatif : installez CUDA ou CUDA+cuDNN (comme dans les instructions Linux).
6. Supprimez CMakeCache.txt (comme dans les instructions Linux).
7. Reconstruisez Darknet (comme dans les instructions Linux).
8. Installez CUDA (facultatif) : visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.
9. Installez cuDNN (facultatif) : 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.
10. Vérifiez l'installation de CUDA : assurez-vous que vous pouvez exécuter nvcc.exe. Vous devrez peut-être modifier votre variable PATH.
11. Décompressez et copiez les fichiers cuDNN : une fois téléchargés, 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.
12. Clonez Darknet et construisez :
`bash
cdc:src
clone git https://github.com/hank-ai/darknet.gitcd 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
`
13. Copiez les DLL CUDA (facultatif) : Si vous rencontrez des erreurs concernant des DLL CUDA ou cuDNN manquantes (par exemple, cublas64_12.dll), copiez manuellement les DLL CUDA dans le répertoire de sortie Darknet.exe :
`bash
copier "C: Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Assurez-vous de remplacer le numéro de version par celui que vous utilisez.)
14. Réexécutez la commande msbuild.exe pour générer le package d'installation NSIS :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
15. Test d'installation :
`bash
C: version srcDarknetbuildsrc-cliReleasedarknet.exe
`
16. Exécutez l'assistant d'installation NSIS : cela installera l'application CLI, les DLL requises, les bibliothèques, les fichiers d'inclusion et les fichiers de configuration de modèle.
Notes supplémentaires :
La commande cmake génère un fichier de solution Visual Studio (Darknet.sln). Vous pouvez utiliser l'interface graphique de Visual Studio pour générer le projet au lieu de msbuild.exe.
Le package d'installation NSIS (par exemple, darknet-VERSION.exe) se trouve dans le répertoire de construction.
Utiliser le Darknet
CLI
Ce qui suit n'est pas une liste exhaustive de toutes les commandes Darknet.
Aide Darknet : affiche les informations d'aide.
Version Darknet : Vérifiez la version Darknet.
Commandes de prédiction :
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
`
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
`
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
`
Enregistrer les résultats dans la 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
`
Spécifiez le GPU :
V2 :
`bash
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4
`
Calcul de 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
`
Recalculer les ancres :
DarkMark (recommandé) : utilisez DarkMark pour exécuter 100 calculs consécutifs et sélectionner les meilleures ancres.
Réseau sombre :
`bash
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
Former un nouveau réseau :
Utilisation de DarkMark (recommandé) : utilisez DarkMark pour créer tous les fichiers nécessaires à la formation.
Configuration manuelle :
1. Créez un nouveau dossier pour votre projet (par exemple, ~/nn/animals/).
2. Copiez un fichier de configuration comme modèle (par exemple, cfg/yolov4-tiny.cfg) dans le dossier.
3. Créez un fichier texte animaux.names avec vos noms de classe, un par ligne.
4. Créez un fichier texte animaux.data au format suivant :
`
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
`
5. Créez un dossier pour les images et les annotations (par exemple, ~/nn/animals/dataset).
6. Annotez vos images et générez les fichiers d'annotation .txt correspondants à l'aide de DarkMark ou d'un logiciel similaire.
7. Créez les fichiers animauxtrain.txt et animauxvalid.txt, répertoriant respectivement les images pour la formation et la validation, une par ligne.
8. Modifiez le fichier de configuration :
- Définir le lot = 64.
- Ajuster les subdivisions selon les besoins.
- Définissez max_batches=8000 (ou 2000 x nombre de classes).
- Définissez les étapes = 6400,7200 (80 % et 90 % de max_batches).
- Définissez la largeur et la hauteur selon les dimensions de votre réseau.
- Mettez à jour les classes avec le nombre de classes dans votre fichier .names.
- Mettre à jour les filtres dans chaque section [convolutionnelle] avant les sections [yolo] : (nombre de classes + 5) * 3.
9. Commencez la formation :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
Conseils de formation supplémentaires :
Utilisez le paramètre --verbose pour obtenir des informations de formation plus détaillées :
`bash
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
Autres outils et liens
DarkMark : gérez les projets Darknet/YOLO, annotez les images, vérifiez les annotations et générez des fichiers de formation.
DarkHelp : CLI alternative robuste à Darknet, prise en charge de la mosaïque d'images, du suivi des objets et d'une API C++ pour les applications commerciales.
FAQ Darknet/YOLO : ressource complète pour les réponses aux questions courantes.
Chaîne YouTube de Stéphane : Tutoriels et exemples de vidéos sur Darknet/YOLO.
Serveur Discord Darknet/YOLO : Forum communautaire d'assistance et de discussion.
Feuille de route
Tâches terminées :
Remplacement de qsort() par std::sort() pour une efficacité améliorée.
Suppression des fonctions obsolètes telles que check_mistakes, getchar() et system().
Conversion de Darknet pour utiliser le compilateur C++ (g++ sous Linux, VisualStudio sous Windows).
Correction de problèmes de build Windows.
Prise en charge de Python restaurée.
Création de la bibliothèque Darknet.
Étiquettes de prédiction réactivées (code alphabétique).
Réactivation de la demi-prise en charge de CUDA/GPU, CUDNN et CUDNN.
Suppression de l'architecture CUDA codée en dur.
Informations sur la version CUDA améliorées.
Prise en charge AVX réactivée.
Suppression des anciennes solutions et du Makefile.
A fait d'OpenCV une dépendance non facultative.
Suppression de la dépendance à l'ancienne bibliothèque pthread.
Suppression de la dépendance STB.
Réécriture de CMakeLists.txt pour utiliser la nouvelle détection CUDA.
Suppression de l'ancien code alphabétique et suppression des images inutiles.
Activation des builds hors source.
Sortie améliorée du numéro de version.
Performances de formation et d’inférence optimisées.
Passage par référence implémenté le cas échéant.
Fichiers .hpp nettoyés.
Réécriture de darknet.h.
Utilisé cv::Mat comme objet C++ approprié au lieu d'être converti en void*.
Correction d'incohérences dans l'utilisation de la structure d'image interne.
Correction de problèmes de construction pour les appareils Jetson basés sur ARM (sauf pour les anciens modèles non pris en charge).
API Python fixe dans la version 3.
Objectifs à court terme :
Remplacez printf() par std::cout.
Étudiez la prise en charge des anciennes caméras Zed.
Améliorez et standardisez l’analyse de la ligne de commande.
Objectifs à moyen terme :
Supprimez tout le code char* et remplacez-le par std::string.
Éliminez les avertissements du compilateur et garantissez un style de code cohérent.
Améliorez l’utilisation de cv::Mat par rapport à la structure d’image C personnalisée.
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 (par exemple, avec des canaux de profondeur ou thermiques supplémentaires).
Nettoyage du code en cours.
Objectifs à long terme :
Résolvez les problèmes CUDA/CUDNN sur tous les GPU.
Réécrivez le code CUDA+cuDNN.
Découvrez la prise en charge des GPU non NVIDIA.
Implémentez des cadres de délimitation pivotés ou un support "d'angle".
Ajoutez des points clés/squelettes, des cartes thermiques et une prise en charge de la segmentation.
