ansible

Ansible

Ansible est un système d'automatisation informatique remarquablement simple. Il gère efficacement la gestion de la configuration, le déploiement d'applications, le provisionnement du cloud, l'exécution de tâches ad hoc, l'automatisation du réseau et l'orchestration multi-nœuds. Ansible vous permet d'exécuter sans effort des modifications complexes, telles que des mises à jour progressives sans temps d'arrêt avec des équilibreurs de charge. Plongez plus profondément dans les capacités d’Ansible sur leur site officiel.

Principes de conception

1. Utiliser Ansible

Vous pouvez installer en toute transparence une version publiée d'Ansible à l'aide de pip ou de votre gestionnaire de packages préféré. Consultez notre guide d'installation détaillé pour des instructions complètes sur différentes plates-formes.

2. Donner du pouvoir aux utilisateurs expérimentés et aux développeurs

Pour les utilisateurs avancés et les développeurs, la branche devel donne accès aux dernières fonctionnalités et correctifs. Bien que généralement stable, il est important de reconnaître le risque de rupture de modifications lors de l'utilisation de cette branche. Nous vous recommandons fortement de vous engager avec la communauté Ansible si vous choisissez de travailler avec la branche de développement.

Communication

Rejoignez le forum Ansible dynamique pour interagir avec la communauté, demander de l'aide et poser des questions. Pour des canaux de communication supplémentaires, explorez notre guide dédié sur la connexion avec la communauté Ansible.

Contribuer à Ansible

Directives de codage

Nous documentons méticuleusement nos directives de codage dans le guide du développeur. Nous vous encourageons fortement à consulter les sections suivantes :

1. Informations sur la succursale

2. Feuille de route

Sur la base des précieux commentaires de l'équipe et de la communauté, une feuille de route initiale est publiée pour chaque version majeure ou mineure (par exemple, 2.7, 2.8). La page Ansible Roadmap présente nos plans et propose des pistes pour influencer notre orientation.

Auteurs

Ansible a été conçu à l'origine par Michael DeHaan et a bénéficié des contributions de plus de 5 000 utilisateurs (et ce n'est pas fini). Merci à tous ceux qui ont contribué !

Ansible est fièrement sponsorisé par Red Hat, Inc.

Licence

Licence publique générale GNU v3.0 ou ultérieure. Reportez-vous à COPIE pour le texte complet de la licence.

Cadre de détection d'objets Darknet et YOLO

Logos !darknet et hank.ai

Darknet est un framework de réseau neuronal open source développé en C, C++ et CUDA.

YOLO (You Only Look Once) représente 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 contribue à la communauté Darknet/YOLO : https://darknetcv.ai/

Explorez le site officiel Darknet/YOLO : https://pjreddie.com/darknet/

Consultez la FAQ complète Darknet/YOLO : https://pjreddie.com/darknet/yolo/

Rejoignez le serveur Discord Darknet/YOLO actif : https://discord.gg/zSq8rtW

Papiers

1. Article YOLOv7 : https://arxiv.org/abs/2207.02696

2. Papier Scaled-YOLOv4 : https://arxiv.org/abs/2102.12074

3. Article YOLOv4 : https://arxiv.org/abs/2004.10934

4. Article YOLOv3 : https://arxiv.org/abs/1804.02769

Informations générales

Le framework Darknet/YOLO continue de surpasser les autres frameworks et versions de YOLO en termes de rapidité et de précision.

Sa liberté totale et sa nature open source vous permettent d'intégrer de manière transparente Darknet/YOLO dans des projets et produits existants, y compris commerciaux, sans restrictions ni frais de licence.

Darknet V3 (« Jazz »), sorti en octobre 2024, démontre ses prouesses en traitant les vidéos de l'ensemble de données LEGO à une vitesse impressionnante de 1 000 FPS lors de l'utilisation d'un GPU NVIDIA RTX 3090. Cela équivaut à un temps de traitement de 1 milliseconde ou moins pour chaque image vidéo, démontrant une efficacité exceptionnelle.

Pour toute assistance ou discussion liée à Darknet/YOLO, rejoignez le serveur Discord dédié : https://discord.gg/zSq8rtW.

