Système de requête de score universel adaptatif intelligent Asp+Csv v20210730
20210730
Système d'enquête de score universel adaptatif intelligent Asp + Csv
Aujourd'hui, l'éditeur de Downcodes vous présentera un système de requête développé et publié basé sur ASP pour interroger des données au format csv s'adapte intelligemment au système de requête de score universel.
Ce logiciel est extrêmement simple mais constitue un système de requête de score très polyvalent et pratique qui peut être utilisé pour interroger presque tous les tableaux de données Excel unidimensionnels et bidimensionnels.
But
Ce système convient à diverses demandes précises telles que les grades, les salaires, les factures de services publics, etc. qui sont rarement modifiées et ont une faible confidentialité. Les scénarios d'utilisation spécifiques sont les suivants :
1. Système de requête de score : applicable à chaque école, établissement d’enseignement, examen d’établissement public, etc.
2. Système de requête sur les salaires : applicable à chaque école, établissement d'enseignement, examen d'établissement public, etc.
3. Système de demande de renseignements sur les frais fonciers : applicable à chaque entreprise, école et toutes les unités.
4. Système de demande de factures de services publics : adapté aux communautés, aux sociétés immobilières, aux dortoirs universitaires, etc.
5. Autres systèmes de requête : tels que la requête de placement de classe, la requête d'admission, la requête de certificat et d'autres systèmes de requête avec quelques modifications.
Caractéristiques et avantages
1. Haute polyvalence : il peut être utilisé dans presque tous les tableaux bidimensionnels et peut répondre à la plupart de vos besoins.
2. Simple et pratique : le code est petit et simple, et peut être rapidement modifié pour s'adapter à divers scénarios tels qu'une requête conjointe multi-tables.
3. Flexible et facile à utiliser : modifiez simplement quelques paramètres pour personnaliser la requête.
4. Utilisation rapide : La publication d'un score peut être résolue en deux à trois minutes au plus rapidement.
Limites
1. Ne convient pas aux modifications fréquentes : Les résultats, les salaires, les factures d'eau et d'électricité, etc. sont généralement publiés en une seule fois sans modification. Ce système n'est pas adapté aux scénarios où les modifications sont fréquentes.
2. Convient uniquement aux tableaux bidimensionnels : généralement, les bases de données adoptent une structure bidimensionnelle, avec des en-têtes dans la première ligne et les lignes suivantes, et une donnée par ligne par la suite. Ce système ne prend actuellement pas en charge les données dans d'autres structures.
3. Contrôle recommandé du nombre d'enregistrements dans une seule base de données : ce système ne limite pas le nombre d'enregistrements dans une seule base de données, mais il est recommandé que le nombre d'enregistrements dans une seule base de données soit contrôlé dans la limite de 30 000, et les bases de données peuvent être divisés en bases de données sans s’influencer mutuellement.
4. Les formules, images, URL, etc. ne sont pas prises en charge pour le moment : Ce système ne prend pas en charge les formules, images, URL, etc.
Suggestions d'utilisation
Il peut être utilisé directement en téléchargeant via FTP. Il est recommandé de télécharger directement pour tester les requêtes en premier.
Accès frontal : http://website/directory/ (téléchargement pour une utilisation directe sans le support de la base de données mysql, etc.)
Utilisez ensuite notepad++ pour ouvrir inc/conn.Asp afin d'afficher la relation correspondante entre les paramètres et les pages Web, puis ouvrez la base de données intégrée par défaut pour comparer les résultats de la requête et afficher la relation correspondante.
Étapes d'utilisation
Pour plus de détails, consultez le fichier au format HTML dans le package compressé.
Exemple
Ce qui suit prend Darknet Object Detection Framework et YOLO comme exemple pour montrer comment utiliser l'élément de balise de titre de Markdown et certains ajustements de mise en page pour rendre l'affichage des informations plus soigné et plus pratique à lire pour les utilisateurs :
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 fonctionnant dans le framework Darknet.
Papiers
Papier YOLOv7
Papier à l'échelle-YOLOv4
Papier YOLOv4
Papier YOLOv3
Informations générales
Le framework Darknet/YOLO continue d'être plus rapide et plus précis que les autres frameworks et versions YOLO.
Le framework est entièrement gratuit et open source. Vous pouvez utiliser 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.
Si vous avez besoin d'aide ou souhaitez discuter de Darknet/YOLO, veuillez rejoindre 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 et Colab, des ordinateurs de bureau, des ordinateurs portables et des équipements de formation haut de gamme. La version GPU de Darknet/YOLO nécessite le GPU compatible CUDA de NVIDIA.
Darknet/YOLO est connu pour fonctionner sous Linux, Windows et Mac. Veuillez consulter les instructions de construction ci-dessous.
Version Darknet
Les outils Darknet originaux, écrits par Joseph Redmon en 2013-2017, n'avaient pas de numéro de version. Nous pensons qu'il s'agit de la version 0.x.
Le prochain référentiel Darknet populaire maintenu par Alexey Bochkovskiy de 2017 à 2021 n'a pas non plus de numéro de version. Nous pensons qu'il s'agit de la version 1.x.
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 ».
L’objectif est de se familiariser avec la base de code tout en essayant de casser le moins de fonctionnalités existantes possible.
Réécriture des étapes de construction afin que nous ayons une approche unifiée de la construction sous Windows et Linux à l'aide de CMake.
Convertissez la base de code pour utiliser un compilateur C++.
Chart.png amélioré pendant la formation.
Corrections de bugs et optimisations liées aux performances, principalement liées à la réduction du temps nécessaire à la formation du réseau.
La dernière branche de cette base de code est la version 2.1 dans la branche v2.
La prochaine phase de développement commence mi-2024, avec une sortie en octobre 2024. La commande version renvoie désormais 3.x "JAZZ".
Si vous devez exécuter l'une de ces commandes, vous pouvez toujours extraire la branche v2 précédente. Si vous avez besoin d'aide, veuillez nous le faire savoir afin que nous puissions étudier l'ajout de commandes manquantes.
Suppression de nombreuses commandes anciennes et non maintenues.
De nombreuses optimisations de performances ont été réalisées, notamment lors de la formation et de l'inférence.
L'ancienne API C a été modifiée ; les applications utilisant l'API Darknet d'origine nécessiteront des modifications mineures : https://darknetcv.ai/api/api.html
Nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
Nouvelles applications et exemples de code dans src-examples : https://darknetcv.ai/api/files.html
Poids pré-entraînés MSCOCO
Pour plus de commodité, plusieurs versions populaires de YOLO sont pré-entraînées sur l'ensemble de données MSCOCO. L'ensemble de données contient 80 catégories et peut être consulté dans le fichier texte cfg/coco.names.
Il existe plusieurs 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 pour MSCOCO se trouvent dans le répertoire cfg. Exemple de commande :
`
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
`
Notez qu’il faut former son propre réseau. MSCOCO est généralement utilisé pour confirmer que tout fonctionne correctement.
Bâtiment
Diverses méthodes de construction fournies dans le passé (avant 2023) ont été fusionnées en 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.
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 pour Google Colab sont les mêmes que pour Linux. Il existe plusieurs notebooks Jupyter disponibles qui 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.
Méthode Linux CMake
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).
Obligatoire : vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
Obligatoire : n'oubliez pas de reconstruire Darknet.
Darknet peut fonctionner sans lui, mais si vous souhaitez former un réseau personnalisé, CUDA ou CUDA+cuDNN est requis.
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.
Une fois CUDA installé, assurez-vous que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.
Si vous avez installé CUDA ou CUDA+cuDNN ultérieurement, ou si vous avez effectué une mise à niveau vers une version plus récente du logiciel NVIDIA :
Ces instructions supposent (mais ne l'exigent pas nécessairement !) que le système exécute Ubuntu 22.04. Si vous utilisez une autre distribution, veuillez l'ajuster si nécessaire.
`
sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/srccd ~/src
git clone https://github.com/hank-ai/darknetcd darknet
mkdir buildcd construire
cmake -DCMAKEBUILDTYPE=Version ..
faire -j4
emballer
sudo dpkg -i darknet-VERSION.deb
`
Si vous utilisez une ancienne version de CMake, vous devez mettre à niveau CMake avant d'exécuter la commande cmake ci-dessus. Pour mettre à niveau CMake sur Ubuntu, vous pouvez utiliser la commande suivante :
`
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Si vous utilisez bash comme shell de commande, vous devrez peut-être redémarrer votre shell. Si vous utilisez du poisson, il devrait immédiatement suivre le nouveau chemin.
Utilisateurs avancés :
Si vous souhaitez créer un fichier d'installation RPM au lieu d'un fichier DEB, consultez les lignes pertinentes dans CM_package.cmake. Avant d'exécuter le package make -j4, vous devez modifier ces deux lignes :
`
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
`
Pour les distributions comme Centos et OpenSUSE, vous devez modifier ces deux lignes dans CM_package.cmake en :
`
SET (CPACKGENERATOR "DEB")SET (CPACKGENERATOR "RPM")
`
Pour installer le package d'installation, une fois celui-ci construit, utilisez le gestionnaire de packages habituel de votre distribution. Par exemple, sur un système basé sur Debian (comme Ubuntu) :
`
sudo dpkg -i darknet-2.0.1-Linux.deb
`
L'installation du package .deb copiera les fichiers suivants :
/usr/bin/darknet est l'exécutable Darknet habituel. Exécutez la version darknet à partir de la CLI pour confirmer qu'elle est correctement installée.
/usr/include/darknet.h est 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 est une bibliothèque permettant aux développeurs C, C++ et Python de créer des liens.
/opt/darknet/cfg/... est l'endroit où tous les modèles .cfg sont stockés.
Maintenant, vous avez terminé ! Darknet a été construit et installé dans /usr/bin/. Exécutez la commande suivante pour tester : version darknet.
Si vous n'avez pas /usr/bin/darknet, cela signifie que vous ne l'avez pas installé, vous venez de le construire ! Assurez-vous d'installer le fichier .deb ou .rpm comme décrit ci-dessus.
Méthode Windows CMake
Ces instructions supposent que vous disposez d’une nouvelle installation de Windows 11 22H2.
Ouvrez une fenêtre d'invite de commande cmd.exe normale et exécutez la commande suivante :
`
Winget installe Git.Git
Winget installe Kitware.CMake
Winget installe nsis.nsis
Winget installe Microsoft.VisualStudio.2022.Community
`
À ce stade, nous devons 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 de bureau avec 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, vous rencontrerez des problèmes !
Utilisateurs avancés :
Au lieu d'exécuter l'invite de commande du développeur, vous pouvez 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 utilisé pour créer OpenCV :
`
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
`
Veuillez être patient avec cette dernière étape car son exécution peut prendre beaucoup de temps. Cela nécessite de télécharger et de créer beaucoup de choses.
Utilisateurs avancés :
Notez qu'il existe de nombreux autres modules facultatifs 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).
Obligatoire : vous devez supprimer le fichier CMakeCache.txt de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
Obligatoire : n'oubliez pas de reconstruire Darknet.
Darknet peut fonctionner sans lui, mais si vous souhaitez former un réseau personnalisé, CUDA ou CUDA+cuDNN est requis.
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#download-windows pour télécharger et installer cuDNN.
Une fois CUDA installé, assurez-vous de pouvoir exécuter nvcc.exe et nvidia-smi.exe. Vous devrez peut-être modifier votre variable PATH.
Une fois que vous avez téléchargé cuDNN, 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.
Si vous avez installé CUDA ou CUDA+cuDNN ultérieurement, ou si vous avez effectué 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 :
`
cdc: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 obtenez des erreurs concernant certaines DLL CUDA ou cuDNN manquantes, telles que cublas64_12.dll, copiez manuellement le fichier CUDA .dll dans le même répertoire de sortie que Darknet.exe. Par exemple:
`
copier "C: Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Ceci est un exemple ! Veuillez vérifier la version que 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 :
`
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Utilisateurs avancés :
Veuillez noter que la sortie de la commande cmake est un 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 que vous pouvez exécuter : C:srcDarknetbuildsrc-cliReleasedarknet.exe. Exécutez la commande suivante pour tester : version C:srcDarknetbuildsrc-cliReleasedarknet.exe.
Pour installer correctement Darknet, les bibliothèques, inclure les fichiers et les DLL nécessaires, exécutez l'assistant d'installation NSIS créé à la dernière étape. Voir le fichier darknet-VERSION.exe dans le répertoire build. Par exemple:
`
darknet-2.0.31-win64.exe
`
L'installation du package d'installation NSIS :
Créez un répertoire appelé 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'une autre application.
Installez le fichier modèle .cfg.
Maintenant, vous avez terminé ! 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, cela signifie que vous ne l'avez pas installé, vous venez de le construire ! Assurez-vous de parcourir chaque panneau de l'assistant d'installation NSIS comme décrit à l'étape précédente.
Utiliser le Darknet
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 fournit une CLI alternative à Darknet/YOLO. DarkHelp CLI possède également des fonctionnalités avancées qui ne sont pas directement disponibles 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 devrez utiliser le fichier .weights pour les fichiers .names et .cfg correspondants. Vous pouvez former votre propre réseau (fortement recommandé !) ou télécharger sur Internet des réseaux de neurones qui ont été formés par d'autres et sont disponibles gratuitement. 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 80 catégories)
Les commandes à exécuter incluent :
Répertoriez quelques commandes et options pouvant être exécutées :
`
aide sur le darknet
`
Vérifier la version :
`
version darknet
`
Utilisez des images pour faire des prédictions :
`
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.cfg cars_best.weights image1.jpg
`
Coordonnées de sortie :
`
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 :
`
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 la webcam :
`
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 une vidéo :
`
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 :
`
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écuter sur un GPU spécifique :
`
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 :
`
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 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 feu rouge 94.1033 3449 217 451 4643 0.9237 0.0763 0.8844 0.9408 0.9115 0.0885
`
Vérifier la précision mAP@IoU=75 :
`
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 l'exécutera 100 fois de suite et sélectionnera le meilleur point d'ancrage parmi tous les points d'ancrage calculés. Mais si vous souhaitez exécuter une ancienne version dans Darknet :
`
détecteur darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256
`
Former un nouveau réseau :
`
darknet detector -map -dont_show train cats.data cats.cfg (voir également la section formation ci-dessous)
`
Entraînement
Lien rapide vers la section pertinente de la FAQ Darknet/YOLO :
* Comment configurer mes fichiers et répertoires ?
* Quel profil dois-je utiliser ?
* Quelles commandes dois-je utiliser lors de la formation de mon propre réseau ?
Utilisez DarkMark pour créer tous les fichiers Darknet nécessaires, ce 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 configurer manuellement les différents fichiers pour entraîner un réseau personnalisé :
1. Créez un nouveau dossier pour stocker les fichiers. Dans cet exemple, un réseau de neurones sera créé pour détecter les animaux, donc le répertoire suivant sera créé : ~/nn/animals/.
2. 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éé. Dans cet exemple, nous avons maintenant ~/nn/animals/animals.cfg.
3. Dans le même dossier où vous avez placé le fichier de configuration, créez un fichier texte cats.names. Dans ce cas, nous avons maintenant ~/nn/animals/animals.names.
4. Utilisez un éditeur de texte pour modifier le fichier cats.names. Répertoriez les catégories que vous souhaitez utiliser. Vous devez avoir exactement une entrée par ligne, aucune ligne vide et aucun commentaire. Dans cet exemple, le fichier .names contiendra exactement 4 lignes :
`
chien
chat
oiseau
cheval
`
5. Créez un fichier texte animaux.data dans le même dossier. Dans 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
`
6. 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 avec des annotations décrivant 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 exactes de l'annotation. Veuillez vous référer à DarkMark ou à un autre logiciel similaire pour annoter vos images. Le format d'annotation YOLO est décrit dans la FAQ Darknet/YOLO.
7. Créez les fichiers texte « train » et « valide » nommés dans le fichier .data. Ces deux fichiers texte doivent répertorier toutes les images que Darknet doit utiliser respectivement pour la formation et la validation (lors du calcul du mAP%). Il y a exactement une image par ligne. Les chemins et les noms de fichiers peuvent être relatifs ou absolus.
8. Utilisez un éditeur de texte pour modifier votre fichier .cfg.
* Assurez-vous que lot = 64.
* Faites attention aux subdivisions. En fonction des dimensions du réseau et de la quantité de mémoire disponible sur votre GPU, vous devrez peut-être augmenter les subdivisions. La meilleure valeur à utiliser est 1, alors commencez par cela. Si 1 ne fonctionne pas pour vous, consultez la FAQ Darknet/YOLO.
Notez que maxbatches=…. Au début, une bonne valeur correspond à 2 000 fois le nombre de catégories. Dans 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. Dans cet exemple, nous utiliserons steps=6400,7200 puisque maxbatches est défini sur 8000.
* Faites attention à width=... et height=..... Ce sont des dimensions de réseau. La FAQ Darknet/YOLO explique comment calculer la taille optimale à utiliser.
* Recherchez toutes les instances contenant la ligne classes=... et modifiez-les avec le nombre de classes dans votre fichier .names. Dans cet exemple, nous utiliserons classes=4.
Dans la section [convolutional] avant chaque section [yolo], recherchez toutes les instances contenant la ligne filters=... . La valeur à utiliser est (nombre de catégories + 5) 3. Cela signifie dans ce cas, (4 + 5) * 3 = 27. Nous utiliserons donc filters=27 dans les lignes appropriées.
9. Commencez la formation ! Exécutez la commande suivante :
`
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. 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:
`
détecteur darknet -map -dont_show --verbose train animaux.data animaux.cfg
`
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 CLI alternative robuste au Darknet permettant d'utiliser la mosaïque d'images pour le suivi d'objets dans la vidéo, ou pour une API C++ robuste qui peut être facilement utilisée dans des applications commerciales, consultez DarkHelp.
Veuillez consulter la FAQ Darknet/YOLO et voir si elle aide à répondre à votre question.
Merci de regarder les nombreux tutoriels et exemples de vidéos sur la chaîne YouTube de Stéphane.
Si vous avez des questions d'assistance ou si vous souhaitez discuter avec d'autres utilisateurs de Darknet/YOLO, veuillez rejoindre le serveur Discord Darknet/YOLO.
Feuille de route
Dernière mise à jour : 2024-10-30
Complété
Remplacement de qsort() utilisé pendant la formation par std::sort() (d'autres moins courants existent toujours)
Supprimez check_mistakes, getchar() et system()
Convertir Darknet pour utiliser un compilateur C++ (g++ sous Linux, Visual Studio sous Windows)
Réparer la version de 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
Supprimer l'ancienne solution et 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 au-delà du code source
A une meilleure sortie du numéro de version
Optimisations des performances liées à la formation (tâches en cours)
Optimisations des performances liées à l'inférence (tâches en cours)
Utilisez des références par valeur autant que possible
Nettoyer les fichiers .hpp
Réécrire darknet.h
Ne convertissez pas cv::Mat en void, utilisez-le plutôt comme un objet C++ approprié
Corriger ou conserver les structures d’image internes utilisées de manière cohérente
Correction de la version pour les appareils Jetson basés sur ARM
* Étant donné que NVIDIA ne prend plus en charge les appareils Jetson d'origine, il est peu probable qu'ils soient corrigés (pas de compilateur C++17)
* Le nouvel appareil Jetson Orin est désormais en cours d'exécution
Correction de l'API Python dans la V3
Une meilleure prise en charge de Python est nécessaire (des développeurs Python souhaitent-ils aider ?)
objectifs à court terme
Remplacez printf() par std::cout (travail en cours)
Découvrez l'ancien support de la 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, nettoyez les avertissements du compilateur (travail en cours)
Mieux vaut utiliser cv::Mat au lieu de structures d'images personnalisées en C (travail en cours)
Remplacez les anciennes fonctions 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 une profondeur supplémentaire ou des canaux thermiques)
Nettoyage du code en cours (en cours)
objectifs à long terme
Résoudre les problèmes CUDA/CUDNN pour 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
Carte thermique (travail en cours)
segmentation
Dans l'exemple, l'élément de balise de titre Markdown est utilisé et certains contenus sont logiquement complétés, peaufinés et la composition ajustée. Par exemple, l'ajout de numéros de série chinois, de sérialisation de chiffres arabes, de sauts de ligne et d'autres formats peut rendre l'affichage des informations plus ordonné et faciliter la vérification par les utilisateurs.
J'espère que cet article pourra être utile à tout le monde !
