HmacManager

HmacManager

Résumé

L'éditeur de Downcodes vous propose HmacManager, un outil d'authentification HMAC pour les applications ASP.NET Core, offrant une intégration transparente et une sécurité renforcée pour vos applications.

Caractéristiques

Authentification HMAC : HmacManager fournit l'authentification HMAC, vous permettant d'ajouter une couche d'authentification sécurisée à votre API ASP.NET Core.

Configuration facile : avec des options de configuration simples, vous pouvez rapidement intégrer l'authentification HMAC dans vos applications.

Options de personnalisation : HmacManager propose des options de personnalisation afin que vous puissiez le configurer en fonction de vos besoins.

Sécurité améliorée : l'authentification HMAC améliore la sécurité de votre API en utilisant l'algorithme de hachage HMAC pour authentifier les requêtes.

Installation

HmacManager est disponible sur NuGet.

`bash

dotnet ajoute le package HmacManager

`

Ressources

Lectures complémentaires : Documentation officielle

Exemple de code : référentiel GitHub

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 avancé de détection de cibles en temps réel fonctionnant dans le framework Darknet.

1. Documents

YOLOv7 : lien papier

Scaled-YOLOv4 : lien papier

YOLOv4 : lien papier

YOLOv3 : lien papier

2. Informations générales

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

Le framework est entièrement gratuit et open source. Vous pouvez intégrer Darknet/YOLO dans des projets et produits existants, y compris des produits commerciaux, sans licence ni frais.

Darknet V3 (« Jazz »), sorti en octobre 2024, peut exécuter avec précision des vidéos d'ensembles de données LEGO jusqu'à 1 000 FPS lors de l'utilisation d'un GPU NVIDIA RTX 3090, ce qui signifie que chaque image vidéo prend 1 milliseconde ou moins. Lue, redimensionnée et traitée par Darknet. /YOLO en secondes.

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

La version CPU de Darknet/YOLO peut fonctionner sur des appareils simples tels que le Raspberry Pi, des serveurs cloud, des serveurs Colab, des ordinateurs de bureau, des ordinateurs portables et des équipements de formation haut de gamme. La version GPU de Darknet/YOLO nécessite un GPU prenant en charge NVIDIA CUDA.

Darknet/YOLO est connu pour fonctionner correctement sous Linux, Windows et Mac. Voir les instructions de construction ci-dessous.

3. Version Darknet

Version 0.x : L'outil Darknet original écrit par Joseph Redmon en 2013-2017 n'a pas de numéro de version.

Version 1.x : Le prochain référentiel Darknet populaire maintenu par Alexey Bochkovskiy entre 2017 et 2021 n'a pas non plus de numéro de version.

Version 2.x (« OAK ») : Le référentiel Darknet sponsorisé par Hank.ai et maintenu par Stéphane Charette à partir de 2023 est le premier à disposer d'une commande de version. De 2023 à fin 2024, il revient à la version 2.x « OAK ».

Version 3.x (« JAZZ ») : Prochaine phase de développement débutant mi-2024, avec sortie en octobre 2024. La commande version renvoie désormais 3.x "JAZZ".

4. Poids de pré-entraînement MSCOCO

Pour plus de commodité, plusieurs versions populaires de YOLO sont pré-entraînées sur l'ensemble de données MSCOCO. Cet ensemble de données contient 80 catégories et peut être consulté dans le fichier texte cfg/coco.names.

Il existe d'autres ensembles de données plus simples et poids pré-entraînés 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 emplacements différents ou à partir de 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 uniquement destinés à des fins de démonstration. Les fichiers .cfg et .names correspondants se trouvent dans le répertoire cfg. Exemple de commande :

`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 vidéo1. avi

`

Notez qu’il faut former son propre réseau. MSCOCO est souvent utilisé pour confirmer que tout va bien.

5. Construire

Diverses méthodes de construction du passé (avant 2023) ont été fusionnées en une solution unifiée. Darknet nécessite C++ 17 ou supérieur, OpenCV et l'utilisation de CMake pour générer les fichiers de projet nécessaires.

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.

5.1 Google Colab