La version CPU de Darknet/YOLO est adaptable à 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. La version GPU de Darknet/YOLO nécessite un GPU compatible CUDA de NVIDIA.

Darknet/YOLO a été validé pour fonctionner de manière transparente sur les systèmes d'exploitation Linux, Windows et Mac. Reportez-vous aux instructions de construction décrites 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 considérons qu'il s'agit de la version 0.x.

Le référentiel Darknet populaire qui a suivi, maintenu par Alexey Bochkovskiy de 2017 à 2021, manquait également de numéro de version. Nous catégorisons cela comme version 1.x.

Le référentiel Darknet, sponsorisé par Hank.ai et géré par Stéphane Charette à partir de 2023, a introduit pour la première fois une commande de version. De 2023 à fin 2024, il a renvoyé la version 2.x « OAK ».

Les objectifs de développement étaient centrés sur la minimisation des perturbations des fonctionnalités existantes tout en nous familiarisant avec la base de code.

Principales améliorations de la version 2.x :

1. Processus de construction unifié : réécriture des étapes de construction pour une approche unifiée à l'aide de CMake sous Windows et Linux.

2. Transition C++ : conversion de la base de code pour exploiter le compilateur C++.

3. Visualisation améliorée de la formation : amélioration de la visualisation chart.png pendant la formation.

4. Optimisations des performances : correction de bugs et mise en œuvre d'optimisations liées aux performances, principalement axées sur la réduction du temps de formation.

La version 2.1 représente la branche finale de cette base de code, disponible dans la branche v2.

La prochaine étape de développement a commencé à la mi-2024 et a culminé avec la sortie en octobre 2024 de la version 3.x « JAZZ ».

Vous conservez la possibilité d'extraire la branche v2 précédente si vous avez besoin d'accéder à des commandes spécifiques de cette version. Si vous rencontrez des commandes manquantes, veuillez nous en informer pour une enquête et une éventuelle réintégration.

Changements importants dans la version 3.x :

1. Élagage des commandes : suppression de nombreuses commandes obsolètes et non maintenues.

2. Performances améliorées : mise en œuvre d'optimisations approfondies des performances, à la fois pendant la formation et l'inférence.

3. Modifications de l'API : l'ancienne API C a subi des modifications ; les applications s'appuyant sur l'API Darknet d'origine nécessiteront des ajustements mineurs. Reportez-vous à la documentation mise à jour pour obtenir des conseils : https://darknetcv.ai/api/api.html

4. Introduction de la nouvelle API : introduction d'une nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html

5. Exemple de code étendu : ajout de nouvelles applications et d'exemples de code dans le répertoire src-examples : https://darknetcv.ai/api/files.html

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, qui peuvent être trouvées dans le fichier texte cfg/coco.names.

Des ensembles de données supplémentaires plus simples et des poids pré-entraînés sont facilement disponibles pour tester Darknet/YOLO, notamment LEGO Gears et Rolodex. Pour des informations détaillées, consultez la FAQ Darknet/YOLO.

Vous pouvez obtenir les poids pré-entraînés MSCOCO à partir de divers endroits, y compris ce référentiel :

YOLOv2 (novembre 2016) :

yolov2-minuscule

yolov2-plein

YOLOv3 (mai 2018) :

yolov3-minuscule

yolov3-plein

YOLOv4 (mai 2020) :

yolov4-minuscule

yolov4-plein

YOLOv7 (août 2022) :

yolov7-minuscule

yolov7-complet

Les poids pré-entraînés MSCOCO sont fournis à des fins de démonstration. Les fichiers .cfg et .names correspondants pour MSCOCO se trouvent 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

