marmite
0.1.7
Marmite
Marmite [Markdown crée des sites] est un générateur de sites statiques très simple.
L'éditeur de downcodes a déclaré : "Marmite est un générateur de sites Web statiques très simple. J'utilise souvent d'autres SSG, mais je trouve toujours trop fastidieux de les configurer à partir de zéro. Un simple répertoire de fichiers de démarques et l'exécution d'une commande peuvent générer un site Web. Cela semble vraiment pratique."
Comment utiliser
Marmite fait une chose simple :
Convertir le fichier de démarque en HTML
Il peut également gérer la génération ou la copie de fichiers statiques ou de fichiers multimédias vers le répertoire de sortie.
Installer
Installer à l'aide de cargo :
`bash
installation de fret marmite
`
Ou téléchargez les binaires précompilés à partir de la page des versions.
utiliser
C'est si simple à utiliser !
`bash
$ dossier marmite avec chemin d'accès aux fichiers markdown vers le site généré
`
Le site Web sera généré dans le répertoire pathtogenerated_site/.
CLI
`bash
❯ marmite --help
Marmite est le générateur de site statique le plus simple.
Utilisation : marmite [OPTIONS]
Arguments :
Possibilités :
--serve Servir le site avec un serveur HTTP intégré
--watch Détecter les modifications et reconstruire le site automatiquement
--lier
Adresse pour lier le serveur [par défaut : localhost:8000]
--config
Chemin d'accès au fichier de configuration personnalisé [par défaut : marmite.yaml]
--debug Afficher les messages de débogage
--init-templates Initialiser les modèles dans le projet
--start-theme Initialiser un thème avec des modèles et des ressources statiques
-h, --help Imprimer l'aide
-V, --version Version imprimable
`
Commencer
Lisez le tutoriel pour savoir comment démarrer avec Marmite https://rochacbruno.github.io/marmite/getting-started.html et passez quelques minutes à créer votre blog.
document
Apprenez-en davantage sur la façon de personnaliser les modèles, d'ajouter des commentaires et bien plus encore sur https://rochacbruno.github.io/marmite/.
Résumer
La marmite est très simple.
Si cette simplicité ne répond pas à vos besoins, il existe d'autres excellents générateurs de sites Web statiques. En voici quelques-uns que je recommande :
Jekyll
Hugo
Gatsby
Suivant.js
Cadre de détection d'objets Darknet et YOLO
Aperçu
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.
Liens importants :
Comment Hank.ai aide la communauté Darknet/YOLO
Site Web Darknet/YOLO
FAQ Darknet/YOLO
Serveur Discord Darknet/YOLO
papier
Article YOLOv7
Papier YOLOv4 à l'échelle
Papier YOLOv4
Article YOLOv3
informations générales
Le framework Darknet/YOLO surpasse systématiquement les autres frameworks et versions YOLO en termes de vitesse et de précision.
Le framework est entièrement gratuit et open source. Vous pouvez intégrer Darknet/YOLO dans des projets et produits existants, y compris des produits commerciaux, sans licence ni frais.
Darknet V3 (« Jazz »), sorti en octobre 2024, peut exécuter avec précision des vidéos de jeux de données LEGO jusqu'à 1 000 FPS lors de l'utilisation d'un GPU NVIDIA RTX 3090, ce qui signifie que Darknet/YOLO lit en 1 milliseconde ou moins. Récupère, redimensionne et traite chaque image vidéo. .
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 fonctionne 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.
Le prochain référentiel Darknet populaire maintenu par Alexey Bochkovskiy de 2017 à 2021 n'avait 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 casser 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 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 consulter la branche v2 précédente. Faites-le-nous savoir afin que nous puissions étudier l'ajout de commandes manquantes.
Suppression de nombreuses commandes anciennes et non maintenues.
De nombreuses optimisations de performances, y compris des optimisations lors de la formation et de l'inférence.
Ancienne API C modifiée ; les applications utilisant l'API Darknet d'origine nécessitent 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 à l'aide de l'ensemble de données MSCOCO. Cet ensemble de données contient 80 catégories et peut être consulté dans le fichier texte cfg/coco.names.
Il existe 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 ou de ce référentiel :
YOLOv2 (novembre 2016)
- yolov2-tiny.weights
- yolov2-full.weights
YOLOv3 (mai 2018)
- yolov3-tiny.weights
- yolov3-full.weights
YOLOv4 (mai 2020)
- yolov4-tiny.weights
- yolov4-full.weights
YOLOv7 (août 2022)
- yolov7-tiny.weights
- yolov7-full.weights
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 souvent utilisé pour confirmer que tout va bien.
Construire
Diverses méthodes de construction du passé (avant 2023) ont été fusionnées en une solution unifiée. Darknet nécessite C++ 17 ou supérieur, OpenCV et l'utilisation de CMake pour générer les fichiers de projet nécessaires.
Vous n'avez pas besoin de connaître le C++ pour créer, installer ou exécuter Darknet/YOLO, tout comme vous n'avez pas besoin d'être mécanicien pour conduire une voiture.
Google Colab
Les instructions de Google Colab sont les mêmes que celles de Linux. Un certain nombre de blocs-notes Jupyter sont fournis montrant 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
1. Installez le logiciel nécessaire :
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clonez le référentiel Darknet :
`bash
clone git https://github.com/hank-ai/darknet
`
3. Créez le répertoire de construction :
`bash
cd darknet
mkdir construire
construction de CD
`
4. Utilisez CMake pour générer des fichiers de build :
`bash
cmake -DCMAKEBUILDTYPE=Version ..
`
5. Créez le Darknet :
`bash
faire -j4
`
6. Installez Darknet (facultatif) :
`bash
faire un paquet
sudo dpkg -i darknet-VERSION.deb
`
Avis:
Si un GPU NVIDIA est installé sur votre système, vous pouvez installer CUDA ou CUDA+cuDNN pour accélérer le traitement des images (et des vidéos).
Si vous installez CUDA ou CUDA+cuDNN ou mettez à niveau le logiciel NVIDIA, vous devez supprimer le fichier CMakeCache.txt dans le répertoire de construction et reconstruire Darknet.
Vous pouvez utiliser la commande darknet version pour vérifier si Darknet a été installé avec succès.
Méthodes Windows CMake
1. Installez le logiciel nécessaire :
`bash
Winget installe Git.Git
Winget installe Kitware.CMake
Winget installe nsis.nsis
Winget installe Microsoft.VisualStudio.2022.Community
`
2. Modifiez l'installation de Visual Studio :
- Ouvrez le menu Démarrer de Windows et exécutez Visual Studio Installer.
- Cliquez sur "Modifier".
- Sélectionnez "Développement bureautique en C++".
- Cliquez sur « Modifier » dans le coin inférieur droit, puis cliquez sur « Oui ».
3. Installez Microsoft VCPKG :
`bash
CDC:
mkdir c:src
cdc:src
clone git https://github.com/microsoft/vcpkg
cdvcpkg
bootstrap-vcpkg.bat
.vcpkg.exe installation intégrée
.vcpkg.exe intègre PowerShell
.vcpkg.exe installer opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
4. Clonez le référentiel Darknet :
`bash
cdc:src
clone git https://github.com/hank-ai/darknet.git
cd darknet
mkdir construire
construction de CD
`
5. Utilisez CMake pour générer des fichiers de build :
`bash
cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
6. Créez le Darknet :
`bash
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
7. Installez Darknet :
- Exécutez le fichier darknet-VERSION.exe dans le répertoire de construction pour démarrer l'assistant d'installation de NSIS.
Avis:
Si un GPU NVIDIA est installé sur votre système, vous pouvez installer CUDA ou CUDA+cuDNN pour accélérer le traitement des images (et des vidéos).
Si vous installez CUDA ou CUDA+cuDNN ou mettez à niveau le logiciel NVIDIA, vous devez supprimer le fichier CMakeCache.txt dans le répertoire de construction et reconstruire Darknet.
Vous pouvez utiliser la commande de version darknet.exe pour vérifier si Darknet a été installé avec succès.
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 pour Darknet/YOLO. DarkHelp CLI possède également plusieurs fonctionnalités avancées non disponibles dans Darknet. Vous pouvez utiliser Darknet CLI et DarkHelp CLI en même temps, ils ne s'excluent pas mutuellement.
Pour la plupart des commandes présentées ci-dessous, vous devez utiliser le fichier .weights correspondant aux fichiers .names et .cfg. 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 publiés gratuitement sur Internet. Voici des exemples d'ensembles de données de pré-formation :
LEGO Gears (trouver des objets dans les images)
Rolodex (trouver du texte dans l'image)
MSCOCO (détection d'objets standard de 80 catégories)
Les commandes à exécuter incluent :
Aide Darknet : affiche les informations d'aide.
Version darknet : Vérifiez la version.
Test du détecteur darknet cars.data cars.cfg cars_best.weights image1.jpg : utilisez des images pour la prédiction (V2).
darknet02displayannotatedimages cars.cfg image1.jpg : Prédiction par images (V3).
DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg : Prédiction à l'aide d'images (DarkHelp).
test du détecteur darknet animaux.data animaux.cfg animauxbest.weights -extoutput dog.jpg : coordonnées de sortie (V2).
darknet01inference_images animaux dog.jpg : Coordonnées de sortie (V3).
DarkHelp --json animaux.cfg animaux.names animaux_best.weights dog.jpg : coordonnées de sortie (DarkHelp).
Démo du détecteur darknet animal.data animaux.cfg animauxbest.weights -extoutput test.mp4 : Traitement vidéo (V2).
darknet03display_videos cats.cfg test.mp4 : Traitement des vidéos (V3).
DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4 : Traitement de la vidéo (DarkHelp).
Démo du détecteur darknet animal.data animaux.cfg animaux_best.weights -c 0 : Lecture depuis la webcam (V2).
darknet08display_webcam animaux : Lire depuis la webcam (V3).
Démo du détecteur darknet animal.data animaux.cfg animauxbest.weights test.mp4 -outfilename res.avi : enregistrez les résultats dans une vidéo (V2).
darknet05processvideosmultithreaded animaux.cfg animaux.names animaux_best.weights test.mp4 : Enregistrer les résultats dans la vidéo (V3).
DarkHelp animaux.cfg animaux.names animaux_best.weights test.mp4 : Enregistrer les résultats dans une vidéo (DarkHelp).
Démo du détecteur darknet animal.data animaux.cfg catsbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput : utilisez le format JSON (V2).
darknet06imagestojson animaux image1.jpg : Utiliser le format JSON (V3).
DarkHelp --json animaux.names animaux.cfg animaux_best.weights image1.jpg : utilisez le format JSON (DarkHelp).
Démo du détecteur darknet animal.data animaux.cfg animaux_best.weights -i 1 test.mp4 : exécuté sur un GPU spécifique.
Carte du détecteur Darknet Driving.data Driving.cfg Driving_best.weights ... : Vérifiez l'exactitude du réseau neuronal.
Carte du détecteur darknet animaux.data animaux.cfg animauxbest.weights -iouthresh 0,75 : Vérifiez l'exactitude de mAP@IoU=75.
détecteur de darknet calcanchors animaux.data -numof_clusters 6 -largeur 320 -hauteur 256 : recalculer les points d'ancrage.
darknet detector -map -dont_show train animaux.data animaux.cfg : Former un nouveau réseau.
former
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 ?
L'utilisation de l'annotation et de la formation DarkMark est la méthode la plus simple, qui crée tous les fichiers Darknet nécessaires. C'est certainement la méthode recommandée pour former de nouveaux réseaux de neurones.
Si vous préférez configurer manuellement les différents fichiers pour entraîner un réseau personnalisé, procédez comme suit :
1. Créez un nouveau dossier pour stocker les fichiers. Par 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 un fichier de configuration Darknet que vous souhaitez utiliser comme modèle. Voir, par exemple, cfg/yolov4-tiny.cfg. Placez-le dans le dossier que vous avez créé. Pour cet exemple, nous avons maintenant ~/nn/animals/animals.cfg.
3. Créez un fichier texte animaux.names dans le même dossier où vous placez le fichier de configuration. Pour cet exemple, 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. Chaque ligne doit contenir exactement un élément, sans lignes vides ni commentaires. Pour cet exemple, le fichier .names contiendra les 4 lignes suivantes :
`
chien
chat
oiseau
cheval
`
5. Créez un fichier texte animaux.data dans le même dossier. Pour cet exemple, le fichier .data contiendra :
`
cours=4
train=/home/username/nn/animals/animals_train.txt
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 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%). 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 batch=64.
- Faites attention aux subdivisions. En fonction des dimensions du réseau et de la quantité de mémoire disponible sur le GPU, vous devrez peut-être augmenter les subdivisions. La valeur optimale est 1, alors commencez par cela. Si 1 ne fonctionne pas pour vous, veuillez consulter la FAQ Darknet/YOLO.
- Notez maxbatches=…. Une bonne valeur pour commencer est le nombre de catégories multiplié par 2000. 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, puisque maxbatches est défini sur 8000, nous utiliserons steps=6400,7200.
- Notez width=... et height=.... Ce sont des dimensions de réseau. La FAQ Darknet/YOLO explique comment calculer la taille optimale à utiliser.
- Recherchez toutes les lignes classes=... et modifiez-les avec le nombre de classes dans votre fichier .names. Pour cet exemple, nous utiliserons classes=4.
- Recherchez toutes les lignes filter=... dans la section [convolutionnelle] avant chaque section [yolo]. La valeur à utiliser est (nombre de catégories + 5) 3. Cela signifie que pour cet exemple, (4 + 5) 3 = 27. Par conséquent, nous utilisons filters=27 sur les lignes appropriées.
9. Commencez la formation ! Exécutez la commande suivante :
`bash
cd ~/nn/animaux/
détecteur darknet -map -dont_show train animaux.data animaux.cfg
`
S'il vous plaît, attendez. Les meilleurs poids seront enregistrés sous le nom animaux_best.weights. 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 puissante alternative CLI à Darknet pour travailler avec la mosaïque d'images, le suivi d'objets dans la vidéo ou une puissante API C++ qui peut être facilement utilisée dans des applications commerciales, consultez DarkHelp.
Veuillez consulter la FAQ Darknet/YOLO pour voir si elle 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é
Remplacement de qsort() par std::sort() pendant la formation (d'autres remplacements obscurs existent encore)
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 sur 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 instrumentation CUDA
Suppression de l'ancien code "alphabet" et suppression de plus de 700 images dans les données/étiquettes
Construire du code source externe
Avoir 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++ correct
Corriger ou conserver les structures d’image internes utilisées de manière cohérente
Correction de la version pour les appareils Jetson à architecture ARM
- Il est peu probable que les appareils Jetson d'origine soient réparés car ils ne sont plus pris en charge par NVIDIA (pas de compilateur C++17)
- Nouvel appareil Jetson Orin en cours d'exécution
Correction de l'API Python dans la V3
- Besoin d'un meilleur support Python (y a-t-il des développeurs Python prêts à aider avec ce problème ?)
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 char* et remplacez-les par std :: string
Ne cachez pas les avertissements et nettoyez les avertissements du compilateur (travail en cours)
Meilleure utilisation de cv::Mat au lieu des structures d'images personnalisées en C (travail en cours)
Remplacez les anciennes fonctions de liste par std :: vector ou std :: list
Correction de la prise en charge des images en niveaux de gris à canal unique
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 liés à 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