Les instructions de Google Colab sont les mêmes que celles de Linux. Plusieurs notebooks Jupyter montrent comment effectuer certaines tâches, telles que la formation d'un nouveau réseau.

Consultez le notebook dans le sous-répertoire colab ou suivez les instructions Linux ci-dessous.

5.2 Méthode Linux CMake

Tutoriel de construction Darknet sur Linux

`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 build cmake -DCMAKEBUILDTYPE=Release .. make -j4 package sudo dpkg -i darknet-VERSION.deb

`

5.3 Méthode Windows CMake

Ces instructions supposent une nouvelle installation de Windows 11 22H2.

`bash

Winget installe Git.Git Winget installe Kitware.CMake Winget installe nsis.nsis Winget installe Microsoft.VisualStudio.2022.Community

`

Nous devons ensuite modifier l'installation de Visual Studio pour inclure la prise en charge des applications C++ :

* Cliquez sur le menu Démarrer de Windows et exécutez Visual Studio Installer.

* Cliquez sur "Modifier".

* Sélectionnez "Développement bureautique en C++".

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

Une fois que tout est téléchargé et installé, cliquez à nouveau sur le menu « Démarrer de Windows » et sélectionnez « Invite de commandes du développeur pour VS 2022 ». N'utilisez pas PowerShell pour effectuer ces étapes, sinon vous rencontrerez des problèmes !

Utilisateurs avancés :

* En plus d'exécuter l'invite de commande du développeur, vous pouvez également utiliser une invite de commande normale ou SSH sur l'appareil et exécuter manuellement « Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat ».

Une fois que vous avez suivi les instructions ci-dessus et exécuté l'invite de commande du développeur (pas PowerShell !), exécutez la commande suivante pour installer Microsoft VCPKG, qui sera ensuite utilisé pour créer OpenCV :

`bash

cd c:mkdir c:srccd c:src git clone https://github.com/microsoft/vcpkgcd vcpkg 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, monde]: x64-windows

`

Soyez patient avec cette dernière étape car son exécution prend beaucoup de temps. Cela nécessite de télécharger et de créer beaucoup de choses.

Utilisateurs avancés :

* Veuillez noter qu'il existe de nombreux autres modules optionnels que vous souhaiterez peut-être ajouter lors de la création d'OpenCV. Exécutez la recherche .vcpkg.exe opencv pour voir la liste complète.

Facultatif : si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer CUDA ou 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 du répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.

N'oubliez pas de reconstruire le Darknet.

Darknet peut fonctionner sans lui, mais si vous souhaitez former un réseau personnalisé, vous avez besoin de CUDA ou CUDA+cuDNN.

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#cudnn-package-manager-installation-overview pour télécharger et installez cuDNN.

Après avoir installé CUDA, assurez-vous de pouvoir exécuter nvcc.exe et nvidia-smi.exe. Vous devrez peut-être modifier la variable PATH.

Après avoir téléchargé cuDNN, décompressez-le 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.

Une fois toutes les étapes précédentes terminées avec succès, vous devez cloner Darknet et le créer. Dans cette étape, nous devons également indiquer à CMake où se trouve vcpkg afin qu'il puisse trouver OpenCV et d'autres dépendances :

`bash

cd c:src git clone https://github.com/hank-ai/darknet.gitcd darknetmkdir buildcd build 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 certaines DLL CUDA ou cuDNN manquantes (par exemple, cublas64_12.dll), copiez manuellement le fichier 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

`

(Voici un exemple ! Vérifiez quelle version vous utilisez et exécutez la commande appropriée pour la version que vous avez installée.)

Une fois les fichiers copiés, 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 :

* Veuillez noter que la sortie de la commande cmake est le fichier de solution Visual Studio normal, Darknet.sln. Si vous êtes un développeur de logiciels qui utilise fréquemment l'interface graphique de Visual Studio au lieu de msbuild.exe pour créer des projets, vous pouvez ignorer la ligne de commande et charger le projet Darknet dans Visual Studio.

Vous devriez maintenant avoir ce fichier prêt à être exécuté : C:srcDarknetbuildsrc-cliReleasedarknet.exe. Exécutez la commande suivante pour tester : version C:srcDarknetbuildsrc-cliReleasedarknet.exe.