`

Il est fortement recommandé de former vos propres réseaux. MSCOCO est généralement utilisé pour garantir que les fonctionnalités du framework fonctionnent comme prévu.

Bâtiment

Les méthodes de construction précédentes (avant 2023) ont été consolidées dans une solution unifiée. Darknet nécessite C++ 17 ou version ultérieure, OpenCV et utilise CMake pour générer les fichiers de projet nécessaires.

La création de Darknet/YOLO ne nécessite pas d'expertise en C++ ; comme si vous conduisiez une voiture, vous n'avez pas besoin d'être mécanicien pour l'utiliser.

Les développeurs de logiciels sont encouragés à visiter https://darknetcv.ai/ pour obtenir un aperçu du fonctionnement interne du cadre de détection d'objets Darknet/YOLO.

Google Colab

Les instructions de Google Colab reflètent les instructions de Linux. Plusieurs notebooks Jupyter présentent 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 fournies ci-dessous.

Méthode Linux CMake

1. Logiciels essentiels :

Éléments essentiels de la construction : sudo apt-get install build-essential git libopencv-dev cmake

2. Clonage du référentiel :

Créez un répertoire source : mkdir ~/srccd ~/src

Cloner le dépôt : git clone https://github.com/hank-ai/darknetcd darknet

3. Créer un répertoire :

Créez un répertoire de build : mkdir buildcd build

4. Configuration CMake :

Configurez CMake : cmake -DCMAKEBUILDTYPE=Release ..

5. Créez le Darknet :

Construire : make -j4

6.Installation du paquet :

Créer le package : package

Installez le package : sudo dpkg -i darknet-VERSION.deb

Facultatif : installation CUDA ou CUDA+cuDNN

Pour un traitement accéléré des images et des vidéos, vous pouvez éventuellement installer CUDA ou CUDA+cuDNN.

Installation de CUDA :

Visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.

Installation de cuDNN :

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 installez cuDNN.

Installation post-CUDA :

Assurez-vous que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.

Mise à niveau de CUDA ou CUDA+cuDNN :

Supprimez le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver les fichiers nécessaires.

Reconstruisez le Darknet.

Mise à niveau de la version CMake (si nécessaire) :

Purger le CMake existant : sudo apt-get purge cmake

Installez la dernière version de CMake : sudo snap install cmake --classic

Redémarrez votre shell (bash) ou assurez-vous que le nouveau chemin est reconnu (fish).

Utilisateurs avancés :

Pour créer un fichier d'installation RPM au lieu de DEB, modifiez les lignes appropriées dans CM_package.cmake. Avant d'exécuter le package make -j4, ajustez les lignes suivantes :

`cmake

ENSEMBLE (CPACK_GENERATOR "DEB")

ENSEMBLE (CPACK_GENERATOR "RPM")

`

Pour les distributions comme CentOS et OpenSUSE, modifiez ces lignes :

`cmake

ENSEMBLE (CPACK_GENERATOR "DEB")

ENSEMBLE (CPACK_GENERATOR "RPM")

`

Une fois le package d'installation créé, installez-le à l'aide du gestionnaire de packages de votre distribution. Par exemple, sur les systèmes basés sur Debian comme Ubuntu :

`bash

sudo dpkg -i darknet-2.0.1-Linux.deb

