Cadre de détection d'objets Darknet et YOLO
!Logos Darknet et Hank.ai
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 soutient la communauté Darknet/YOLO
Explorez le site officiel Darknet/YOLO
Consultez la FAQ complète Darknet/YOLO
Rejoignez le serveur Discord animé Darknet/YOLO
Papiers
1. Papier YOLOv7
2. Papier YOLOv4 à l'échelle
3. Papier YOLOv4
4. Papier YOLOv3
Informations générales
Le framework Darknet/YOLO continue de repousser les limites des performances, offrant systématiquement une vitesse et une précision dépassant les autres frameworks et versions YOLO. Ce framework est entièrement gratuit et open source, vous permettant d'intégrer de manière transparente Darknet/YOLO dans des projets et produits existants, y compris des applications commerciales, sans avoir besoin de licence ni de frais.
Darknet V3 (« Jazz »), sorti en octobre 2024, atteint des performances remarquables, capables de traiter avec précision des vidéos d'ensembles de données LEGO jusqu'à 1 000 FPS à l'aide d'un GPU NVIDIA RTX 3090. Cela se traduit par Darknet/YOLO gérant chaque image vidéo, y compris le redimensionnement et le traitement, en seulement 1 milliseconde ou moins.
Rejoignez le dynamique serveur Discord Darknet/YOLO sur https://discord.gg/zSq8rtW pour obtenir de l'aide, des discussions et pour vous connecter avec d'autres utilisateurs.
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 de Darknet/YOLO nécessite un GPU compatible CUDA de NVIDIA.
Darknet/YOLO est connu pour fonctionner de manière transparente sous Linux, Windows et Mac. Pour des instructions détaillées, reportez-vous aux sections de construction ci-dessous.
Version Darknet
1. Version 0.x : il s'agit de l'outil Darknet original développé par Joseph Redmon de 2013 à 2017, pour lequel il manquait un numéro de version.
2. Version 1.x : Cela englobe le référentiel Darknet populaire maintenu par Alexey Bochkovskiy entre 2017 et 2021, également sans numéro de version officiel.
3. Version 2.x « OAK » : Cette version a été introduite en 2023, sponsorisée par Hank.ai et maintenue par Stéphane Charette. C'était la première fois que le référentiel Darknet incorporait une commande de version.
- L'objectif était de minimiser les perturbations des fonctionnalités existantes tout en se familiarisant avec la base de code.
- Les principaux changements comprenaient :
- Système de build CMake unifié pour Windows et Linux
- Conversion de la base de code en compilateur C++
- Chart.png amélioré pendant la formation
- Corrections de bugs et optimisations de performances, notamment pour la réduction du temps de formation
- La branche finale de cette base de code était la version 2.1 dans la branche v2.
4. Version 3.x « JAZZ » : Cette phase de développement a débuté mi-2024 et lancée en octobre 2024. La commande version renvoie désormais 3.x.
- Les modifications apportées à cette version incluent :
- Suppression de plusieurs commandes obsolètes et non prises en charge.
- Optimisations complètes des performances pour la formation et l'inférence.
- Modifications de l'ancienne API C, nécessitant des ajustements mineurs pour les applications utilisant l'API Darknet d'origine. La documentation mise à jour pour l'API Darknet V3 C et C++ est disponible sur https://darknetcv.ai/api/api.html.
- Introduction de nouvelles applications et d'exemples de code dans le répertoire src-examples, accessible sur https://darknetcv.ai/api/files.html.
Remarque : pour des raisons de compatibilité, vous pouvez toujours accéder à la branche v2 précédente si vous devez exécuter l'une de ces commandes spécifiques. Veuillez nous contacter si vous rencontrez des commandes manquantes et nous étudierons leur réintégration.
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 contient 80 classes, qui peuvent être visualisées dans le fichier texte cfg/coco.names.
Au-delà de MSCOCO, vous pouvez trouver d'autres poids pré-entraînés et des ensembles de données plus simples pour tester Darknet/YOLO, tels que LEGO Gears et Rolodex. Des informations détaillées peuvent être trouvées dans la FAQ Darknet/YOLO.
Les poids pré-entraînés MSCOCO sont accessibles à partir de divers endroits, y compris au sein de ce référentiel :
1. YOLOv2 (novembre 2016)
- yolov2-tiny.weights
- yolov2-full.weights
2. YOLOv3 (mai 2018)
- yolov3-tiny.weights
- yolov3-full.weights
3. YOLOv4 (mai 2020)
- yolov4-tiny.weights
- yolov4-full.weights
4. YOLOv7 (août 2022)
- yolov7-tiny.weights
- yolov7-full.weights
Les poids pré-entraînés MSCOCO sont fournis principalement à 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 essentiel de comprendre que former vos propres réseaux est la pratique recommandée. MSCOCO est principalement utilisé pour vérifier le bon fonctionnement de Darknet/YOLO.
Bâtiment
Les différentes méthodes de construction utilisées dans le passé (avant 2023) ont été rationalisées en une solution unifiée. Darknet nécessite C++ 17 ou version ultérieure, OpenCV et utilise CMake pour la génération de fichiers de projet.
N'oubliez pas que la création, l'installation et l'exécution de Darknet/YOLO ne nécessitent pas de connaissances en C++. C'est comme conduire une voiture sans être mécanicien.
Remarque : Si vous faites référence à des didacticiels plus anciens comportant des étapes de construction plus complexes ou à ceux qui ne correspondent pas à ce fichier Lisez-moi, procédez avec prudence. Les nouvelles instructions de construction décrites ci-dessous ont été introduites en août 2023.
Pour obtenir un aperçu du fonctionnement interne du cadre de détection d'objets Darknet/YOLO, les développeurs de logiciels sont encouragés à visiter https://darknetcv.ai/.
Google Colab
Les instructions de Google Colab sont identiques aux instructions de Linux. Plusieurs notebooks Jupyter sont disponibles, démontrant comment effectuer 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
Tutoriel de construction Darknet pour Linux
1. Installer les dépendances :
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Cloner le référentiel Darknet :
`bash
mkdir ~/srccd ~/src
clone git https://github.com/hank-ai/darknet
cd darknet
`
3. Créez un répertoire de construction :
`bash
mkdir buildcd construire
`
4. Configurez à l'aide de CMake :
`bash
cmake -DCMAKEBUILDTYPE=Version ..
`
5. Créez le Darknet :
`bash
faire -j4
`
6. Package et installation :
`bash
emballer
sudo dpkg -i darknet-VERSION.deb
`
Facultatif : installation de CUDA et cuDNN
Pour un traitement accéléré des images et des vidéos, vous pouvez éventuellement installer CUDA ou CUDA+cuDNN. Darknet exploitera votre GPU si disponible.
1. Installez CUDA :
- Téléchargez et installez CUDA depuis https://developer.nvidia.com/cuda-downloads.
- Assurez-vous que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.
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-package-manager- aperçu de l'installation.
Si vous installez CUDA ou CUDA+cuDNN après la configuration initiale ou la mise à niveau du logiciel NVIDIA :
1. Supprimez CMakeCache.txt :
- Supprimez le fichier CMakeCache.txt de votre répertoire de build Darknet pour forcer CMake à redécouvrir toutes les dépendances.
2. Reconstruisez Darknet :
- Répétez le cmake et suivez les étapes ci-dessus.
Remarque : ces instructions supposent Ubuntu 22.04, mais peuvent être adaptées pour d'autres distributions.
Utilisateurs avancés :
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, mettez à jour ces deux lignes :
`cmake
ENSEMBLE (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Pour les distributions comme Centos et OpenSUSE, ajustez les lignes comme suit :
`cmake
ENSEMBLE (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Après la construction, installez le package à l'aide du gestionnaire de packages de votre distribution. Par exemple, sur les systèmes basés sur Debian :
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Résultat de l'installation :
/usr/bin/darknet : L'exécutable Darknet standard. Exécutez la version darknet pour vérifier l’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 : bibliothèque pour lier des projets C, C++ et Python.
/opt/darknet/cfg/... : emplacement de tous les modèles .cfg.
Confirmation : exécutez la version Darknet sur votre terminal pour confirmer la réussite de l'installation de Darknet.
Méthode Windows CMake
Instructions de construction de Windows (en supposant Windows 11 22H2)
1. Installer les dépendances :
`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 le menu "Démarrer de Windows" et exécutez "Visual Studio Installer".
- 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 :
- 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. Installez Microsoft VCPKG :
`bash
CDC:
mkdir c:srccd c: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
`
5. Facultatif : Installation de CUDA et cuDNN :
- Installez CUDA ou CUDA+cuDNN pour l'accélération GPU.
- Suivez les mêmes étapes que dans les instructions Linux.
6. Clonez Darknet et construisez :
`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 des erreurs concernant des DLL CUDA ou cuDNN manquantes (par exemple, cublas64_12.dll) :
1. Copiez les DLL CUDA :
- 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
`
2. Réexécutez msbuild.exe :
- Exécutez à nouveau la dernière commande msbuild.exe pour générer le package d'installation NSIS.
Utilisateurs avancés :
Au lieu de l'invite de commande du développeur, vous pouvez utiliser une invite de commande normale ou SSH et exécuter « Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat ».
La commande cmake génère un fichier de solution Visual Studio (Darknet.sln). Si vous préférez utiliser l'interface graphique de Visual Studio, chargez le projet au lieu de vous fier aux outils de ligne de commande.
Confirmation : exécutez la version C:srcDarknetbuildsrc-cliReleasedarknet.exe pour vérifier l'installation.
Installation à l'aide de l'assistant NSIS :
Exécutez l'assistant d'installation NSIS trouvé dans le répertoire de construction (par exemple, darknet-VERSION.exe). Cela va :
- Créez un répertoire Darknet (par exemple, C:Program FilesDarknet).
- Installez l'application CLI, darknet.exe et d'autres exemples d'applications.
- Installez les fichiers .dll tiers nécessaires (par exemple, à partir d'OpenCV).
- Installez les fichiers Darknet .dll, .lib et .h pour les utiliser dans d'autres applications.
- Installez les fichiers modèles .cfg.
Confirmation : après l'installation, exécutez la version C:Program FilesDarknetbindarknet.exe pour confirmer que Darknet est prêt.
Utiliser le Darknet
CLI
Ce qui suit est une liste partielle des commandes prises en charge par Darknet.
En plus de la CLI Darknet, pensez à la CLI du projet DarkHelp, offrant une CLI alternative avec des fonctionnalités avancées non directement disponibles dans Darknet. Vous pouvez utiliser les deux CLI ensemble.
Pour la plupart des commandes, 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 des réseaux pré-entraînés disponibles gratuitement en ligne. Les exemples incluent :
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 Darknet courantes :
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. 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
`
7. Enregistrez les résultats 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. Sélection du GPU :
- 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 du réseau :
- Calculer la carte :
`bash
Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ...
`
- Informations détaillées sur la précision :
`bash
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 lumière rouge 94,1033 3449 217 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885
`
- Calculer mAP@IoU=75 :
`bash
carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75
`
- Calculer les ancres :
`bash
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
11. Former un nouveau réseau :
`bash
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
Entraînement
Liens essentiels vers la FAQ Darknet/YOLO :
Configuration des fichiers et des répertoires
Choisir le bon fichier de configuration
Entraînement d'une commande réseau personnalisée
Pour une annotation et une formation transparentes, DarkMark simplifie le processus en créant automatiquement tous les fichiers Darknet nécessaires. L'utilisation de DarkMark est fortement recommandée pour former un nouveau réseau neuronal.
Configuration manuelle de la formation :
1. Créez un répertoire de projet :
- Par exemple, créez un répertoire nommé ~/nn/animals/ pour détecter les animaux.
2. Copiez le fichier de configuration :
- Copiez un fichier de configuration Darknet approprié comme modèle (par exemple, cfg/yolov4-tiny.cfg) dans le répertoire de votre projet. Cela crée ~/nn/animals/animals.cfg.
3. Créez le fichier animaux.names :
- Créez un fichier texte nommé animaux.names dans le même répertoire.
- Listez les cours souhaités, un par ligne, 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. Le contenu doit être :
`
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 répertoire d'ensembles de données :
- Créez un répertoire (par exemple, ~/nn/animals/dataset) pour stocker les images et les annotations. Chaque image nécessite un fichier .txt correspondant définissant ses annotations. Le format est spécifique et ne peut pas être créé manuellement. Utilisez DarkMark ou un logiciel similaire pour annoter les images. Le format d'annotation YOLO est expliqué dans la FAQ Darknet/YOLO.
6. Créez des fichiers de formation et de validation :
- Créez les fichiers animauxtrain.txt et animauxvalid.txt mentionnés dans le fichier .data. Ces fichiers répertorient respectivement toutes les images pour la formation et la validation, une image par ligne. Les chemins peuvent être relatifs ou absolus.
7. Configurez le fichier .cfg :
- Ouvrez votre fichier .cfg avec un éditeur de texte.
- Assurez-vous que le lot = 64.
- Ajustez les subdivisions en fonction des dimensions du réseau et de la mémoire GPU. Commencez par subdivisions=1. Reportez-vous à la FAQ Darknet/YOLO pour connaître les valeurs alternatives.
- Définissez max_batches sur 2000 * nombre de classes (par exemple, 8000 pour 4 classes).
- Définissez les étapes à 80 % et 90 % des lots maximum (par exemple, 6 400,7 200 pour des lots maximum = 8 000).
- Configurez la largeur et la hauteur (dimensions du réseau) à l'aide des directives de la FAQ Darknet/YOLO.
- Remplacez classes=... par le nombre de classes de votre fichier .names (par exemple, classes=4).
- Modifier filters=... dans la section [convolutional] avant chaque section [yolo]. Utilisez la formule (nombre de classes + 5) * 3 (par exemple, filtres = 27 pour 4 classes).
8. Commencer la formation :
- Accédez au répertoire de votre projet :
`bash
cd ~/nn/animaux/
`
- Exécutez la commande d'entraînement :
`bash
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
9. Surveiller les progrès :
- Les meilleurs poids seront enregistrés sous le nom cats_best.weights.
- Suivez la progression de la formation en affichant le fichier chart.png.
- Consultez la FAQ Darknet/YOLO pour des paramètres de formation supplémentaires.
10. Formation détaillée :
- Pour un résultat plus détaillé pendant la formation, incluez le paramètre --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.
DarkHelp : fournit une CLI alternative robuste pour Darknet, la mosaïque d'images, le suivi des objets dans les vidéos et une API C++ complète pour les applications commerciales.
FAQ Darknet/YOLO : Une ressource précieuse pour répondre à vos questions.
Chaîne YouTube de Stéphane : De nombreux tutoriels et exemples de vidéos.
Serveur Discord Darknet/YOLO : rejoignez la communauté pour obtenir de l'aide et des discussions.
Feuille de route
Dernière mise à jour : 2024-10-30
Complété:
Remplacement de qsort() par std::sort() pendant la formation (sauf pour quelques cas restants).
Suppression de check_mistakes, getchar() et system().
Conversion de Darknet pour utiliser le compilateur C++ (g++ sous Linux, VisualStudio sous Windows).
Correction de la version Windows.
Prise en charge Python activée.
Création de la bibliothèque Darknet.
Étiquettes de prédiction réactivées (en utilisant le code "alphabet").
Code CUDA/GPU réactivé.
Réactivation de CUDNN et CUDNN moitié.
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.
Rendu OpenCV non facultatif.
Suppression de la dépendance à l'ancienne bibliothèque pthread.
STB supprimé.
CMakeLists.txt réécrit pour une 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 pendant la formation (en cours).
Implémentation d'optimisations de performances lors de l'inférence (en cours).
Passage par référence utilisé lorsque cela est possible.
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'une utilisation incohérente de la structure interne de l'image.
Correction de problèmes de construction pour les appareils Jetson basés sur ARM (à l'exception des modèles Jetson d'origine non pris en charge).
Les appareils Jetson Orin sont fonctionnels.
Correction de l'API Python dans la V3.
Prise en charge améliorée de Python (recherche de développeurs Python pour contribuer).
Objectifs à court terme :
Remplacez printf() par std::cout (en cours).
Revisitez la prise en charge des anciennes caméras Zed.
Améliorer et assurer la cohérence de l'analyse de la ligne de commande (en cours).
Objectifs à moyen terme :
Éliminez tout le code char* et remplacez-le par std::string.
Afficher les avertissements et adresser les avertissements du compilateur (en cours).
Optimisez 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 (N > 3).
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".
Ajoutez des points clés/squelettes.
Implémentation de cartes thermiques (en cours).
Introduire la fonctionnalité de segmentation.