Pour installer correctement Darknet, les bibliothèques, les fichiers d'inclusion et les DLL nécessaires, exécutez l'assistant d'installation NSIS créé à l'étape précédente. Voir le fichier darknet-VERSION.exe dans le répertoire build. Par exemple:

`bash

darknet-2.0.31-win64.exe

`

L'installation du package d'installation NSIS :

* Créez un répertoire nommé Darknet, par exemple C:Program FilesDarknet.

* Installez l'application CLI, darknet.exe et d'autres exemples d'applications.

* Installez les fichiers .dll tiers requis, tels que ceux d'OpenCV.

* Installez les fichiers Darknet .dll, .lib et .h nécessaires pour utiliser darknet.dll à partir d'autres applications.

* Installez le fichier modèle .cfg.

Vous avez terminé maintenant ! Une fois l'assistant d'installation terminé, Darknet sera installé dans C:Program FilesDarknet. Exécutez la commande suivante pour tester : version C:Program FilesDarknetbindarknet.exe.

Si vous n'avez pas C:/Program Files/darknet/bin/darknet.exe, vous ne l'avez pas installé, vous venez de le construire ! Assurez-vous de parcourir chaque panneau de l'assistant d'installation NSIS à l'étape précédente.

6. Utilisez le Darknet

6.1 CLI

Ce qui suit n'est pas une liste complète de toutes les commandes prises en charge par Darknet.

En plus de la CLI Darknet, notez également la CLI du projet DarkHelp, qui propose une alternative à la CLI Darknet/YOLO. DarkHelp CLI présente également des améliorations introuvables dans Darknet. Vous pouvez utiliser Darknet CLI et DarkHelp CLI ensemble, ils ne s'excluent pas mutuellement.

Pour la plupart des commandes présentées ci-dessous, vous aurez besoin d'un fichier .weights avec les fichiers .names et .cfg correspondants. Vous pouvez entraîner le réseau vous-même (fortement recommandé !), ou vous pouvez télécharger des réseaux de neurones formés par d'autres et disponibles gratuitement sur Internet. Voici des exemples d'ensembles de données de pré-formation :

* LEGO Gears (trouver des objets dans les images)