`

Post-installation :

Les fichiers installés incluent :

- /usr/bin/darknet : exécutable Darknet. Exécutez la version darknet pour confirmer l'installation.

- /usr/include/darknet.h : API Darknet pour les développeurs C, C++ et Python.

- /usr/include/darknet_version.h : informations de version pour les développeurs.

- /usr/lib/libdarknet.so : Bibliothèque de liaison dans le développement C, C++ et Python.

- /opt/darknet/cfg/... : Emplacement de tous les modèles .cfg.

Darknet est désormais construit et installé avec succès dans /usr/bin/. Pour vérifier, exécutez la version darknet.

Méthode Windows CMake

1. Prérequis :

Installez les éléments suivants à l'aide de Winget :

- Git : Winget installe Git.Git

- CMake : Winget installe Kitware.CMake

- NSIS : winget installe nsis.nsis

- Communauté Visual Studio 2022 : installation Winget Microsoft.VisualStudio.2022.Community

2. Configuration de Visual Studio :

Ouvrez "Visual Studio Installer" dans le menu Démarrer de Windows.

Cliquez sur "Modifier".

Sélectionnez « Développement de postes de travail avec C++ ».

Cliquez sur « Modifier » dans le coin inférieur droit puis sur « Oui ».

3. Invite de commandes du développeur :

Ouvrez le menu « Démarrer de Windows » et sélectionnez « Invite de commandes du développeur pour VS 2022 ». N'utilisez pas PowerShell pour ces étapes.

4. Installation de Microsoft VCPKG (pour OpenCV) :

Accédez à C: : cd c :

Créez un répertoire src : mkdir c:src

Cloner VCPKG : cd c:src git clone https://github.com/microsoft/vcpkg

Bootstrap VCPKG : cd vcpkg bootstrap-vcpkg.bat

Intégrer VCPKG : .vcpkg.exe intégrer l'installation

Installez OpenCV (y compris les dépendances) : .vcpkg.exe installez opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows

5. Facultatif : installation CUDA ou CUDA+cuDNN (Windows)

Pour un traitement accéléré des images et des vidéos, vous pouvez éventuellement installer CUDA ou CUDA+cuDNN.

Installation de CUDA :

Visitez https://developer.nvidia.com/cuda-downloads pour télécharger et installer CUDA.

Installation de 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.

Installation post-CUDA :

Assurez-vous que vous pouvez exécuter nvcc.exe. Vous devrez peut-être modifier votre variable PATH.

Décompressez le cuDNN téléchargé 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.

Mise à niveau de CUDA ou CUDA+cuDNN :

CUDA doit être installé après Visual Studio. Réinstallez CUDA si vous mettez à niveau Visual Studio.

6. Clonage et création du Darknet :

Accédez à votre répertoire source : cd c:src

Cloner le dépôt : git clone https://github.com/hank-ai/darknet.git

Créez un répertoire de build : cd darknetmkdir build

Configurez CMake avec VCPKG : cd build cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..

Créez la solution : msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln

Générez le package d'installation NSIS : msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj

7. Gestion des 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 de sortie que Darknet.exe. Par exemple:

`bash

copier "C: Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease

