schémaorg
Release
Bienvenue sur Schema.org
Il s'agit du référentiel du projet Schema.org. Il contient tous les schémas, exemples et logiciels utilisés pour publier schema.org. Pour le site lui-même, veuillez plutôt consulter Schema.org.
Remarque : La plupart des logiciels de support sont importés à partir d'un sous-module : "sdopythonapp".
Les problèmes et les propositions sont gérés ici par les collaborateurs autour du projet, en particulier les participants du groupe communautaire W3C Schema.org. Si vous êtes intéressé à participer, veuillez rejoindre le groupe du W3C, vous présenter et trouver ou déposer ici les problèmes qui suscitent votre intérêt. Si vous êtes nouveau sur Git et GitHub, il existe une introduction utile à GitHub dans le wiki du W3C.
Il existe également des tests d'intégration continue pour vérifier les demandes d'extraction entrantes.
Le numéro 1 de GitHub est un point d’entrée pour la planification des versions. Il doit fournir un aperçu des travaux à venir, en termes de thèmes généraux, de problèmes spécifiques et d'étapes de publication. Le numéro 1 sera lié aux points d'entrée par version, ou bien naviguera dans les problèmes via une étiquette ou un jalon dans GitHub.
Chaque modification apportée au site se fait via des discussions ici. Des changements substantiels sont enregistrés dans nos notes de version. Un aperçu du projet de nouvelles notes de version peut être trouvé dans le cadre du site de test de notre prochaine version. Chaque mois environ, après un examen final par le groupe de pilotage Schema.org et la communauté au sens large, nous publions une version officielle.
Concernant les licences CC et open source pour les documents et logiciels, consultez notre entrée FAQ.
Nous sommes toujours intéressés par des suggestions pratiques d'amélioration de schema.org, et notre collection de schémas s'est développée progressivement depuis notre lancement en 2011. Nous essayons de donner la priorité aux correctifs et améliorations simples de nos schémas, exemples et documentation existants plutôt que de l'ajout de nouveaux vocabulaire, et nous sommes plus susceptibles d'ajouter de nouveaux schémas lorsqu'il est évident qu'une application consommatrice (de préférence à grande échelle) utilisera les données. Les applications consommatrices ne doivent pas nécessairement être des moteurs de recherche ; les outils logiciels (par exemple, les approches open source enrichies en balisage pour l'analyse Web, les modules complémentaires de navigateur ou les outils cloud) sont tous de riches domaines d'exploration et de collaboration. L’important est que l’on puisse raisonnablement s’attendre à ce que les consommateurs de données fassent bon usage des changements. Il ne suffit pas de justifier des ajouts au motif que les moteurs de recherche tentent généralement d’utiliser des données structurées basées sur Schema.org. Les modifications plus petites et les modifications rétrocompatibles sont plus faciles à intégrer.
Remarque : Schema.org ne tente pas de capturer tous les détails du contenu Web ; c'est nécessairement une simplification d'une réalité plus complexe. Cela signifie qu'il y aura de nombreux cas où il semblera possible d'ajouter plus de détails à Schema.org. Cependant, dans l'intérêt de garder Schema.org simple et utilisable pour les éditeurs et les webmasters, nous choisissons souvent de ne pas ajouter de tels détails.
Schema.org utilise des standards Web tels que JSON-LD, Microdata et RDFa pour permettre une extension indépendante (par exemple, voir le vocabulaire de GS1).
Il est également très peu probable que nous entreprenions des réorganisations à grande échelle de la terminologie de Schema.org, si elles sont motivées uniquement par des considérations d'élégance, de « modélisation appropriée », de pureté ontologique ou d'unification conceptuelle. Bien que les fondateurs et l'équipe du projet connaissent - et respectent - les traditions qui sous-tendent de telles préoccupations, l'ampleur, la portée et la nature de Schema.org nous ont obligés à troquer l'élégance et la cohérence globale contre une notion quelque peu plus rudimentaire d'évolution incrémentale et une approche pragmatique. tolérance pour un style qui ne serait pas à sa place dans une ontologie formelle. Les propositions visant à unifier les structures de connaissances basées sur la logique inter-domaines pourraient être mieux reçues, par exemple dans la communauté Ontolog.
Nous introduisons parfois des types sans associations de propriétés dédiées, simplement pour des raisons de convivialité du balisage. Dans une ontologie formelle, cela est souvent considéré comme une mauvaise modélisation. Cependant, des structures logiquement équivalentes peuvent entraîner beaucoup plus d'erreurs de la part d'éditeurs/webmasters peu familiers avec les concepts formels sous-jacents à JSON-LD ou RDF/S.
Schema.org n'est pas un système fermé, et d'autres initiatives (par exemple, Wikidata ou GS1) ont défini de nombreux autres termes qui peuvent être mélangés à ceux que nous définissons sur schema.org. Nous nous efforçons également d'aligner nos conceptions sur les normes et initiatives externes pertinentes, même si cela réduit l'élégance globale de Schema.org pris seul. Par exemple, dans un contexte bibliographique ou de patrimoine culturel, nous pouvons être influencés par des initiatives comme MARC, BibFrame et FRBR, tandis que pour le commerce électronique, nous avons collaboré avec Good Relations et GS1. Les termes liés à l'actualité de Schema.org ont été fortement influencés par l'intégration de la conception rNews de l'IPTC, ainsi que par des collaborations avec des vérificateurs de faits, le Trust Project et d'autres. Nos vocabulaires liés à la télévision et à la musique sont fortement influencés par notre collaboration avec la BBC et l'Union européenne de radiodiffusion, aux côtés de l'ontologie musicale et de MusicBrainz ; nos schémas reflètent ces conceptions antérieures. Nous préférons collaborer de cette manière, en améliorant Schema.org progressivement et en travaillant à peaufiner, intégrer et mélanger ces conceptions plutôt que de produire notre propre modèle pur de manière isolée. Le résultat manque peut-être d’élégance globale, mais il permet d’aligner notre travail sur les efforts connexes déployés à l’échelle mondiale.
Nous accueillons toujours favorablement les problèmes liés à l'utilisabilité et à la lisibilité, mais nous encourageons à nous concentrer sur des situations concrètes (par exemple, comment décrire des événements répétitifs) plutôt que sur des préoccupations philosophiques globales (par exemple, si une réserve ou une action est « réellement » un événement). Nous donnons la priorité à la cohérence locale (avoir des moyens raisonnables de décrire de nombreuses situations communes) plutôt qu’à l’élégance globale (avoir une théorie globale dans laquelle tout a une place raisonnable). Cela ne signifie pas que nous n'avons jamais de nettoyages, mais ils sont contrebalancés (et souvent contrebalancés par) d'autres considérations.
Lorsque nous ajoutons des termes, souvent dans la zone « En attente », nous encourageons fortement les commentaires qui adoptent une perspective globale : comment un nouveau terme est-il lié aux autres, comment pourrait-il être utilisé aux côtés de modèles préexistants, etc. cette phase d'intégration reflète de telles considérations, mais s'exprime généralement par une reformulation modeste, des exemples ou un ajustement de la documentation des liens de type/propriété, plutôt que par une restructuration majeure.
En savoir plus sur "Comment nous travaillons"
Pour la plupart des collaborateurs, tout ce que vous devez savoir sur le logiciel est de savoir comment l'exécuter. L'objectif du logiciel est de créer une copie statique du site Schema.org, y compris les modifications locales potentielles, à inspecter et à exécuter derrière un simple serveur Web sur un système local à des fins de test. De la même manière qu'une version de production est déployée sur un serveur cloud, votre version locale peut ensuite être déployée sur une machine virtuelle à l'aide de gcloud pour permettre la collaboration avec d'autres.
Des instructions complètes sont disponibles dans SOFTWARE_README.md expliquant comment créer la copie locale initiale avec laquelle travailler, puis évoluer pour tester les modifications. Essentiellement, vous aurez besoin d'un environnement de type Linux (y compris Mac) chargé avec Python version 3.6 ou supérieure. Vous pouvez ensuite rendre les versions de test de schema.org exécutées sur votre propre ordinateur accessibles en tant que http://localhost:8080/ ou bien les publier sur appspot.com pour collaboration. Consultez la documentation Appengine pour plus de détails sur les commandes gcloud pertinentes.
Des informations plus détaillées sur le logiciel et son utilisation sont disponibles dans SOFTWARE_README.md. Voir aussi les notes dans le wiki : https://github.com/schemaorg/schemaorg/wiki/Contributing
Tous les schémas et exemples sont dans data/dans des fichiers codés en utf-8.
Le fichier de schémas principal est data/schema.ttl (utf-8).
Lors du développement de schémas, l'utilisation de data/sdo-somethinghere-schema.ttl peut être utile.
Le format est basé sur le W3C RDFS au format RDF/Turtle.
Les exemples sont stockés dans data/examples.txt (utf-8) et dans d'autres fichiers .txt.
Comme pour les schémas, data/examples.txt sera également lu. Il peut être utile de développer en utilisant des fichiers séparés.
Lorsque le vocabulaire sera enfin intégré dans le référentiel principal, les données du schéma seront fusionnées dans schema.org. Cependant, les exemples resteront dans des fichiers séparés, car cela fonctionne mieux avec le système de comparaison de fichiers de git.
La hiérarchie data/releases/ est réservée aux instantanés de version (voir https://schema.org/version/).
La hiérarchie ext// est réservée aux extensions (voir https://schema.org/docs/extension.html).
Nous n'utilisons plus les branches github pour les travaux en cours. La branche main/ est notre dernier candidat. Il n'est pas garanti qu'il soit dans un état conceptuel cohérent, mais il doit se stabiliser avant la diffusion d'une version candidate pour examen.
Cette documentation concerne la base de code du logiciel plutôt que schema.org lui-même. Cependant, notez que les étiquettes, les commentaires et la documentation doivent utiliser l'anglais américain (dans le code et les schémas), si un choix entre les variantes anglaises est nécessaire. Veuillez viser l’anglais international dans la mesure du possible.
Voir aussi : https://twitter.com/schemaorg_dev
Exemple:
`
Licence Apache-2.0
Table des matières
Cadre de détection d'objets Darknet et YOLO
Papiers
Informations générales
Version Darknet
Poids pré-entraînés MSCOCO
Bâtiment
Google Colab
Méthode Linux CMake
Méthode Windows CMake
Utiliser le Darknet
CLI
Entraînement
Autres outils et liens
Feuille de route
Objectifs à court terme
Objectifs à moyen terme
Objectifs à long terme
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 aide la communauté Darknet/YOLO
Annonce du Darknet V3 "Jazz"
Voir le site Darknet/YOLO
Veuillez lire la FAQ Darknet/YOLO
Rejoignez le serveur discord Darknet/YOLO
Papiers
Papier YOLOv7
Papier à l'échelle-YOLOv4
Papier YOLOv4
Papier YOLOv3
Informations générales
Le framework Darknet/YOLO continue d'être à la fois plus rapide et plus précis que les autres frameworks et versions de YOLO.
Ce framework est à la fois entièrement gratuit et open source. Vous pouvez intégrer Darknet/YOLO dans des projets et produits existants, y compris commerciaux, sans licence ni paiement de frais.
Darknet V3 (« Jazz ») sorti en octobre 2024 peut exécuter avec précision les vidéos de l'ensemble 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 est lue, redimensionnée et traitée par Darknet/YOLO en 1 milliseconde ou moins.
Veuillez rejoindre le serveur Discord Darknet/YOLO si vous avez besoin d'aide ou si vous souhaitez discuter de Darknet/YOLO : https://discord.gg/zSq8rtW
La version CPU de Darknet/YOLO peut fonctionner sur des appareils simples tels que le 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 est connu pour fonctionner sous Linux, Windows et Mac. Voir les instructions de construction ci-dessous.
Version Darknet
L'outil Darknet original écrit par Joseph Redmon en 2013-2017 n'avait pas de numéro de version. Nous considérons cette version 0.x.
Le prochain dépôt Darknet populaire maintenu par Alexey Bochkovskiy entre 2017 et 2021 n'avait pas non plus de numéro de version. Nous considérons cette version 1.x.
Le repo Darknet sponsorisé par Hank.ai et maintenu par Stéphane Charette à partir de 2023 a été le premier doté d'une commande de version. De 2023 à fin 2024, il a renvoyé la version 2.x « OAK ».
L'objectif était d'essayer de briser le moins possible les fonctionnalités existantes tout en se familiarisant avec la base de code.
Réécriture des étapes de construction afin que nous disposions d'une manière unifiée de créer à l'aide de CMake sous Windows et Linux.
Conversion de la base de code pour utiliser le compilateur C++.
Chart.png amélioré pendant l'entraînement.
Corrections de bugs et optimisations liées aux performances, principalement liées à la réduction du temps nécessaire à la formation d'un réseau.
La dernière branche de cette base de code est la version 2.1 dans la branche v2.
La phase suivante de développement a commencé mi-2024 et a été publiée en octobre 2024. La commande de version renvoie désormais 3.x « JAZZ ».
Vous pouvez toujours effectuer une extraction de la branche v2 précédente si vous devez exécuter l'une de ces commandes. Faites-le-nous savoir afin que nous puissions étudier la réintégration des commandes manquantes.
Suppression de nombreuses commandes anciennes et non maintenues.
De nombreuses optimisations de performances, aussi bien lors de l'entraînement que lors de l'inférence.
L'API C héritée a été modifiée ; les applications qui utilisent 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 les exemples src : https://darknetcv.ai/api/files.html
Poids pré-entraînés MSCOCO
Plusieurs versions populaires de YOLO ont été pré-entraînées pour plus de commodité sur l'ensemble de données MSCOCO. Cet ensemble de données contient 80 classes, visibles 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 et sont également disponibles en téléchargement à partir de ce dépôt :
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 fournis à des fins de démonstration uniquement. Les fichiers .cfg et .names correspondants pour MSCOCO se trouvent dans le répertoire cfg. Exemples de commandes :
wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights darknet02displayannotatedimages coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights vidéo1. avi
Notez que les gens sont censés former leurs propres réseaux. MSCOCO est normalement utilisé pour confirmer que tout fonctionne correctement.
Bâtiment
Les différentes méthodes de construction disponibles dans le passé (avant 2023) ont été fusionnées en une seule 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, de la même manière que vous n'avez pas besoin d'être mécanicien pour conduire une voiture.
Google Colab
Linux
Fenêtres
Méfiez-vous si vous suivez d'anciens didacticiels avec des étapes de construction plus compliquées, ou si vous construisez des étapes qui ne correspondent pas à ce qui est contenu dans ce fichier Lisez-moi. Les nouvelles étapes de construction décrites ci-dessous ont commencé en août 2023.
Les développeurs de logiciels sont encouragés à visiter https://darknetcv.ai/ pour obtenir des informations sur les composants internes du framework de détection d'objets Darknet/YOLO.
Google Colab
Les instructions de Google Colab sont les mêmes que celles de Linux. Plusieurs notebooks Jupyter sont disponibles montrant comment effectuer certaines tâches, comme la formation d'un nouveau réseau.
Consultez les notebooks dans le sous-répertoire colab et/ou suivez les instructions Linux ci-dessous.
Méthode Linux CMake
Tutoriel de construction Darknet pour Linux
Facultatif : si vous disposez d'un GPU NVIDIA moderne, vous pouvez installer soit CUDA, soit 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 de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
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 que vous avez installé CUDA, assurez-vous de pouvoir exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier votre variable PATH.
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 :
Ces instructions supposent (mais ne nécessitent pas !) un système exécutant Ubuntu 22.04. Adaptez si nécessaire si vous utilisez une distribution différente.
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
Si vous utilisez une ancienne version de CMake, vous devrez mettre à niveau CMake avant de pouvoir exécuter la commande cmake ci-dessus. La mise à niveau de CMake sur Ubuntu peut être effectuée avec les commandes suivantes :
sudo apt-get purge cmake sudo snap install cmake --classic
Si vous utilisez bash comme shell de commande, vous souhaiterez redémarrer votre shell à ce stade. Si vous utilisez du poisson, il doit 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 devrez modifier ces deux lignes :
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
Pour les distributions telles que Centos et OpenSUSE, vous devrez changer ces deux lignes dans CM_package.cmake pour qu'elles soient :
SET (CPACKGENERATOR "DEB")SET (CPACKGENERATOR "RPM")
Pour installer le package d'installation une fois sa construction terminée, utilisez le gestionnaire de packages habituel de votre distribution. Par exemple, sur les systèmes basés sur Debian tels qu'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 la bibliothèque avec laquelle établir des liens pour les développeurs C, C++ et Python.
/opt/darknet/cfg/... est l'endroit où tous les modèles .cfg sont stockés.
Vous avez maintenant terminé ! Darknet a été construit et installé dans /usr/bin/. Exécutez ceci pour tester : version darknet.
Si vous n'avez pas /usr/bin/darknet alors cela signifie que vous ne l'avez pas installé, vous l'avez seulement construit ! Assurez-vous d'installer le fichier .deb ou .rpm comme décrit ci-dessus.
Méthode Windows CMake
Ces instructions supposent une toute nouvelle installation de Windows 11 22H2.
Ouvrez une fenêtre d'invite de commande cmd.exe normale et exécutez les commandes suivantes :
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 ces étapes, vous exécuterez dans les 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 l'invite de commande du développeur s'exécute comme décrit ci-dessus (pas PowerShell !), exécutez les commandes suivantes pour installer Microsoft VCPKG, qui sera ensuite utilisé pour créer OpenCV :
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 lors de cette dernière étape car son exécution peut prendre beaucoup de temps. Il doit télécharger et construire 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 soit CUDA, soit 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 de votre répertoire de construction Darknet pour forcer CMake à retrouver tous les fichiers nécessaires.
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 que vous avez installé CUDA, 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 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 construire. Au cours de cette étape, nous devons également indiquer à CMake où se trouve vcpkg afin qu'il puisse trouver OpenCV et d'autres dépendances :
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 obtenez une erreur concernant certaines DLL CUDA ou cuDNN manquantes telles que cublas64_12.dll, copiez manuellement les fichiers 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
(C'est un exemple ! Vérifiez la version que vous utilisez et exécutez la commande appropriée à ce que vous avez installé.)
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 :
Notez 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 régulièrement 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 ceci 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éé à 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, tel que 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 les fichiers modèles .cfg.
Vous avez maintenant terminé ! Une fois l'assistant d'installation terminé, Darknet aura été installé dans C:Program FilesDarknet. Exécutez ceci 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 l'avez seulement construit ! Assurez-vous de parcourir chaque panneau de l'assistant d'installation NSIS à l'étape précédente.
Utiliser le Darknet
CLI
Ce qui suit n'est pas la 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. La CLI DarkHelp possède également plusieurs fonctionnalités avancées qui ne sont pas disponibles directement dans Darknet. Vous pouvez utiliser à la fois la CLI Darknet et la CLI DarkHelp ensemble, elles ne s'excluent pas mutuellement.
Pour la plupart des commandes présentées ci-dessous, vous aurez besoin du fichier .weights avec les fichiers .names et .cfg correspondants. Vous pouvez soit entraîner votre propre réseau (fortement recommandé !), soit télécharger un réseau neuronal que quelqu'un a déjà formé et mis à disposition gratuitement sur Internet. Voici des exemples d'ensembles de données pré-entraînés :
LEGO Gears (trouver des objets dans une image)
Rolodex (trouver du texte dans une image)
MSCOCO (détection d'objets standard de classe 80)
Les commandes à exécuter incluent :
Répertoriez quelques commandes et options possibles à exécuter :
aide sur le darknet
Vérifiez la version :
version darknet
Prédire à l'aide d'une image :
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
Travailler avec des vidéos :
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 une webcam :
V2 : démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -c 0
V3 : animaux darknet08display_webcam
Enregistrez 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écuté sur un GPU spécifique :
V2 : démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -i 1 test.mp4
Pour vérifier 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 10 4116 0,8904 0,1096 0,7943 0,8918 0,8898 0,1102 6 feu 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 2 17 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885
Pour vérifier l'exactitude 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 ancres dans DarkMark, car il s'exécutera 100 fois consécutives et sélectionnera les meilleures ancres parmi toutes celles qui ont été calculées. Mais si vous souhaitez exécuter l’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
Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :
Comment dois-je configurer mes fichiers et répertoires ?
Quel fichier de configuration dois-je utiliser ?
Quelle commande dois-je utiliser lors de la formation de mon propre réseau ?
Le moyen le plus simple d’annoter et de s’entraîner consiste à utiliser DarkMark pour créer tous les fichiers Darknet nécessaires. C'est certainement la méthode recommandée pour former un nouveau réseau neuronal.
Si vous préférez configurer manuellement les différents fichiers pour entraîner un réseau personnalisé :
Créez un nouveau dossier dans lequel les fichiers seront stockés. Pour cet exemple, un réseau de neurones sera créé pour détecter les animaux, donc le répertoire suivant est 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.
Modifiez le fichier animaux.names avec votre éditeur de texte. Listez les classes que vous souhaitez utiliser. Vous devez avoir exactement 1 entrée par ligne, sans lignes vides ni 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 :
classes = 4 train = /home/username/nn/animals/animalstrain.txt valid = /home/username/nn/animals/animalsvalid.txt noms = /home/username/nn/animals/animals.names sauvegarde = /home/ nom d'utilisateur/nn/animaux
Créez un dossier dans lequel vous stockerez vos images et annotations. Par exemple, cela pourrait être ~/nn/animals/dataset. Chaque image aura besoin d'un fichier .txt correspondant qui décrit les annotations pour cette image. Le format des fichiers d'annotations .txt est très spécifique. Vous ne pouvez pas créer ces fichiers manuellement puisque chaque annotation doit contenir les coordonnées exactes 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 les fichiers texte « train » et « valide » nommés dans le fichier .data. Ces deux fichiers texte doivent répertorier individuellement toutes les images que Darknet doit utiliser pour l'entraînement et pour la validation lors du calcul du mAP%. Exactement une image par ligne. Le chemin et les noms de fichiers peuvent être relatifs ou absolus.
Modifiez votre fichier .cfg avec un éditeur de texte.
Assurez-vous que le lot = 64.
Notez les 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. Consultez la FAQ Darknet/YOLO si 1 ne fonctionne pas pour vous.
Notez que maxbatches=.... Une bonne valeur à utiliser au début est 2000 x le nombre de classes. 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 utiliserions steps=6400,7200 puisque maxbatches a été défini sur 8000.
Notez width=... et height=.... Ce sont les dimensions du réseau. La FAQ Darknet/YOLO explique comment calculer la meilleure taille à utiliser.
Recherchez toutes les instances de la ligne classes=... et modifiez-la avec le nombre de classes dans votre fichier .names. Pour cet exemple, nous utiliserions classes=4.
Recherchez toutes les instances de la ligne filters=... dans la section [convolutionnelle] avant chaque section [yolo]. La valeur à utiliser est (numberofclasses + 5) 3. Cela signifie pour cet exemple, (4 + 5) 3 = 27. Nous utiliserions donc filters=27 sur les lignes appropriées.
Commencez à vous entraîner ! Exécutez les commandes suivantes :
cd ~/nn/animaux/ détecteur darknet -map -dont_show train animaux.data animaux.cfg
Sois patient. Les meilleurs poids seront enregistrés sous le nom animaux_best.weights. Et la progression de la formation peut être observée en visualisant le