* Rolodex (trouver du texte dans l'image)

* MSCOCO (détection de cible standard de catégorie 80)

Les commandes à exécuter incluent :

* Répertoriez quelques commandes et options possibles qui peuvent être exécutées :

`bash

aide sur le darknet

`

* Vérifier la version :

`bash

version darknet

`

* Utilisez des images pour la prédiction :

`bash

V2 : test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg

V3 : darknet02displayannotatedimages cars.cfg image1.jpg

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

`

* Coordonnées de sortie :

`bash

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

V3 : darknet01inference_images animaux chien.jpg

DarkHelp : DarkHelp --json animaux.cfg animaux.names animaux_best.weights dog.jpg

`

*Utiliser la vidéo :

`bash

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

V3 : darknet03display_videos animaux.cfg test.mp4

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

`

* Lecture depuis webcam :

`bash

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

V3 : animaux darknet08display_webcam

`

* Enregistrer les résultats dans la vidéo :

`bash

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

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

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

`

*JSON :

`bash

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

V3 : darknet06imagestojson animaux image1.jpg

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

`

* Exécutez sur des GPU spécifiques :

`bash

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

`

* Vérifiez l'exactitude 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 1 50 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 10 4116 0,8904 0,1096 0,7943 0,8918 0,8898 0,1102 6 jaune clair 82,0390 126 38 30 1239 0,9525 0,0475 0,8077 0,7683 0,9764 0,0236 7 clair 94,1033 3449 2 17 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885

`

* Vérifier la précision mAP@IoU=75 :

`bash

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

`

* Il est préférable de recalculer les points d'ancrage dans DarkMark, car il s'exécutera 100 fois de suite et sélectionnera le meilleur point d'ancrage parmi tous les points d'ancrage calculés. Cependant, si vous souhaitez exécuter une ancienne version dans 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

`

6.2 Formation

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

* Comment dois-je configurer mes fichiers et répertoires ?

* Quel profil dois-je utiliser ?

* Quelle commande dois-je utiliser lors de la formation de mon propre réseau ?

Créez tous les fichiers Darknet nécessaires à l'aide de DarkMark, qui constitue le moyen le plus simple d'annoter et de former. C'est certainement la méthode recommandée pour former de nouveaux réseaux de neurones.

Si vous souhaitez paramétrer manuellement les différents fichiers pour entraîner un réseau personnalisé :

* Créez un nouveau dossier pour stocker les fichiers. Pour cet exemple, un réseau de neurones sera créé pour détecter les animaux, donc le répertoire suivant sera créé : ~/nn/animals/.

* Copiez l'un des fichiers de configuration Darknet que vous souhaitez utiliser comme modèle. Par exemple, consultez cfg/yolov4-tiny.cfg. Placez-le dans le dossier que vous avez créé. Pour cet exemple, nous avons maintenant ~/nn/animals/animals.cfg.

* Créez un fichier texte animaux.names dans le même dossier où vous avez placé le fichier de configuration. Pour cet exemple, nous avons maintenant ~/nn/animals/animals.names.

* Utilisez un éditeur de texte pour modifier le fichier animaux.names. Répertoriez les catégories que vous souhaitez utiliser. Vous avez besoin d’exactement une entrée par ligne, pas de lignes vides ni de commentaires. Pour cet exemple, le fichier .names contiendra exactement 4 lignes :

`

chien

chat

oiseau

cheval

`

* 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

`

* 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 qui décrit les annotations de cette image. Le format des fichiers de commentaires .txt est très spécifique. Vous ne pouvez pas créer ces fichiers manuellement car chaque annotation doit contenir les coordonnées précises de l'annotation. Consultez DarkMark ou un autre logiciel similaire pour annoter vos images. Le format d'annotation YOLO est décrit dans la FAQ Darknet/YOLO.

* Créez des fichiers texte "train" et "valide" nommés dans le fichier .data. Ces deux fichiers texte doivent répertorier séparément toutes les images que Darknet doit utiliser pour s'entraîner et valider lors du calcul de mAP%. Exactement une image par ligne. Les chemins et les noms de fichiers peuvent être relatifs ou absolus.

* Utilisez un éditeur de texte pour modifier votre fichier .cfg.

* Assurez-vous que lot = 64.

* Faites attention aux subdivisions. En fonction de la taille du réseau et de la quantité de mémoire disponible sur le GPU, vous devrez peut-être augmenter les subdivisions. La meilleure valeur à utiliser est 1, alors commencez par cela. Si vous ne parvenez pas à utiliser 1, veuillez consulter la FAQ Darknet/YOLO.

Notez que maxbatches=…. Une bonne valeur pour commencer est 2 000 fois le nombre de catégories. Pour cet exemple nous avons 4 animaux, donc 4 2000 = 8000. Cela signifie que nous utiliserons maxbatches=8000.

* Notez les étapes =..... Cela doit être défini sur 80 % et 90 % des lots maximum. Pour cet exemple, nous utiliserons steps=6400,7200 puisque maxbatches est défini sur 8000.

* Notez largeur=... et hauteur=..... Ce sont des dimensions de réseau. La FAQ Darknet/YOLO explique comment calculer la taille optimale à utiliser.

* Recherchez toutes les instances de lignes classes=... et modifiez-les avec le nombre de classes dans le fichier .names. Pour cet exemple, nous utiliserons classes=4.

Recherche les instances de toutes les lignes filters=... dans la section [convolutionnelle] avant chaque section [yolo]. La valeur à utiliser est (nombre de catégories + 5) 3. Cela signifie que pour cet exemple, (4 + 5) * 3 = 27. Nous utiliserons donc filters=27 sur la ligne correspondante.

* Commencez la formation ! Exécutez la commande suivante :

`bash

cd ~/nn/animaux/ détecteur darknet -map -dont_show train animaux.data animaux.cfg

`

* S'il vous plaît, attendez. Les meilleurs poids seront enregistrés sous le nom animaux_best.weights. Et vous pouvez observer la progression de la formation en consultant le fichier chart.png. Consultez la FAQ Darknet/YOLO pour connaître les paramètres supplémentaires que vous souhaiterez peut-être utiliser lors de la formation d'un nouveau réseau.

* Si vous souhaitez voir plus de détails pendant l'entraînement, ajoutez le paramètre --verbose. Par exemple:

`bash

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

`

7. Autres outils et liens

Pour gérer votre projet Darknet/YOLO, annoter des images, valider vos annotations et générer les fichiers nécessaires à la formation avec Darknet, voir DarkMark.

Pour une alternative puissante à la CLI Darknet, pour utiliser la mosaïque d'images, le suivi d'objets dans la vidéo ou pour obtenir une API C++ puissante qui peut être facilement utilisée dans des applications commerciales, consultez DarkHelp.

Veuillez consulter la FAQ Darknet/YOLO pour obtenir de l'aide pour répondre à vos questions.

Découvrez les nombreux tutoriels et exemples de vidéos sur la chaîne YouTube de Stéphane.

Si vous avez des questions d'assistance ou souhaitez discuter avec d'autres utilisateurs de Darknet/YOLO, veuillez rejoindre le serveur Discord Darknet/YOLO.

8. Feuille de route

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

* Complété

* Remplacement de qsort() par std::sort() pendant la formation (un autre code obscur existe toujours)

* Débarrassez-vous de check_mistakes, getchar() et system()

* Convertir Darknet pour utiliser un compilateur C++ (g++ sous Linux, VisualStudio sous Windows)

* Correction de la version Windows

* Correction de la prise en charge de Python

* Créer une bibliothèque darknet

* Réactiver les labels dans les prédictions (code "alphabet")

* Réactiver le code CUDA/GPU

* Réactiver CUDNN

* Réactiver la moitié CUDNN

* Ne codez pas en dur l'architecture CUDA

* Meilleures informations sur la version CUDA

* Réactiver AVX

* Supprimez l'ancienne solution et le Makefile

* Rendre OpenCV non facultatif

* Supprimer la dépendance à l'ancienne bibliothèque pthread

* Supprimer le STB

* Réécrivez CMakeLists.txt 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

*Construire en dehors du code source

* A une meilleure sortie du numéro de version

* Optimisation des performances liées à la formation (tâche continue)

* Optimisation des performances liées à l'inférence (tâche en cours)

* Utilisez des références de passage par valeur chaque fois que possible

* Nettoyer les fichiers .hpp

* Réécrire darknet.h

Ne lancez pas cv::Mat en void, utilisez-le comme un objet C++ approprié

* Corriger ou maintenir une utilisation cohérente des structures d'image internes

* Correction de la construction du périphérique Jetson à architecture ARM

*Il est peu probable que les appareils Jetson d'origine soient réparés car ils ne sont plus pris en charge par NVIDIA (pas de compilateur C++17)

* Le nouvel appareil Jetson Orin est désormais en cours d'exécution

* Correction de l'API Python en V3

* Besoin d'un meilleur support Python (des développeurs Python veulent-ils aider ?)

* Objectifs à court terme

* Remplacez printf() par std::cout (travail en cours)

* Découvrez l'ancien support de caméra zed

* Analyse de ligne de commande meilleure et plus cohérente (travail en cours)

* Objectifs à moyen terme

Supprimez tous les codes de caractères et remplacez-les par std :: string

* Ne cachez pas les avertissements et nettoyez les avertissements du compilateur (travail en cours)

* Meilleure utilisation de cv::Mat au lieu des structures d'images personnalisées en C (travail 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

* Ajout de la prise en charge des images à canal N où N > 3 (par exemple, images avec une profondeur supplémentaire ou des canaux chauds)

* Nettoyage continu du code (en cours)

* Objectifs à long terme

* Correction des problèmes CUDA/CUDNN sur tous les GPU

* Réécrire le code CUDA+cuDNN

* Pensez à ajouter la prise en charge des GPU non NVIDIA

* Boîte englobante pivotée, ou une forme de support "d'angle"

*Points clés/squelette

* Heatmap (travail en cours)

* Diviser