`

Ajustez le numéro de version dans la commande pour qu'il corresponde à votre installation.

Réexécutez la commande msbuild.exe pour générer le package d'installation NSIS.

Utilisateurs avancés :

La commande cmake génère un fichier de solution Visual Studio (Darknet.sln). Si vous préférez l'interface graphique de Visual Studio, vous pouvez charger le projet Darknet dans Visual Studio au lieu d'utiliser des outils de ligne de commande.

Vérification post-construction :

Vérifiez que C:srcDarknetbuildsrc-cliReleasedarknet.exe existe. Exécutez la version C:srcDarknetbuildsrc-cliReleasedarknet.exe pour confirmer.

Installation:

Exécutez l'assistant d'installation NSIS (par exemple, darknet-VERSION.exe dans le répertoire de construction) pour installer Darknet, les bibliothèques, les fichiers d'inclusion et les DLL nécessaires.

Vérification post-installation :

Vérifiez que C:/Program Files/darknet/bin/darknet.exe existe. Exécutez la version C:/Program Files/darknet/bindarknet.exe pour confirmer.

Utiliser le Darknet

CLI

Cette liste n'englobe pas toutes les commandes Darknet.

En plus de la CLI Darknet, pensez à utiliser la CLI du projet DarkHelp, qui propose une interface alternative et plus avancée. Les deux CLI peuvent être utilisées ensemble.

Pour la plupart des commandes, vous aurez besoin d'un fichier .weights ainsi que des fichiers .names et .cfg correspondants. Vous pouvez former votre propre réseau ou télécharger des réseaux pré-entraînés.

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.

Commandes CLI courantes :

1. Aide : aide darknet

2. Version : version darknet

3. Prédiction d'images (V2) :

Test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg

4. Prédiction d'images (V3) :

darknet02displayannotatedimages cars.cfg image1.jpg

5. Prédiction d'image (DarkHelp) :

DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg

6. Coordonnées de sortie (V2) :

test du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput dog.jpg

7. Coordonnées de sortie (V3) :

darknet01inference_images animaux chien.jpg

8. Coordonnées de sortie (DarkHelp) :

DarkHelp --json animaux.cfg animaux.names animaux_best.weights chien.jpg

9. Traitement vidéo (V2) :

Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput test.mp4

10. Traitement vidéo (V3) :

darknet03display_videos animaux.cfg test.mp4

11. Traitement vidéo (DarkHelp) :

DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4

12. Traitement de la webcam (V2) :

Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -c 0

13. Traitement de la webcam (V3) :

darknet08display_webcam animaux

14. Sauvegarde vidéo (V2) :

Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights test.mp4 -outfilename res.avi

15. Sauvegarde vidéo (V3) :

darknet05processvideosmultithreaded animaux.cfg animaux.noms animaux_best.weights test.mp4

16. Sauvegarde vidéo (DarkHelp) :

DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4

17. Sortie JSON (V2) :

Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput

18. Sortie JSON (V3) :

darknet06imagestojson animaux image1.jpg

19. Sortie JSON (DarkHelp) :

DarkHelp --json animaux.names animaux.cfg animaux_best.weights image1.jpg

20. Sélection du GPU (V2) :

Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4

21. Vérification de la précision du réseau :

Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...

22. Contrôle de précision (mAP@IoU=75) :

carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75

23. Recalcul de l'ancre (DarkMark recommandé) :

détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256

24. Former un nouveau réseau :

darknet detector -map -dont_show train cats.data cats.cfg (voir la section formation ci-dessous)

Entraînement

Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :

Configuration : https://pjreddie.com/darknet/yolo/

Sélection du fichier de configuration : https://pjreddie.com/darknet/yolo/

Commande d'entraînement : https://pjreddie.com/darknet/yolo/

L'approche la plus simple en matière d'annotation et de formation consiste à utiliser DarkMark. C'est la méthode recommandée pour former un nouveau réseau de neurones.

Configuration manuelle de la formation :

1. Créez un dossier de projet : par exemple, ~/nn/animals/.

2. Copiez un modèle de configuration :

Choisissez un fichier de configuration (par exemple, cfg/yolov4-tiny.cfg).

Placez-le dans le dossier du projet.

Vous avez maintenant ~/nn/animals/animals.cfg.

3. Créez le fichier animaux.names :

Créez un fichier texte nommé animaux.names dans le dossier du projet.

Modifiez ce fichier avec les classes souhaitées.

Assurez-vous que chaque classe se trouve sur une ligne distincte, sans lignes vides ni commentaires.

Par exemple:

`

chien

chat

oiseau

cheval

`

4. Créez le fichier animaux.data :

Créez un fichier texte nommé animaux.data dans le dossier du projet.

Le contenu doit ressembler à :

`

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 le dossier de l'ensemble de données :

Créez un dossier pour stocker vos images et annotations. Par exemple, ~/nn/animaux/dataset.

Chaque image nécessite un fichier .txt correspondant qui définit ses annotations.

Vous ne pouvez pas créer manuellement ces fichiers .txt ; DarkMark ou des outils similaires sont nécessaires pour annoter vos images et générer ces fichiers.

Reportez-vous à la FAQ Darknet/YOLO pour le format d'annotation YOLO.

6. Créez les fichiers animauxtrain.txt et animauxvalid.txt :

Créez ces fichiers texte comme spécifié dans le fichier animaux.data.

Ces fichiers répertorient toutes les images à utiliser respectivement pour la formation et la validation.

Une image par ligne, utilisant des chemins relatifs ou absolus.

7. Modifiez le fichier de configuration (animaux.cfg) :

Lot : définissez le lot = 64.

Subdivisions : commencez par subdivisions=1. Ajustez si nécessaire en fonction des dimensions du réseau et de la mémoire GPU.

Max Batches : Une bonne valeur de départ est maxbatches=2000 * numberofclasses. Dans cet exemple, maxbatches=8000 (4 animaux).

Étapes : défini sur 80 % et 90 % de max_batches. Dans cet exemple, étapes = 6 400,7 200.

Largeur et Hauteur : Définissez les dimensions du réseau. Reportez-vous à la FAQ Darknet/YOLO pour obtenir des conseils.

Classes : définissez classes=... pour correspondre au nombre de classes dans votre fichier .names (4 dans cet exemple).

