vidéo2x
6.0.0
Video2X : cadre de conversion ascendante vidéo et d'interpolation d'images de haute qualité
Éditeur de code source
Important
Les versions 4 et 5 ont atteint le statut de fin de vie (EOL). En raison de ressources de développement limitées, les problèmes liés aux versions inférieures à 6 ne seront plus résolus.
Version 6.0.0
Téléchargez le programme d'installation de Windows
En un mot : la version 6.0.0 est une réécriture complète du projet Video2X en C/C++, avec une architecture plus rapide et plus efficace, un support multiplateforme, une qualité de sortie considérablement améliorée et de nouvelles fonctionnalités pour une configuration facile sur l'interface graphique et l'installateur Windows. .
La version 6.0.0 est une réécriture complète du projet, implémentée en C/C++ et inclut les fonctionnalités suivantes :
1. Architecture plus rapide : en tirant parti du multithreading et de l'accélération GPU, Video2X est désormais beaucoup plus rapide qu'auparavant.
2. Prise en charge multiplateforme : Video2X fonctionne désormais sous Windows, Linux et macOS.
3. Qualité de sortie améliorée : Video2X offre désormais une qualité de conversion ascendante supérieure, en particulier pour les vidéos haute résolution.
4. Nouvelle interface graphique : Video2X propose désormais une interface graphique conviviale qui simplifie le processus de configuration et d'utilisation.
5. Nouveau programme d'installation : Video2X propose désormais un programme d'installation facile à utiliser qui vous aide à installer le logiciel rapidement et facilement sous Windows.
La prise en charge de RealCUGAN et de l'interpolation de trames à l'aide de RIFE sera bientôt disponible.
Télécharger la version Windows
Vous pouvez télécharger la dernière version de Windows à partir de la page des versions. Pour une utilisation de base de l'interface graphique, consultez la page wiki de l'interface graphique. Si vous ne pouvez pas télécharger directement depuis GitHub, essayez d'utiliser un miroir. L'interface graphique prend actuellement en charge les langues suivantes :
1. Anglais
2. Chinois simplifié
3. Chinois traditionnel
4. Japonais
5. Coréen
6. Français
7. Allemand
8. Italien
9. Espagnol
10. Portugais
11. Russe
Installer sur Linux
Vous pouvez installer Video2X sur Arch Linux à l'aide du package video2x-git ou télécharger les binaires précompilés à partir de la page des versions. Si vous souhaitez créer à partir des sources, consultez le fichier PKGBUILD pour un aperçu des packages et commandes requis. Si vous ne souhaitez pas compiler votre programme à partir des sources, pensez à utiliser l'image du conteneur ci-dessous.
image du conteneur
Les images de conteneurs Video2X sont disponibles sur le registre de conteneurs GitHub pour un déploiement facile sur Linux et macOS. Si Docker/Podman est installé, vous pouvez démarrer l'amplification vidéo avec une seule commande. Pour plus d'informations sur l'utilisation de l'image Docker de Video2X, consultez la documentation.
Google Colab (obsolète : 5.0.0-beta7)
Si vous ne disposez pas de votre propre GPU puissant, vous pouvez utiliser Video2X gratuitement sur Google Colab. Vous pouvez emprunter gratuitement un GPU puissant (NVIDIA T4, L4 ou A100) sur les serveurs de Google jusqu'à 12 heures par session. Veuillez utiliser les ressources gratuites de manière équitable, ne créez pas de sessions continues et n'exécutez pas Zoom 24h/24 et 7j/7. Cela peut entraîner votre bannissement. Si vous souhaitez utiliser un meilleur GPU et obtenir des durées d'exécution plus longues, procurez-vous Colab Pro/Pro+. Les instructions d'utilisation sont intégrées dans le notebook Colab.
Groupe de discussion sur les télégrammes
Rejoignez notre groupe de discussion Telegram pour poser toutes vos questions sur Video2X, discuter directement avec les développeurs ou discuter de la technologie super-résolution et de l'avenir de Video2X.
document
La documentation pour Video2X est hébergée sur la page Wiki de ce référentiel. Il comprend des instructions complètes sur l'utilisation de l'interface graphique, de la CLI, des images de conteneur, des bibliothèques, etc. Les wikis sont ouverts à l'édition par la communauté, donc vous, oui, vous pouvez également corriger les erreurs ou ajouter du nouveau contenu à la documentation.
introduire
Video2X est un framework de mise à l'échelle vidéo et d'interpolation de trames basé sur l'apprentissage automatique et construit autour de trois composants principaux :
1. Modèles : Video2X utilise une variété de modèles avancés d'apprentissage en profondeur pour effectuer la mise à l'échelle et l'interpolation d'images.
2. Moteur : le moteur Video2X est responsable du traitement des données vidéo, de l'inférence de modèle et de la génération de vidéos de sortie.
3. Interface : Video2X fournit diverses interfaces telles que l'interface graphique, la CLI et les images de conteneurs pour vous permettre d'utiliser facilement le framework.
Démonstration vidéo
Zoom avant : bande-annonce du film Le Voyage de Chihiro
Extrait de test standard
L'extrait suivant peut être utilisé pour tester si votre configuration fonctionne correctement. Il s'agit également d'un extrait standard pour exécuter des tests de performances.
Le clip original est tiré de l'anime "The Pet Girl of Sakurasou".
Les droits d'auteur de ce clip appartiennent à Amino Pulse Co., Ltd.
licence
Ce projet est publié sous la licence GNU AGPL version 3.
Copyright (C) 2018-2024 K4YT3X et contributeurs.
Ce projet comprend ou dépend des projets suivants :
1. opencv : https://github.com/opencv/opencv
2. waifu2x-caffe : https://github.com/nagadomi/waifu2x-caffe
3. Réel-ESRGAN : https://github.com/xinntao/Real-ESRGAN
4. BasicSR : https://github.com/xinntao/BasicSR
5. GFPGAN : https://github.com/TencentARC/GFPGAN
6. RIFE : https://github.com/hzwer/arXiv2021-RIFE
7. Anime4K : https://github.com/bloc97/Anime4K
Vous pouvez trouver plus d’informations sur les licences dans le fichier NOTICE.
merci spécial
Un merci spécial aux personnes suivantes pour leurs contributions significatives à ce projet, par ordre alphabétique :
1. K4YT3X : Créateur de projet
2. Contributeurs : Merci à tous ceux qui ont contribué à ce projet.
Par exemple:
Licence Apache-2.0
Table des matières
Cadre de détection d'objets Darknet et YOLO
1. Papier
2. Informations générales
3. Version Darknet
4. Poids de pré-entraînement MSCOCO
5. Construire
1. Google Colab
2. Méthode Linux CMake
3. Méthode Windows CMake
6. Utilisez le Darknet
1. CLI
2. Formation
7. Autres outils et liens
8. Feuille de route
1. Objectifs à court terme
2. Objectifs à moyen terme
3. Objectifs à long terme
Cadre de détection d'objets Darknet et YOLO
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.
Découvrez comment Hank.ai aide la communauté Darknet/YOLO
Annonce de Darknet V3 « Jazz »
Consultez le site Darknet/YOLO
Veuillez lire la FAQ Darknet/YOLO
Rejoignez le serveur Discord Darknet/YOLO
papier
1. Document YOLOv7
2. Papier YOLOv4 à l'échelle
3. Papier YOLOv4
4. 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 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 de jeux 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 en interne par Darknet/ YOLO.
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. Voir 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.
La prochaine bibliothèque Darknet populaire maintenue 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.
La bibliothèque Darknet sponsorisée par Hank.ai et maintenue par Stéphane Charette à partir de 2023 est la première bibliothèque à disposer d'une commande de version. De 2023 à fin 2024, il revient à la version 2.x « OAK ».
Le but est de se familiariser avec la base de code tout en brisant le moins de fonctionnalités existantes possible.
1. Réécriture des étapes de construction afin que nous puissions désormais construire sur Windows et Linux à l'aide de CMake.
2. Convertissez la base de code pour utiliser un compilateur C++.
3. Chart.png amélioré pendant la formation.
4. 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 la base de code est la version 2.1 dans la branche v2.
La prochaine phase de développement commence mi-2024 et sortira 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. Veuillez nous le faire savoir afin que nous puissions étudier l'ajout de commandes manquantes.
1. Suppression de nombreuses commandes anciennes et non maintenues.
2. Réalisation de nombreuses optimisations de performances, à la fois lors de la formation et de l'inférence.
3. Modification de l'ancienne API C ; les applications utilisant l'API Darknet d'origine devront apporter des modifications mineures : https://darknetcv.ai/api/api.html
4. Nouvelle API Darknet V3 C et C++ : https://darknetcv.ai/api/api.html
5. 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. Pour plus d’informations, consultez la FAQ Darknet/YOLO.
Les poids pré-entraînés MSCOCO peuvent être téléchargés à partir de plusieurs emplacements différents et peuvent également être téléchargés à partir de ce dépôt :
1. YOLOv2, novembre 2016
1. YOLOv2-minuscule
2.YOLOv2-complet
2. YOLOv3, mai 2018
1. YOLOv3-minuscule
2.YOLOv3-complet
3. YOLOv4, mai 2020
1.YOLOv4-minuscule
2. YOLOv4-complet
4. YOLOv7, août 2022
1. YOLOv7-minuscule
2. 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 :
`bash
wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights
darknet02displayannotatedimages coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
`
Notez qu’il faut former son propre réseau. MSCOCO est généralement utilisé pour confirmer que tout fonctionne correctement.
construire
Les différentes méthodes de build disponibles dans le 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.
Google Colab
Les instructions de Google Colab sont les mêmes que celles de 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
Tutoriel de construction Darknet pour Linux
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 requis.
N'oubliez pas de reconstruire le Darknet.
Darknet peut être exécuté sans lui, mais si vous souhaitez former un réseau personnalisé, vous aurez 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 que vous pouvez exécuter nvcc et nvidia-smi. Vous devrez peut-être modifier la variable PATH.
Si vous avez installé ultérieurement CUDA ou CUDA+cuDNN, ou si vous avez effectué une mise à niveau vers une version plus récente du logiciel NVIDIA :
Ces instructions supposent (mais n'exigent pas !) que le système exécute Ubuntu 22.04. Si vous utilisez une autre distribution, ajustez si nécessaire.
`bash
sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/srccd ~/src
clone git https://github.com/hank-ai/darknet
cd darknet
mkdir construire
construction de CD
cmake -DCMAKEBUILDTYPE=Version ..
créer le paquet -j4
sudo dpkg -i darknet-VERSION.deb
`
Si vous utilisez une ancienne version de CMake, vous devrez mettre à niveau CMake pour exécuter la commande cmake ci-dessus. La mise à niveau de CMake sur Ubuntu peut être effectuée avec la commande suivante :
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Si vous utilisez bash comme shell de commande, vous devrez redémarrer votre shell à ce moment. 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 :
`bash
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
`
Pour les distributions telles que Centos et OpenSUSE, vous devez remplacer ces deux lignes dans CM_package.cmake par :
`bash
ENSEMBLE (CPACK_GENERATOR "DEB")
ENSEMBLE (CPACK_GENERATOR "RPM")
`
Pour installer un package, utilisez le gestionnaire de packages habituel de votre distribution une fois sa construction terminée. Par exemple, sur un système basé sur Debian tel qu'Ubuntu :
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
L'installation du package .deb copiera les fichiers suivants :
1. /usr/bin/darknet est le fichier exécutable Darknet habituel. Exécutez la version darknet à partir de la CLI pour confirmer qu'elle est correctement installée.
2. /usr/include/darknet.h est l'API Darknet pour les développeurs C, C++ et Python.
3. /usr/include/darknet_version.h contient des informations de version pour les développeurs.
4. /usr/lib/libdarknet.so est une bibliothèque permettant aux développeurs C, C++ et Python de créer des liens.
5. /opt/darknet/cfg/... est l'endroit où tous les modèles .cfg sont stockés.
Vous avez terminé maintenant ! Darknet est construit et installé dans /usr/bin/. Exécutez la commande suivante pour tester : version darknet.
Si vous n'avez pas /usr/bin/darknet, 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éthodes 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 standard et exécutez la commande suivante :
`bash
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++ :
1. Cliquez sur le menu Démarrer de Windows et exécutez Visual Studio Installer.
2. Cliquez sur Modifier.
3. Choisissez le développement de bureau en utilisant C++.
4. 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 Visual Studio 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 vous connecter à l'appareil à l'aide d'une invite de commande normale ou de SSH 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 la commande suivante pour installer Microsoft VCPKG, qui sera ensuite utilisé pour créer OpenCV :
`bash
CDC:
mkdir c:srccd c:src
clone git https://github.com/microsoft/vcpkg
cdvcpkg
bootstrap-vcpkg.bat
.vcpkg.exe intégrer l'installation
.vcpkg.exe intégrer powershell.vcpkg.exe installer opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
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 que lors de la création d'OpenCV, vous devrez peut-être ajouter de nombreux autres modules facultatifs. 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 requis.
N'oubliez pas de reconstruire le Darknet.
Darknet peut être exécuté sans lui, mais si vous souhaitez former un réseau personnalisé, vous aurez 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#download-windows pour télécharger et installer 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 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é ultérieurement CUDA ou CUDA+cuDNN, 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 :
`bash
cdc:src
clone git https://github.com/hank-ai/darknet.git
cd darknet
mkdir construire
construction de CD
cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Si vous recevez une erreur concernant une DLL CUDA ou cuDNN manquante (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
`
(Ceci est un exemple ! Veuillez vérifier que vous exécutez la version et exécutez la commande appropriée pour la version que vous avez installée.)
Après avoir copié les fichiers, 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 :
Notez 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. Vérifiez le fichier darknet-VERSION.exe dans le répertoire de construction. Par exemple:
`bash
darknet-2.0.31-win64.exe
`
L'installation du package d'installation NSIS :
1. Créez un répertoire nommé Darknet, par exemple C:Program FilesDarknet.
2. Installez l'application CLI, darknet.exe et d'autres exemples d'applications.
3. Installez les fichiers .dll tiers requis, tels que ceux d'OpenCV.
4. Installez les fichiers Darknet .dll, .lib et .h nécessaires pour utiliser darknet.dll à partir d'une autre application.
5. 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 remplir 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 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 avez besoin d'un fichier .weights avec les fichiers .names et .cfg correspondants. Vous pouvez former votre propre réseau (fortement recommandé !) ou télécharger des réseaux de neurones que d'autres ont formés et sont disponibles gratuitement sur Internet. Voici des exemples d'ensembles de données de pré-formation :
1. LEGO Gears (trouver des objets dans les images)
2. Rolodex (trouver du texte dans l'image)
3. 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 faire des prédictions :
`bash
V2
Test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg
V3
darknet02displayannotatedimages cars.cfg image1.jpg
Aide sombre
DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg
`
Coordonnées de sortie :
`bash
V2
test du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput dog.jpg
V3
darknet01inference_images animaux chien.jpg
Aide sombre
DarkHelp --json animaux.cfg animaux.names animaux_best.weights chien.jpg
`
Vidéo de traitement :
`bash
V2
Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput test.mp4
V3
darknet03display_videos animaux.cfg test.mp4
Aide sombre
DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4
`
Lecture depuis la webcam :
`bash
V2
Démo du détecteur darknet animaux.data animaux.cfg animaux_best.weights -c 0
V3
darknet08display_webcam animaux
`
Enregistrer les résultats dans une 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
Aide sombre
DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4
`
JSON :
`bash
V2
Démo du détecteur darknet animaux.data animaux.cfg animauxbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
V3
darknet06imagestojson animaux image1.jpg
Aide sombre
DarkHelp --json animaux.names animaux.cfg animaux_best.weights image1.jpg
`
Exécuter sur un GPU spécifique :
`bash
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 :
`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 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
`
Pour vérifier l'exactitude 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
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
(Voir également la section formation ci-dessous)
former
Liens rapides vers les sections pertinentes de la FAQ Darknet/YOLO :
1. Comment configurer mes fichiers et répertoires ?
2. Quel profil dois-je utiliser ?
3. Quelles commandes dois-je utiliser lors de la formation de mon propre réseau ?
Le moyen le plus simple de créer tous les fichiers, annotations et formations Darknet nécessaires à l'aide de DarkMark. 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. Pour cet exemple, vous allez créer un réseau de neurones 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. Créez un fichier texte animaux.names dans le même dossier où vous avez placé le fichier de configuration. Dans cet exemple, nous avons maintenant ~/nn/animals/animals.names.
4. Utilisez votre é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, et pas de lignes vides ni de commentaires. 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
valid=/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 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.
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%). 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.
9. Assurez-vous que lot = 64.
10. 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 1. Si 1 ne fonctionne pas pour vous, consultez la FAQ Darknet/YOLO.
11. Notez que maxbatches=.... Une bonne valeur pour commencer est 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.
12. Notez steps=.... Cela doit être défini sur 80 % et 90 % des maxbatches. Dans cet exemple, puisque maxbatches est défini sur 8000, nous utiliserons steps=6400,7200.
13. Notez que width=... et height=.... Ce sont des dimensions de réseau. La FAQ Darknet/YOLO explique comment calculer la taille optimale à utiliser.
14. Recherchez dans la section [convolutionnelle] toutes les lignes classes=... avant la section [yolo] et modifiez-les avec le nombre de classes du fichier .names. Dans cet exemple, nous utiliserons classes=4.
15. Recherchez 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 dans cet exemple, (4 + 5) 3 = 27. Par conséquent, nous utilisons filters=27 sur les lignes appropriées.
Commencez à vous entraîner ! 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. 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
`
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 pour vous entraîner avec Darknet, voir DarkMark.
Pour une CLI alternative puissante à Darknet, pour utiliser la mosaïque d'images, le suivi d'objets dans vos vidéos ou pour une API C++ puissante qui peut être facilement utilisée dans des applications commerciales, consultez DarkHelp.
Vérifiez si la FAQ Darknet/YOLO peut vous aider à répondre à votre question.
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.
feuille de route
Dernière mise à jour : 2024-10-30 :
Complété
1. Remplacez qsort() utilisé lors de la formation par std::sort()