Filtres : dans chaque couche convolutive précédant une couche yolo, définissez filters=... sur (numberofclasses + 5) * 3. Dans cet exemple, filters=27.

8. Commencer la formation :

Accédez au dossier de votre projet : cd ~/nn/animals/

Démarrer la formation : darknet detector -map -dont_show train cats.data cats.cfg

Sois patient. Les meilleurs poids seront enregistrés sous le nom animaux_best.weights.

Observez la progression de la formation en consultant le fichier chart.png.

Consultez la FAQ Darknet/YOLO pour des paramètres de formation supplémentaires.

Pour un résultat de formation plus détaillé, ajoutez l'indicateur --verbose :

`bash

détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg

`

Autres outils et liens

DarkMark : pour gérer des projets Darknet/YOLO, annoter des images, vérifier des annotations et générer des fichiers de formation. https://darknetcv.ai/darkmark/

DarkHelp : pour une CLI alternative robuste à Darknet, une mosaïque d'images, un suivi d'objets et une API C++ commerciale. https://darknetcv.ai/darkhelp/

FAQ Darknet/YOLO : pour des réponses aux questions courantes. https://pjreddie.com/darknet/yolo/

Chaîne YouTube de Stéphane : Pour des tutoriels et des exemples de vidéos. https://www.youtube.com/@stephane-charette

Darknet/YOLO Discord Server : pour les questions d'assistance et les discussions de la communauté. https://discord.gg/zSq8rtW

Feuille de route

Dernière mise à jour : 2024-10-30

Complété

Remplacement de qsort() par std::sort() pendant la formation.

Suppression de check_mistakes, getchar() et system().

Migration de Darknet vers le compilateur C++ (g++ sous Linux, VisualStudio sous Windows).

Problèmes de build Windows résolus.

Prise en charge Python réactivée.

Création de la bibliothèque Darknet.

Étiquettes de prédiction réactivées (code "alphabet").

Code CUDA/GPU réactivé.

CUDNN réactivé.

Réactivation de la moitié CUDNN.

Suppression de l'architecture CUDA codée en dur.

Informations sur la version CUDA améliorées.

AVX réactivé.

Suppression des anciennes solutions et du Makefile.

A fait d'OpenCV une dépendance non facultative.

Suppression de la dépendance à l'ancienne bibliothèque pthread.

STB supprimé.

CMakeLists.txt réécrit pour utiliser la nouvelle détection CUDA.

Suppression de l'ancien code "alphabet" et suppression de plus de 700 images dans les données/étiquettes.

Activation de la construction hors source.

Sortie améliorée du numéro de version.

Implémentation d'optimisations de performances liées à la formation (en cours).

Implémentation d'optimisations de performances liées à l'inférence (en cours).

Passage par référence employé, le cas échéant.

Fichiers .hpp nettoyés.

Darknet.h réécrit.

J'ai évité de convertir cv::Mat en void* et je l'ai utilisé comme un objet C++ approprié.

Correction d'incohérences dans l'utilisation de la structure d'image interne.

Version corrigée pour les appareils Jetson basés sur ARM.

Les nouveaux appareils Jetson Orin sont fonctionnels.

Problèmes d'API Python résolus dans la V3.

Objectifs à court terme

Remplacez printf() par std::cout (en cours).

Enquêtez sur l'ancien support de caméra Zed.

Améliorer l'analyse de la ligne de commande pour plus de cohérence (en cours).

Objectifs à moyen terme

Supprimez tout le code char* et remplacez-le par std::string.

Éliminez les avertissements cachés et corrigez les avertissements du compilateur (en cours).

Améliorer l'utilisation de cv::Mat au lieu de la structure d'image C personnalisée (en cours).

Remplacez l'ancienne fonctionnalité de liste par std :: vector ou std :: list.

Correction de la prise en charge des images en niveaux de gris à 1 canal.

Ajoutez la prise en charge des images à canal N où N > 3 (par exemple, images avec profondeur ou canaux thermiques).

Poursuivre le nettoyage du code en cours (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.

Présentez les points clés/squelettes.

Ajout de la prise en charge des cartes thermiques (en cours).

Intégrez la segmentation.