Apprentissage Automatique et Réseaux Neuronaux - page 38

Nouveau commentaire
 

Segmenter des images et des vidéos en Python à l'aide de Segment Anything Model (SAM) | YOLOv5 | YOLOv8 et SAM



Segmenter des images et des vidéos en Python à l'aide de Segment Anything Model (SAM) | YOLOv5 | YOLOv8 et SAM

Cette vidéo présente le Segment Anything Model (SAM), un modèle d'IA capable d'identifier et d'extraire des objets d'images et de vidéos pour diverses tâches. Le SAM est formé sur un énorme ensemble de données de 11 milliards d'images et 1,1 milliard de masques et a de fortes performances dans une variété de tâches de segmentation. La vidéo fournit des instructions étape par étape pour utiliser le SAM sur un système local, y compris comment installer les packages nécessaires, télécharger des points de contrôle de modèle pré-formés et effectuer une segmentation sur des images et des vidéos à l'aide de Python. La vidéo montre également comment utiliser le SAM avec YOLOv5 ou YOLOv8 pour créer des cadres de délimitation autour des objets d'intérêt. Le SAM a également des applications potentielles dans l'animation.

  • 00:00:00 Dans cette section, la vidéo présente le Segment Anything Model (SAM), un modèle d'IA récemment publié par Meta qui peut identifier et extraire des objets d'images et de vidéos pour diverses tâches. Le SAM est entraîné sur 11 milliards d'images et 1,1 milliard de masques et possède une forte généralisation sans prise de vue sur une variété de tâches de segmentation. La vidéo montre comment utiliser le SAM à travers une démo qui permet aux utilisateurs de télécharger une image et d'effectuer une segmentation sur l'image complète ou de couper chaque objet séparément. Les utilisateurs peuvent également dessiner des cadres de délimitation, ajouter des masques et effectuer des masquages multiples. Le SAM a également des applications potentielles dans l'animation. La vidéo fournit également des informations supplémentaires sur l'architecture du SAM, la disponibilité des ensembles de données et les questions fréquemment posées.

  • 00:05:00 Dans cette section de la vidéo, le présentateur montre comment utiliser le Segment Anything Model (SAM) pour créer des masques multiples pour différents objets dans une image. Le SAM a été formé sur un ensemble de données de 11 millions d'images et 1,1 milliard de masques et a une forte performance sur une variété de tâches de segmentation. Le présentateur montre comment sélectionner une image, exécuter la segmentation sur l'image complète, puis découper les objets séparés. Le présentateur montre également comment dessiner des cadres de délimitation autour des objets et comment télécharger et distribuer les données résultantes. La vidéo se termine par des informations sur l'installation de SAM et son utilisation dans Python, y compris avec YOLOv5 et YOLOv8.

  • 00:10:00 Dans cette section de la vidéo, le présentateur explique les exigences pour exécuter le modèle de segment n'importe quoi sur un système local, y compris avoir un GPU et installer les packages nécessaires tels que Torch et Dodge Vision avec prise en charge CUDA. Ils montrent comment cloner le référentiel Segment Anything Model et installer toutes les dépendances requises à l'aide de pip. La vidéo explique également comment convertir un modèle de segmentation au format ONNX et comment télécharger les points de contrôle du modèle pré-formés pour trois tailles de backbone différentes. Le présentateur montre ensuite comment effectuer une segmentation sur des images et des vidéos à l'aide du modèle. La vidéo comprend également des instructions détaillées étape par étape pour chaque tâche, ce qui permet aux téléspectateurs de suivre facilement.

  • 00:15:00 Dans cette section de la vidéo, le présentateur importe d'abord toutes les bibliothèques requises, y compris Matplotlib pour afficher les images d'entrée et de sortie dans le bloc-notes de l'application Google. Ils téléchargent ensuite des exemples d'images à partir de leur lecteur et montrent une image d'exemple de plusieurs personnes marchant avec des bâtiments en arrière-plan. Ensuite, ils chargent un point de contrôle de modèle pré-formé avec bord de tiret sur le bloc-notes de l'application Google et appliquent le générateur de masque automatique de modèle de segment n'importe quoi aux images pour les segmenter. Le présentateur fournit des points par côté des images qui sont utilisés par le SMAM pour numériser l'image et la segmenter en fonction des points fournis. Un seuil IOT de prédiction de 0,9 est défini pour augmenter la précision de la segmentation.

  • 00:20:00 Dans cette section de la vidéo, le présentateur montre comment utiliser le Segment Anything Model (SAM) pour effectuer une segmentation d'objets sur des images et des vidéos à l'aide de Python. Ils montrent comment ajuster la planification IU pour augmenter la précision et réduire la quantité de fichiers inutiles dans la sortie. Ils appliquent le modèle de segmentation à un exemple d'image et montrent comment il segmente avec précision la personne, le bâtiment et l'arbre. Ils utilisent ensuite le même modèle pour segmenter un exemple de vidéo en installant le package de méta-segmentation et en téléchargeant des exemples de vidéos depuis Google Drive. Le présentateur copie ensuite le code d'un référentiel GitHub et l'applique à la vidéo, implémentant efficacement le SAM sur la vidéo.

  • 00:25:00 Dans cette section, l'orateur discute du référentiel Segment Anything Model (SAM), qui contient trois modèles différents avec différentes tailles de dorsale, permettant aux utilisateurs de définir le nom du modèle et d'appeler la vidéo qu'ils souhaitent mettre en œuvre. L'orateur parcourt ensuite le code requis pour intégrer le SAM avec YOLOv5 ou YOLOv8, en utilisant des packages existants et des exemples d'images. L'orateur montre comment le SAM est utilisé pour effectuer une segmentation sur les bâtiments, les arbres et les voitures, en utilisant des codes de couleur pour débruiter la sortie. Le conférencier discute également des différentes versions de modèles de segmentation, indiquant que chaque modèle a une taille de dorsale différente. La démonstration met en évidence la précision et la vitesse du plus petit modèle YOLOv8 Nano.

  • 00:30:00 Dans cette section, l'intervenant montre comment il a pu utiliser le Segment Anything Model (SAM) avec YOLOv8 pour effectuer une segmentation et créer des cadres de délimitation autour des objets d'intérêt. Ils démontrent la capacité du modèle en présentant une boîte englobante qui entoure une personne et effectue également une segmentation de son image. L'orateur conclut le didacticiel vidéo en soulignant l'intégration de YOLOv8 avec SAM et en disant au revoir aux téléspectateurs.
 

Cours YOLOv8 - Application Web de détection d'objets en temps réel utilisant YOLOv8 et Flask - Webcam/caméra IP


Cours YOLOv8 - Application Web de détection d'objets en temps réel utilisant YOLOv8 et Flask - Webcam/caméra IP

Le cours YOLOv8 est une série de didacticiels qui guident les spectateurs dans la création d'une application Web de détection d'objets en temps réel à l'aide de YOLOv8 et Flask. Les didacticiels couvrent l'installation des logiciels nécessaires tels que Python et PyCharm, la création d'un environnement virtuel, l'installation de packages et le test de la détection d'objets sur les images et les webcams. Les didacticiels couvrent également la conversion de la sortie des tenseurs en nombres entiers, l'étiquetage des objets détectés et l'enregistrement de la vidéo de sortie avec les détections. Les téléspectateurs apprennent à intégrer YOLOv8 à Flask et à exécuter l'application Web de détection d'objets en temps réel sur les flux vidéo et webcam en direct.

Dans la deuxième partie de la vidéo, le présentateur montre comment créer une application Web à l'aide de Flask et YOLOv8 pour la détection d'objets sur les flux et vidéos de webcam en direct, en plus de présenter la formation et l'inférence d'un modèle personnalisé pour la détection des équipements de protection individuelle. L'application Web a une page d'accueil, une page vidéo et une page de flux de webcam en direct, avec un style CSS pour chaque page, et le présentateur parcourt les fichiers HTML et Flask utilisés pour le projet. La vidéo montre le processus d'importation d'un ensemble de données, sa préparation pour la formation du modèle YOLOv8, la formation du modèle, l'analyse des résultats et le test du modèle sur des vidéos de démonstration. Dans l'ensemble, la vidéo fournit un didacticiel complet pour développer et tester une application Web de détection d'objets en temps réel.

Le présentateur discute également des modifications apportées à une application Web qui utilise le modèle YOLOv8 formé sur un ensemble de données d'équipement de protection individuelle (EPI). Les modifications incluent la modification du code pour attribuer différentes couleurs aux cadres de délimitation et aux rectangles d'étiquettes en fonction des noms de classe et la définition d'un score de confiance supérieur à 0,5 pour que les cadres de délimitation et les rectangles apparaissent. Le présentateur démontre la détection réussie d'éléments d'EPI dans une vidéo et un flux de webcam en direct, marquant la fin du cours.

  • 00:00:00 L'étape suivante consiste à télécharger et installer Python et PyCharm Community Edition. La dernière version de Python n'est pas recommandée car elle peut contenir des erreurs et des corrections de bogues. Nous pouvons télécharger la dernière version de Python 3.8 qui est recommandée. La version professionnelle de PyCharm offre un essai gratuit de 30 jours, mais l'édition communautaire est suffisante pour le didacticiel. Une fois que nous avons téléchargé et installé le logiciel nécessaire, nous pouvons créer un dossier vide avec le nom de notre choix, puis l'ouvrir dans PyCharm pour démarrer le projet.

  • 00:05:00 Dans cette section du cours accéléré YOLOv8, l'instructeur montre comment créer un nouvel environnement virtuel dans Pycharm et installer les packages nécessaires au projet. L'instructeur montre comment créer un nouveau projet, sélectionner l'interpréteur de base et installer les packages via la fenêtre du gestionnaire de packages. Ils montrent également comment créer un fichier requirements.txt pour noter tous les packages que vous souhaitez installer à partir de la ligne de commande. La vidéo souligne l'importance d'installer le package ultralytics pour la détection d'objets à l'aide de YOLOv8.

  • 00:10:00 Dans cette section, l'instructeur montre comment installer YOLOv8, qui est la seule version de YOLO qui possède son propre package. En utilisant pip install ultralytics, YOLOv8 peut être installé, et si des modifications doivent être apportées au script de détection ou de formation, le référentiel peut être cloné. L'instructeur utilise ensuite YOLOv8 pour détecter des objets dans une image en important le package et le modèle YOLOv8, en spécifiant le fichier de poids pré-formé et en transmettant le chemin de l'image d'entrée. Les résultats montrent les objets détectés dans l'image.

  • 00:15:00 Dans cette section, la vidéo montre comment tester le modèle YOLOv8 sur de nouvelles images en les ajoutant au dossier images et en exécutant le script de test YOLO. Après avoir importé la bibliothèque cv2 et ajouté un délai, le modèle produit des résultats assez impressionnants en détectant avec précision les motos et les voitures. La vidéo aborde également le problème de la précision par rapport à la vitesse lors de l'utilisation de différents modèles YOLO et suggère d'utiliser le modèle YOLOv8x pour des résultats encore plus précis. La vidéo passe ensuite au test du modèle YOLOv8 sur une webcam en utilisant un nouveau répertoire.

  • 00:20:00 Dans cette section de la vidéo, le présentateur crée un nouveau fichier appelé "YOLOv8_webcam.py". Ils importent YOLOv8, CB2 et math, et définissent "cap" comme égal à "CV2.videoCapture(0)", ce qui leur permettra d'exécuter YOLOv8 sur leur webcam. Ils calculent la fréquence d'images et la hauteur en appelant respectivement "cap.get(5)" et "cap.get(4)". Ils expliquent qu'ils veulent enregistrer la vidéo de sortie avec les détections, ils définissent donc le nom du fichier de sortie comme "output.avi" en utilisant CB2.VideoWriter(). Ils transmettent la fréquence d'images et la hauteur à la fonction, puis définissent "moderne" comme égal à "YOLOv8". Le présentateur teste ensuite si sa webcam fonctionne correctement en appelant "CV2.imshow('image', image)" et "CV2.waitKey(1)" sur son image.

  • 00:25:00 Dans cette section du cours YOLOv8, le présentateur teste la webcam et vérifie si la vidéo de sortie est correctement enregistrée. Il procède ensuite à l'exécution des détections sur le flux Web en direct à l'aide du modèle YOLOv8 et enregistre les résultats dans une variable nommée 'results'. Le code parcourt chacune des boîtes englobantes individuelles pour voir les performances. Chaque boîte englobante a quatre coordonnées - X1, Y1, X2 et Y2, qui sont converties sous forme entière à partir de tenseurs pour un traitement ultérieur et la création de boîtes englobantes autour de l'objet détecté.

  • 00:30:00 Dans cette section de la vidéo, le présentateur explique comment la sortie est convertie de tenseurs en nombres entiers et comment un rectangle est créé autour de chaque objet détecté à l'aide de cv2.rectangle. La couleur et l'épaisseur de la boîte englobante sont définies avec le point de départ et d'arrivée pour chaque objet détecté. La sortie de l'application montre que les cadres de délimitation sont parfaitement dessinés autour des objets détectés. Cependant, le présentateur mentionne la nécessité d'afficher également l'étiquette et le score de confiance pour chaque objet détecté. Le score de confiance est actuellement affiché sous forme de tenseurs, mais le présentateur prévoit de le convertir en entier à l'aide de mat.c.

  • 00:35:00 Dans cette section du didacticiel vidéo, l'instructeur montre aux spectateurs comment ajouter des scores de confiance aux objets détectés, les convertir en nombres entiers et les étiqueter en fonction de leur ID de classe. L'ID de classe est déterminé par le type d'objet, 0 étant une personne, 1 un vélo et 2 une voiture. L'instructeur montre également comment créer un rectangle autour de l'étiquette et enregistrer les détections de sortie dans un fichier nommé output.avi. Les téléspectateurs peuvent voir les détections en direct image par image, et l'instructeur leur montre comment arrêter le processus en cliquant sur l'écran. L'instructeur affiche également le fichier vidéo de sortie et confirme que les résultats sont conformes aux attentes. Enfin, l'instructeur annonce que dans le prochain tutoriel, ils exécuteront YOLOv8 sur Windows et partageront les résultats.

  • 00:40:00 Dans cette section du cours YOLOv8, le créateur montre comment effectuer la détection d'objets sur un exemple de vidéo à l'aide de poids pré-formés YOLOv8. L'objectif est de détecter à la fois les vélos et les personnes, qui font partie de l'ensemble de données COCO. Le créateur montre comment exécuter le script et rediriger le dossier vers le dossier vidéo désigné, puis détecte avec succès les vélos, les personnes et d'autres objets, comme un feu de circulation. Le créateur démontre ensuite que la vidéo de sortie avec les détections est enregistrée dans le dossier sélectionné, montrant les cadres de délimitation autour des objets détectés avec des étiquettes et des scores de confiance. La fonction de détection vidéo est créée pour contenir tout le code, et un fichier nommé last app dot Pi est créé.

  • 00:45:00 Dans cette section de la vidéo, l'intervenant discute des étapes nécessaires pour intégrer YOLOv8 à Flask afin de créer une application Web de détection d'objets en temps réel. La première étape consiste à installer Flask, qui se fait à l'aide de pip install. Ensuite, le haut-parleur importe les bibliothèques nécessaires et initialise Flask. Ensuite, ils créent une fonction appelée générer une image qui prend le chemin du fichier vidéo d'entrée et génère la sortie avec des cadres de délimitation autour des objets détectés. Enfin, l'orateur discute de l'encodage des images sous forme d'octets et de la conversion d'images individuelles en une vidéo à l'aide du clavier de suppression. Le résultat final est des cadres individuels avec des cadres de délimitation autour de l'objet détecté, des étiquettes et des scores de confiance.

  • 00:50:00 Dans cette section, le créateur de la vidéo explique comment intégrer YOLOv8 à Flask pour créer une application Web de détection d'objets en temps réel. La vidéo montre l'encodage des images et la conversion de l'image en octets, suivie d'une boucle sur des images individuelles pour la détection et l'affichage ultérieur des images. La vidéo présente le remplacement des images visuelles à l'aide du type de moyen, tandis que le type de contenu est utilisé pour afficher les images suivantes. La vidéo comprend une démonstration où le fichier vidéo est transmis comme entrée pour la détection, ce qui entraîne des boîtes de délimitation autour des objets détectés ; dans ce scénario, les personnes, les vélos et les feux de circulation. La vidéo se termine en indiquant que le prochain didacticiel couvrira la détection sur les flux de webcam en direct, créant ainsi une API Fly Fast.

  • 00:55:00 Dans cette section, le présentateur montre comment exécuter l'application Web de détection d'objets en temps réel YOLOv8 sur un flux de webcam en direct. En changeant le chemin vidéo à 0 dans le script, le programme peut être exécuté sur le flux de webcam en direct. Une nouvelle URL est créée et liée à l'application Flask, permettant la détection d'objets en temps réel du flux de webcam en direct. Le présentateur montre que le programme peut détecter avec précision des objets tels qu'une personne, un vélo et un feu de circulation à partir du flux en direct. De plus, le chemin de la vidéo est remplacé par l'URL de la vidéo et le programme démontre également sa capacité à détecter des objets dans une vidéo.

  • 01:00:00 Dans cette section, le didacticiel vidéo se concentre sur la création d'une page Web HTML complète en utilisant HTML et CSS pour la conception frontale et Flask pour le back-end. L'application Web se compose de trois pages différentes : une page d'accueil, une page vidéo et une page de flux de webcam en direct. La page d'accueil comporte un en-tête, un contenu et un pied de page avec des exemples de résultats de différents projets. La page vidéo permet à l'utilisateur de télécharger une vidéo et d'exécuter des détections YOLOv8 sur cette vidéo. La page de flux de webcam en direct permet à l'utilisateur d'effectuer des détections sur le flux de webcam en direct. La vidéo présente également le fichier de pile de points de l'application Flask et les trois pages HTML.

  • 01:05:00 Dans cette section, le didacticiel vidéo explique comment permettre aux utilisateurs de télécharger un fichier vidéo sur le modèle de détection d'objet à l'aide du formulaire Flask. Le didacticiel utilise des validateurs pour s'assurer que l'utilisateur télécharge le fichier vidéo dans le bon format (MP4 ou .avi). Le chemin d'accès au fichier vidéo téléchargé est stocké dans la variable de fichier à l'aide du formulaire de classe. Le didacticiel présente également la fonction de génération d'images utilisée pour détecter des objets dans le fichier vidéo d'entrée. Le fichier vidéo d'entrée est enregistré dans le dossier des fichiers statiques et l'utilisateur peut soumettre le fichier vidéo pour détection en cliquant sur le bouton Soumettre.

  • 01:10:00 Dans cette section du cours YOLOv8, l'accent est mis sur la fonction de détection que nous avons dans le fichier vidéo YOLO Dash. La fonction de réduction vidéo nous fournit une direction et avec la détection d'objet, il y a des boîtes de délimitation de sortie autour des objets détectés avec des étiquettes et des scores de confiance. Les images actuelles sont ensuite converties en octets, comme requis par l'image ou les images d'entrée de Flask. La fonction Web de génération de cadre est appelée lorsque nous voulons accéder ou rediriger vers la webcam sur l'application, avec un point de session clair supprimant les fichiers vidéo d'entrée du stockage de session, permettant à la détection de se produire sur de nouvelles vidéos ou fichiers d'entrée, pas le précédent ceux. L'instance de formulaire de fichier de téléchargement est créée, avec le chemin du fichier vidéo enregistré dans la variable de stockage de session. Le stockage de la session est effacé par la suite pour garantir que la détection se produit sur les nouvelles vidéos, empêchant l'application de détecter les vidéos ou les fichiers d'entrée précédents.

  • 01:15:00 Dans cette section, l'orateur explique le code et les fichiers HTML utilisés dans le cours YOLOv8 pour la détection d'objets en temps réel dans une application Web à l'aide de Flask et d'une webcam/caméra IP. L'orateur montre comment il a enregistré la partie vidéo dans le stockage de session et a appelé le chemin vidéo pour effectuer les détections dans la vidéo. Ils affichent également le fichier Flask app dot Pi pour le projet. Le fichier HTML comprend la langue, le titre de la page, le corps et les en-têtes avec leurs propriétés, telles que la couleur d'arrière-plan, la famille de polices, la couleur du texte, la hauteur et d'autres éléments. De plus, l'orateur explique le but du rayon de bordure dans la création d'une forme de rectangle arrondi.

  • 01:20:00 Dans cette section, l'orateur présente les principales pages de l'application Web qu'il a créée. Ils commencent par afficher l'URL de la page d'accueil Dash qui dirige l'utilisateur vers la page de flux vidéo, où il peut télécharger une vidéo et faire en sorte que des détections d'objets se produisent. Ensuite, ils affichent la page UI.html, où les détections se produisent sur le flux de webcam en direct. Ils présentent également l'exemple de page de résultats, montrant trois images qu'ils ont enregistrées et transmises au HTML. Enfin, ils affichent le pied de page qui, lorsqu'il est cliqué, redirige l'utilisateur vers sa chaîne YouTube. Tout au long de la démonstration, l'orateur montre le style CSS qu'il a utilisé pour chaque page.

  • 01:25:00 Dans cette section, l'orateur présente l'application Web de détection d'objets en temps réel utilisant YOLOv8 et Flask avec un flux de webcam en direct et une vidéo. Le style CSS est ajouté à la page Web et l'orateur exécute le fichier cap de classe Python pour effectuer les détections sur la vidéo ainsi que le flux de webcam en direct. L'utilisateur peut également saisir un fichier vidéo pour obtenir les détections. Les résultats sont impressionnants car le modèle YOLOv8 est capable de détecter des objets tels que des personnes, des vélos, des feux de circulation, etc., et de créer des boîtes englobantes avec les étiquettes et le score de confiance. L'orateur conclut en démontrant que les détections sur le flux de la webcam en direct fonctionnent également avec précision.

  • 01:30:00 Dans cette section de la vidéo, le présentateur présente une application Web Flask qui peut détecter des objets dans les flux vidéo et webcam en direct à l'aide de YOLOv8. L'application dispose d'une page d'accueil, d'une page vidéo avec la possibilité d'effectuer des détections sur n'importe quelle vidéo d'entrée et d'une page de flux de webcam en direct. Le présentateur poursuit ensuite en démontrant comment YOLOv8 peut être utilisé pour la détection des équipements de protection individuelle (EPI) à l'aide d'un ensemble de données disponible sur Roboflow, qui se compose de 3235 images avec 7 classes différentes. Le présentateur renomme les classes en conséquence pour refléter les objets réels détectés par YOLOv8, et le présentateur affiche ensuite les statistiques de l'ensemble de données, qui incluent une distribution de classe déséquilibrée. Le ratio de partage utilisé pour l'ensemble de données est 70-20-10. Enfin, le présentateur montre comment importer le modèle YOLOv8 dans un bloc-notes Collab.

  • 01:35:00 Dans cette section du cours YOLOv8, l'instructeur explique comment importer les bibliothèques requises et vérifier l'accès au GPU. La bibliothèque du système d'exploitation est utilisée pour naviguer vers différents fichiers et la bibliothèque d'images est utilisée pour afficher les images d'entrée/sortie dans le bloc-notes Google Colab. L'ensemble de données de détection de données EPI est ensuite importé de Roboflow et téléchargé dans le dossier « ensembles de données » nouvellement créé. Le modèle YOLOv8 est installé à l'aide de pip install ultralytics et sa fonctionnalité est ensuite vérifiée pour l'installation et le fonctionnement à l'aide d'import ultralytics.

  • 01:40:00 Dans cette section de la vidéo, le présentateur montre comment télécharger et préparer l'ensemble de données de détection d'EPI pour former un modèle YOLOv8. L'ensemble de données se compose d'ensembles de test et de validation, ainsi que d'un fichier data.yml avec des noms de classe pour chaque objet. Après avoir téléchargé et renommé le dossier, le présentateur utilise l'interface de ligne de commande pour la mise en œuvre locale de la formation, de la validation et du test du modèle. La formation dure environ trois heures et le présentateur montre les résultats de la formation, y compris le meilleur fichier de poids et les 90e derniers poids de travail. Le modèle a été formé sur sept classes différentes d'objets EPI.

  • 01:45:00 Dans cette section, les résultats de la formation du modèle YOLOv8 sont analysés, y compris la précision moyenne moyenne et la matrice de confusion pour chaque classe. Les pertes de formation et de validation sont également examinées, les valeurs de perte diminuant continuellement tout au long du processus de formation. Les prédictions du modèle sur les lots de validation sont également affichées, indiquant que le modèle fonctionne bien. Les meilleurs poids pour le modèle sont utilisés pour valider une commande personnalisée, les scores de précision moyens moyens restant élevés. Enfin, l'inférence est exécutée sur une image pour détecter l'étiquette à l'aide du modèle personnalisé. Dans l'ensemble, le modèle YOLOv8 semble bien fonctionner pour détecter diverses classes dans la détection d'objets en temps réel.

  • 01:50:00 Dans cette section, le créateur de la vidéo montre comment exécuter le modèle YOLOv8 sur un ensemble de données de test d'images et une vidéo de démonstration. Les résultats de l'ensemble de données de test sont enregistrés dans le fichier "prédiction" et le créateur affiche la sortie des cinq premières images à l'aide du package "ipython.display". Les résultats montrent que le modèle peut détecter correctement des objets tels que des planches de protection, des vestes, des gants, des masques anti-poussière, des servantes de protection et des casques. Le créateur télécharge ensuite une vidéo de démonstration et la passe à travers le modèle, affichant la sortie qui montre que le modèle est capable de détecter les vestes de protection et les servantes. Le créateur de la vidéo mentionne également l'avantage d'utiliser un GPU pour l'entraînement et la prédiction car cela prend moins de temps.

  • 01:55:00 Dans cette section, le présentateur teste le modèle YOLOv8 sur des vidéos de démonstration pour voir comment il fonctionne. Le modèle est capable de détecter les casques et vestes de protection, mais pas les gants. Le présentateur télécharge les vidéos de démonstration de sortie et montre comment le modèle fonctionne sur chacune d'elles. Le modèle est capable de détecter les servantes et vestes de protection dans toutes les vidéos de démonstration testées. Le présentateur télécharge ensuite le meilleur fichier de poids pour le modèle formé sur l'équipement de protection individuelle et explique comment l'intégrer à Flask pour une application Web de détection d'objets en temps réel.

  • 02:00:00 Dans cette section, le présentateur discute des modifications apportées au code dans l'application Web qui utilise le modèle Yellow V8 formé sur un ensemble de données d'équipement de protection individuelle (EPI). L'ensemble de données PPE comporte sept classes différentes et leurs noms sont répertoriés. Le fichier des meilleures pondérations a été renommé en ppe.pt à partir de l'ensemble de données Coco, qui se compose de 80 classes différentes. Le présentateur a ajouté une fonctionnalité permettant d'attribuer différentes couleurs à la zone de délimitation et au rectangle d'étiquette en fonction du nom de la classe. Le présentateur a fixé une limite pour le score de confiance et a mentionné que la boîte englobante et le rectangle n'apparaîtront que si le score est supérieur à 0,5. Les fichiers Flask app.py et HTML restent les mêmes. Enfin, le présentateur montre les résultats de la détection vidéo sur le jeu de données PPE et une webcam. L'application est capable de détecter avec succès les éléments EPI dans la vidéo.

  • 02:05:00 Dans cette section, le présentateur démontre les capacités de détection réussies du modèle YOLOv8 en temps réel à l'aide d'un flux de webcam en direct. Le modèle est capable de détecter avec précision une personne portant un casque de protection et un masque anti-poussière, tout en écartant l'absence de gants et de visières. Les résultats sont jugés satisfaisants et marquent la fin du cours.
 

Suivi d'objets en temps réel à l'aide de YOLOv8 et DeepSORT | Comptage des véhicules (véhicules entrant et sortant)



Suivi d'objets en temps réel à l'aide de YOLOv8 et DeepSORT | Comptage des véhicules (véhicules entrant et sortant)

La vidéo montre la mise en œuvre du suivi d'objets en temps réel à l'aide de YOLOv8 et DeepSORT pour compter le nombre de véhicules entrant et sortant d'une autoroute. Le présentateur fournit un guide étape par étape, en commençant par le clonage du référentiel GitHub, l'installation des packages requis, la définition du répertoire et l'examen du script de suivi. Le didacticiel couvre l'utilisation de files d'attente doubles, le prétraitement, la régression non maximale et la fonction Deep SORT pour générer des ID uniques et déterminer les noms de classe. Le présentateur explique également comment ajouter une fonction de comptage de véhicules en utilisant une ligne à l'écran, et chaque fois que la piste d'un véhicule croise cette ligne, le nombre augmente. L'interface utilisateur est définie à l'aide d'une fonction spécifique. Enfin, le présentateur montre comment la sortie actuelle du script peut détecter les intersections avec la ligne et compter les véhicules entrant et sortant de la zone.

  • 00:00:00 La section de la vidéo montre une démonstration de la mise en œuvre du suivi d'objets à l'aide d'un tri approfondi dans YOLO V8. Le tutoriel portera sur la création d'une application pour compter le nombre de véhicules entrant et sortant d'une autoroute. Le présentateur fournit un guide étape par étape à suivre lors de l'utilisation de PyCharm IDE et explique chaque étape en détail. La première étape consiste à cloner le référentiel GitHub et à installer les packages requis. La vidéo comprend également une section sur la configuration du répertoire et l'examen du script de suivi.

  • 00:05:00 Dans cette section de la vidéo, l'orateur explique comment configurer le fichier de points de suivi et télécharger et placer les fichiers DeepSORT de Google Drive dans le dossier YOLOv8. Les fichiers DeepSORT sont trop volumineux pour être téléchargés sur GitHub, ils doivent donc être téléchargés à partir du lien Google Drive fourni. La vidéo montre comment extraire les fichiers téléchargés et les placer dans le dossier approprié. L'orateur montre également comment télécharger un exemple de vidéo et exécuter le script. Le script peut prendre un certain temps à s'exécuter car ils le testent sur le processeur, mais l'orateur poursuit en expliquant le code plus en détail pendant l'exécution du script.

  • 00:10:00 Dans cette section, l'orateur explique l'utilisation d'une file d'attente à double extrémité (DQ) et pourquoi elle est préférée à une liste lors de l'exécution d'une opération d'insertion ou de pop en même temps. L'orateur utilise DQ pour ajouter des valeurs sous la forme de coordonnées centrales inférieures de la boîte englobante et explique comment les valeurs sont supprimées une fois que la voiture disparaît du cadre. La longueur maximale du DQ est définie comme 64, et une fois qu'il atteint cette valeur, il n'accepte plus de valeurs. Le haut-parleur définit également la palette de couleurs et l'interface utilisateur pour créer une bordure élégante autour des objets détectés.

  • 00:15:00 Dans cette section, la vidéo décompose le code de création d'une interface utilisateur (UI) avec un rectangle arrondi et une étiquette de texte, ainsi que la manière dont le programme ajoute les objets détectés à une file d'attente à double extrémité afin de générer les sentiers. Le code comprend également un prétraitement et une régression non maximale pour redimensionner les images et effectuer des détections. La fonction Deep SORT est appelée pour attribuer des identifiants uniques et déterminer les noms de classe, tandis que set.modern.names permet de récupérer des informations à partir de l'ensemble de données COCO et de générer des cadres de délimitation.

  • 00:20:00 Dans cette section, l'orateur explique son code pour la détection d'objets à l'aide de YOLOv8 et DeepSORT, en donnant un aperçu du script et de son fonctionnement. Ils démontrent la sortie actuelle du script et notent qu'ils utilisent un modèle nano, de sorte que la détection d'objet n'est pas encore parfaite. L'orateur mentionne également qu'ils créeront une série de conférences sur la vision par ordinateur pour Europa et encourage les téléspectateurs à s'abonner pour plus de contenu. Enfin, ils montrent comment leur script peut détecter quand un sentier croise une ligne, indiquant quand un objet est passé et permettant la mise en œuvre du comptage des véhicules pour entrer et sortir.

  • 00:25:00 Dans cette section, le présentateur explique comment la fonction de comptage de véhicules a été ajoutée au système de suivi d'objets en temps réel à l'aide de YOLOv8 et DeepSORT. Le système utilise une ligne sur l'écran et chaque fois que la piste d'un véhicule croise cette ligne, le décompte augmente. Le décompte peut augmenter selon qu'un véhicule entre ou sort de la zone, selon le sens de déplacement du véhicule. Le présentateur montre également comment l'interface utilisateur est définie via une fonction particulière.
 

Segmentation et suivi d'objets en temps réel à l'aide de YOLOv8 | Comptage des véhicules (entrée et sortie)



Segmentation et suivi d'objets en temps réel à l'aide de YOLOv8 | Comptage des véhicules (entrée et sortie)

Ce didacticiel vidéo se concentre sur la mise en œuvre de la segmentation et du suivi des objets en temps réel à l'aide de YOLOv8 et de l'algorithme de tri approfondi. Plus précisément, il montre comment compter et distinguer les différents sous-types de véhicules entrant et sortant d'une zone donnée. Le didacticiel couvre divers aspects, notamment l'estimation de la vitesse, la mesure de la direction, ainsi que la segmentation et le suivi précis de chaque véhicule avec son ID et ses traces. Le présentateur fournit également les étapes nécessaires pour l'implémenter sur divers IDE et propose le code final à ses partisans Patreon.

  • 00:00:00 Dans cette section de la vidéo, le présentateur explique comment mettre en œuvre la segmentation d'objets avec suivi à l'aide de YOLOv8 et de l'algorithme de tri approfondi. La vidéo montre la segmentation et le suivi des véhicules, y compris le comptage du nombre de véhicules qui entrent et sortent, ainsi que les types de véhicules. L'implémentation comprend également le calcul de la vitesse des véhicules, l'attribution d'un identifiant unique à chaque véhicule et la définition des sentiers. Le présentateur fournit les étapes nécessaires pour l'implémenter sur divers IDE, notamment Anaconda Navigator, PyCharm, Spider et Visual Studio. Les dépendances requises, telles que les bibliothèques, doivent être installées pour éviter toute erreur lors de l'exécution du script predict.5.

  • 00:05:00 Dans cette section, le didacticiel vidéo se concentre sur la mise en œuvre de la segmentation et du suivi à l'aide de YOLOv8 et du tri approfondi. Les fichiers de tri en profondeur sont téléchargés à partir de Google Drive et un exemple de vidéo est utilisé pour les tests. Le script est modifié pour implémenter le comptage des véhicules pour entrer et sortir, avec un dictionnaire utilisé pour stocker le nombre de véhicules par sous-type. Le compteur d'objets un est utilisé pour stocker le nombre de véhicules sortant par sous-type, tandis que le dictionnaire de compteur de contrôle est utilisé pour stocker le nombre de véhicules entrants. Le script modifié suit et compte les véhicules en fonction de leur sous-type et de leur entrée ou de leur sortie du cadre.

  • 00:10:00 Dans cette section, la vidéo explique comment créer un système de comptage de véhicules à l'aide de YOLOv8, avec un compteur d'objets capable de distinguer les sous-types de véhicules tels que les voitures, les gros camions et les motos entrant et sortant d'une zone donnée. La vidéo explique l'utilisation d'une fonction d'estimation de vitesse, et comment créer une ligne qui, lorsqu'elle est dépassée par un véhicule, incrémente le compteur. De plus, la vidéo définit le PPM constant, ou paramètre d'image, qui aide à mesurer le nombre de pixels dans une image.

  • 00:15:00 Dans cette section, l'orateur aborde le concept de mesure de distance dynamique basée sur la distance entre un objet et la caméra. Ils expliquent que cela peut être réalisé en utilisant une formule qui implique que la distance en mètres soit égale au pixel de distance divisé par PPM (pixels par mètre) multiplié par une constante de 3,6 divisé par la fréquence d'images par seconde. Le locuteur procède ensuite à l'écriture d'une fonction pour calculer l'angle et renvoyer la vitesse en fonction de la distance et du temps. Ils créent également deux autres fonctions - set_d et CCW - et écrivent une fonction get_direction pour calculer la direction d'un objet en fonction de l'axe y.

  • 00:20:00 Dans cette section de la vidéo, le présentateur passe en revue son code pour la segmentation et le suivi d'objets en temps réel à l'aide de YOLOv8. Ils apportent des modifications au script, y compris l'ajout d'une structure de direction et le calcul du code restant. Le présentateur explique également comment calculer la vitesse de l'objet et l'ajouter à la liste d'ID. Ils copient et collent ensuite un code d'intersection et continuent de faire des ajustements pour corriger les erreurs dans le code.

  • 00:25:00 Dans cette section de la vidéo, le présentateur ajoute un code compteur pour compter le nombre de véhicules entrant et sortant. Le code du compteur affiche le nombre total de véhicules et le sous-nombre, qui comprend le nombre de voitures, de camions et de motos entrant. Le présentateur suggère également d'ajouter un affichage du nombre de véhicules sortants. Une erreur se produit dans la fonction de dessin des cases, et le présentateur la corrige en déclarant une variable globale pour le compte à rebours et le compte à rebours. Le script s'exécute avec succès et la vidéo de démonstration de sortie montre l'estimation de la vitesse pour chaque véhicule et le nombre total de véhicules avec des sous-comptes pour chaque type de véhicule entré.

  • 00:30:00 Dans cette section, l'orateur discute des résultats de leur segmentation et de leur suivi d'objets en temps réel à l'aide de YOLOv8 pour le comptage de véhicules. Ils ont obtenu des résultats précis et sont même capables d'estimer la vitesse de chaque véhicule, ainsi que l'ID de suivi et les pistes. De plus, la détection et la segmentation de chaque véhicule ont été effectuées avec précision, et le nombre total de véhicules est également mentionné. Ils ont mis ce code à la disposition exclusive de leurs supporters Patreon qui auront accès à tous les codes et projets qu'ils partagent. Enfin, ils invitent les téléspectateurs à tester les vidéos de démonstration, à implémenter le code sur leurs sites ou à rejoindre leur abonnement Patreon.
 

Suivi d'objets avec YOLOv8 : suivi des véhicules, comptage (entrée et sortie) et estimation de la vitesse



Suivi d'objets avec YOLOv8 : suivi des véhicules, comptage (entrée et sortie) et estimation de la vitesse

Le didacticiel vidéo décrit comment mettre en œuvre le suivi d'objets, le comptage de véhicules et l'estimation de la vitesse à l'aide de YOLOv8 et DeepSORT. Le présentateur partage un lien vers le référentiel GitHub contenant le code et parcourt le processus de clonage du référentiel, de téléchargement des fichiers DeepSORT, d'importation des bibliothèques pertinentes et de définition d'une liste DQ de données pour suivre les objets. Ils expliquent également comment déterminer la direction du véhicule et augmenter le nombre en conséquence. De plus, le présentateur montre comment estimer la vitesse des véhicules en mettant en œuvre la formule de distance euclidienne basée sur les coordonnées X et Y des objets suivis, et configure un espace pour l'affichage du comptage. En fin de compte, la sortie du script affiche le nombre et la vitesse des objets, indiquant ainsi que la mise en œuvre a réussi.

  • 00:00:00 Dans cette section du didacticiel, le présentateur explique comment mettre en œuvre le suivi de la détection d'objets et l'estimation de la vitesse à l'aide de YOLOv8. Pour commencer, le présentateur fournit un lien vers le suivi d'objets YOLOv8 avec le référentiel Deep Sort GitHub, qui contient un fichier Google Colab ainsi que des instructions étape par étape pour exécuter le code sous Windows. Le présentateur passe ensuite par les étapes nécessaires pour cloner le référentiel, définir le répertoire actuel et installer toutes les bibliothèques nécessaires. Après cela, le présentateur accède au dossier de détection et télécharge les fichiers Deep Sort à partir du lien Google Drive fourni.

  • 00:05:00 Dans cette section, l'orateur explique les étapes pour télécharger et implémenter le suivi d'objet avec YOLOv8 en utilisant DeepSORT. Ils guident les téléspectateurs pour télécharger le dossier DeepSORT en décompressant le dossier et en le plaçant dans le dossier principal du projet. Ils expliquent également les importations de bibliothèques utilisées dans le fichier predict.py et décrivent le concept de file d'attente à double extrémité (DQ) utilisé pour stocker des ID uniques pour les objets entrant et sortant du cadre. L'orateur mentionne également le téléchargement de l'exemple de vidéo à partir de Google Drive et l'attente de quelques secondes pour la sortie, car ils utilisent le CPU plutôt que le GPU pour le traitement.

  • 00:10:00 Dans cette section, le conférencier explique diverses fonctions utilisées dans le Deep Sort Tracker, un algorithme de suivi pour le suivi d'objets. Ils incluent la fonction d'ajout de points, utilisée pour ajouter des valeurs à l'extrémité droite d'un deque, un type de données de conteneur utilisé pour stocker des objets et la fonction d'ajout de points à gauche utilisée pour insérer des valeurs à l'extrémité gauche d'un deque. L'orateur aborde également la fonction de calcul des étiquettes colorées, qui attribue différentes couleurs aux objets en fonction de leurs types. De plus, les fonctions de dessin de bordure de tiret et de dessin de boîtes de tiret sont expliquées en détail, où elles créent une interface utilisateur avec un rectangle arrondi qui affiche l'ID et le nom uniques de l'objet et une ligne de trace créée à l'aide de CB2.9.

  • 00:15:00 Dans cette section, l'orateur explique comment créer une Trail Line et mettre en œuvre le concept de données DQ pour suivre les objets. Ils initialisent une liste DQ et y ajoutent les coordonnées inférieures de chaque objet détecté. Lorsqu'un objet quitte le cadre, ses points sont supprimés de la liste DQ des données. Ils créent également un prédicteur de détection de classe, utilisent l'algorithme Deep Sort pour attribuer des ID uniques à chaque objet et obtenir leurs noms. Ils appellent une fonction draw-boxes et exécutent les prédictions. De plus, ils implémentent le comptage de véhicules en téléchargeant et en collant un fichier et en définissant la direction comme nord, sud, est ou ouest. Si un objet entre ou sort dans une direction spécifique, il incrémente le décompte.

  • 00:20:00 Dans cette section, l'orateur explique comment ils ont implémenté le comptage d'objets dans leur script de suivi d'objets YOLOv8. Ils ont défini une direction pour les objets entrant ou sortant en fonction de leur mouvement à travers des lignes désignées. Ils ont également montré le nombre d'objets entrant ou sortant et défini l'espace où le nombre doit être affiché. L'orateur a ensuite ajouté une estimation de la vitesse en mettant en œuvre la formule de distance euclidienne, en utilisant les coordonnées X et Y des objets suivis pour calculer leurs vitesses. Ils ont utilisé une valeur de pixel par mètre pour effectuer le calcul, qui peut être rendu dynamique en fonction de la position de la caméra. La sortie du script indiquait le nombre et la vitesse des objets, indiquant que le script fonctionnait correctement.

  • 00:25:00 Dans cette section, l'orateur explique la formule utilisée pour calculer la vitesse des véhicules en mètres par heure, qui consiste à diviser la distance en pixels par la valeur pixel par mètre (PPM) et à multiplier le résultat par une constante de temps . Lorsqu'un véhicule franchit une ligne définie par la zone de détection définie par l'utilisateur, le script incrémente le nombre de véhicules et discerne si le véhicule entre ou sort de la zone, en fonction de la direction dans laquelle il se déplace. En fin de compte, les estimations de vitesse et de nombre de véhicules sont ajoutées à la liste de sortie, et l'utilisateur peut mettre en œuvre ce projet en suivant les étapes du didacticiel.
 

Reconnaissance automatique des plaques d'immatriculation à l'aide de YOLOV8 et EasyOCR (images et vidéos)



Reconnaissance automatique des plaques d'immatriculation à l'aide de YOLOV8 et EasyOCR (images et vidéos)

Dans cette vidéo YouTube, le présentateur explique comment mettre en œuvre la reconnaissance automatique des plaques d'immatriculation à l'aide de YOLOV8 et EasyOCR. Ils guident les téléspectateurs tout au long du processus de mise en œuvre à l'aide d'un bloc-notes Google Colab et d'un référentiel GitHub, fournissant des instructions étape par étape et expliquant comment installer les dépendances et télécharger l'ensemble de données nécessaire. Le présentateur démontre le taux de réussite du modèle et le processus de validation, et explique également comment utiliser EasyOCR pour lire les numéros de plaque d'immatriculation. Ils parcourent les dernières étapes de l'exécution du script et rencontrent des erreurs qu'ils corrigent, ce qui donne des résultats impressionnants. Bien que le script de reconnaissance de la plaque d'immatriculation ne soit fourni que sur le référentiel GitHub du présentateur pour les supporters de Patreon, les téléspectateurs peuvent en savoir plus sur les modifications apportées au fichier predict.py pour des résultats similaires.

  • 00:00:00 Dans cette section de la vidéo, le présentateur montre comment mettre en œuvre la détection et la reconnaissance des plaques d'immatriculation à l'aide de YOLOV8 et EasyOCR. Le présentateur utilise un bloc-notes Google Colab et un référentiel GitHub pour guider les spectateurs tout au long du processus de mise en œuvre. Le bloc-notes contient des instructions étape par étape pour exécuter le code, et le référentiel GitHub donne accès à plusieurs projets exclusifs pour les supporters de Patreon qui contribuent cinq dollars par mois. Le présentateur explique également comment installer les dépendances nécessaires et télécharger l'ensemble de données requis à partir de Roboflow pour former un modèle personnalisé pour la détection des plaques d'immatriculation. Enfin, le présentateur montre la matrice de confusion qui révèle à quel point le modèle a géré différentes classes, avec un taux de réussite de 84 % pour la détection des plaques d'immatriculation.

  • 00:05:00 Dans cette section, l'orateur discute des résultats du modèle sur l'ensemble de validation, qui montre une diminution de la perte et une augmentation de la précision moyenne moyenne et du score de rappel à mesure que le nombre d'époques augmente. L'orateur montre également comment télécharger le modèle enregistré à partir de Google Drive et le valider sur une vidéo personnalisée, atteignant une précision moyenne moyenne de 0,926 avec une reconnaissance de dette de 50. Cependant, l'accent de cette section est sur la mise en œuvre d'EasyOCR pour lire le les numéros de plaque d'immatriculation des plaques détectées et les ajustements apportés au fichier predict.py pour inclure le lecteur OCR et les coordonnées de l'image.

  • 00:10:00 Dans cette section, nous voyons une explication sur la façon de mettre en œuvre la reconnaissance automatique des plaques d'immatriculation à l'aide de YOLOv8 et EasyOCR. La vidéo explique le processus de recadrage et de conversion de l'image de la plaque d'immatriculation en niveaux de gris pour faciliter la lecture du texte de la plaque. Ils montrent comment utiliser EasyOCR pour lire le texte de l'image en niveaux de gris de la plaque d'immatriculation en écrivant "reader. read_text(gray)". Ils testent enfin le script pour voir si des erreurs se produisent.

  • 00:15:00 Dans cette section, l'orateur parcourt les dernières étapes de l'exécution du script de reconnaissance de plaque d'immatriculation à l'aide des modèles YOLOv8 et EasyOCR. Ils rencontrent quelques erreurs dans le code mais parviennent à les corriger et à exécuter le script avec succès. La vidéo de sortie montre des résultats impressionnants, le modèle détectant les plaques d'immatriculation et lisant le texte à l'aide d'EasyOCR. Le script de reconnaissance de la plaque d'immatriculation sera fourni sur le référentiel GitHub de l'orateur pour les supporters de Patreon, mais les téléspectateurs peuvent toujours en savoir plus sur les modifications apportées au fichier predict.pi dans la vidéo pour obtenir des résultats similaires.
 

Détection et suivi d'objets en temps réel à l'aide de YOLOv8 sur un jeu de données personnalisé : tutoriel complet



Détection et suivi d'objets en temps réel à l'aide de YOLOv8 sur un jeu de données personnalisé : tutoriel complet

Dans ce didacticiel vidéo, le présentateur présente un ensemble de données personnalisé contenant des images de voitures, de camions, de motos, de camionnettes, d'avions et de camping-cars, qui est utilisé pour démontrer la mise en œuvre de YOLOv8 avec détection et suivi. Ils expliquent l'importance d'un ensemble de données équilibré et fournissent des instructions étape par étape pour naviguer dans le référentiel GitHub, configurer l'environnement requis et mettre en œuvre le suivi des objets à l'aide de l'algorithme de tri approfondi. Le présentateur discute également de la matrice de confusion et de l'importance des pertes de formation et de validation tout en testant la précision du modèle en exécutant l'inférence avec une vidéo de démonstration téléchargée depuis Google Drive. Ils concluent en partageant le fichier du cahier de collaboration pour les personnes intéressées.

  • 00:00:00 Dans cette section du didacticiel vidéo, le présentateur présente un ensemble de données multi-classes accessible au public qui contient environ 4680 images de voitures, camions, motos, camionnettes, avions et camping-cars. L'ensemble de données n'est pas équilibré car il est surreprésenté par les annotations de voiture avec environ 8 389 annotations alors que les autres annotations sont très faibles. Cependant, l'ensemble de données est utilisé pour ce didacticiel, mais lors de la mise en œuvre d'un projet ou de l'utilisation d'un ensemble de données accessible au public, il est important de s'assurer que l'ensemble de données est équilibré. La vidéo présente également un référentiel GitHub qui est utilisé pour le projet et fournit les instructions étape par étape pour implémenter YOLO V8 avec détection et suivi sur n'importe quel ensemble de données personnalisé. Les instructions incluent le clonage du référentiel, l'installation de dépendances, la mise en œuvre du suivi d'objets à l'aide de Deep sor,t et le téléchargement d'un exemple de vidéo à tester.

  • 00:05:00 Dans cette section de la vidéo, le présentateur explique les bibliothèques utilisées pour afficher les images et les informations de formation, et montre comment configurer l'environnement requis pour YOLOv8 à l'aide de Google Colab. Le présentateur clone le référentiel GitHub pour YOLOv8, installe les bibliothèques nécessaires et accède au dossier de détection. Le présentateur montre ensuite comment télécharger l'ensemble de données personnalisé requis à partir de Roboflow et le décompresser pour obtenir les dossiers d'entraînement, de test et de validation.

  • 00:10:00 Dans cette section de la vidéo, le présentateur discute de la mise en œuvre du suivi d'objet à l'aide de l'algorithme de tri approfondi. Ils téléchargent les fichiers de tri approfondi et les décompressent avant d'afficher la matrice de confusion, qui est un graphique montrant dans quelle mesure un modèle gère différentes classes. Ils expliquent que la matrice de confusion indique que le modèle détecte correctement les camping-cars 67% du temps, mais les classe parfois comme de simples voitures. Ils discutent également de l'importance des pertes de formation et de validation, et de la manière dont ils vérifient la prédiction du modèle sur les lots de validation. Enfin, ils téléchargent les poids du modèle personnalisé depuis Google Drive et le valident, montrant que la précision moyenne moyenne est élevée lorsque l'IOU est à 50 %.

  • 00:15:00 Dans cette section, le présentateur teste la précision du modèle en exécutant une inférence avec le modèle construit à l'aide d'une vidéo de démonstration téléchargée depuis son Google Drive. La vidéo montre des voitures et des camions sur une autoroute, et les résultats montrent que le modèle fonctionne bien avec un identifiant unique attribué à chaque objet, et le suivi est également possible. Le fichier de collaboration utilisé dans ce didacticiel est disponible sur leur dépôt GitHub. Une autre vidéo est également testée, et les résultats sont tout aussi bons, certains cas nécessitant des améliorations. Le présentateur partage le fait qu'il a implémenté le suivi de la détection d'objets à l'aide de YOLOv8 sur un ensemble de données personnalisé et partage le fichier de bloc-notes de collaboration pour les personnes intéressées.
 

Segmentation et suivi d'objets en temps réel à l'aide de YOLOv8 sur un jeu de données personnalisé : tutoriel complet



Segmentation et suivi d'objets en temps réel à l'aide de YOLOv8 sur un jeu de données personnalisé : tutoriel complet

Ce didacticiel vidéo est un guide complet sur l'utilisation de YOLOv8 pour la segmentation et le suivi d'objets en temps réel sur des ensembles de données personnalisés. Le didacticiel passe par l'ensemble du processus, y compris l'importation d'ensembles de données, la formation de modèles personnalisés à l'aide des algorithmes YOLOv8 et Deep Sort, et le test des modèles sur des vidéos de démonstration. Le conférencier fournit le code et les bibliothèques nécessaires à la mise en œuvre et présente les résultats des prédictions du modèle. Ils expliquent également la matrice de confusion et fournissent des liens pour accéder aux vidéos de sortie et aux fichiers polaires sur GitHub. Dans l'ensemble, ce didacticiel est une excellente ressource pour tous ceux qui souhaitent en savoir plus sur la segmentation et le suivi d'objets à l'aide de YOLOv8.

  • 00:00:00 Dans cette section, le didacticiel vidéo explique comment utiliser YOLOv8 pour la segmentation et le suivi sur des ensembles de données personnalisés. Le didacticiel décrit la mise en œuvre étape par étape et utilise un référentiel pour faciliter la mise en œuvre. Le présentateur explique comment importer les bibliothèques et dépendances requises, ainsi que comment accéder et télécharger un ensemble de données de trafic de drones à partir de Roboflow. Le code requis pour importer l'ensemble de données est également fourni, ainsi que des instructions sur la façon d'exécuter le code avec succès. Il est souligné qu'il est important de regarder la vidéo complète pour bien comprendre les concepts de base.

  • 00:05:00 Dans cette section, le conférencier explique comment entraîner des modèles personnalisés pour le suivi d'objets à l'aide des algorithmes YOLOv8 et Deep Sort. Ils mentionnent la procédure pour télécharger un ensemble de données de Roboflow dans Google Colab Notebook, télécharger des fichiers Deep Sort et former les modèles personnalisés pour détecter différentes classes d'objets, y compris les vélos, les bus, les voitures et les camions. L'orateur partage les résultats de la prédiction du modèle sur le lot de validation, enregistre les pondérations du modèle dans Google Drive et télécharge une vidéo de démonstration pour tester les performances du modèle. Ils expliquent la matrice de confusion et comment elle révèle la précision du modèle pour différentes classes d'objets. Dans l'ensemble, la vidéo fournit un didacticiel complet sur la segmentation et le suivi d'objets en temps réel à l'aide de YOLOv8 sur des ensembles de données personnalisés.

  • 00:10:00 Dans cette section de la vidéo, le présentateur teste le modèle sur deux vidéos de démonstration et présente les résultats. Le modèle est capable de détecter et de suivre avec précision des objets, en attribuant à chaque objet un identifiant unique et en créant des pistes pour suivre leur mouvement. Le présentateur fournit un lien pour accéder à la vidéo de sortie et au fichier polaire sur GitHub.

  • 00:15:00 Dans cette section, l'orateur présente les résultats de son projet de segmentation et de suivi d'objets à l'aide de YOLOv8 sur un ensemble de données personnalisé. L'orateur montre leurs vidéos de sortie et mentionne que les détections sont très bonnes, et les téléspectateurs peuvent télécharger les fichiers pour voir les résultats eux-mêmes. L'orateur rappelle également aux téléspectateurs de s'abonner à la chaîne pour de futures vidéos sur de nouveaux sujets.
 

Détection des panneaux de signalisation et des feux de circulation et reconnaissance des couleurs à l'aide de YOLOv8



Détection des panneaux de signalisation et des feux de circulation et reconnaissance des couleurs à l'aide de YOLOv8

Ce didacticiel YouTube présente l'utilisation de YOLOv8 pour la détection des panneaux de signalisation et la reconnaissance des couleurs. Le présentateur présente le jeu de données, qui contient 17 classes différentes de panneaux routiers avec une distribution équilibrée des images. Le modèle YOLOv8 est formé et affiné sur 100 époques, ce qui donne de bons scores moyens de précision moyenne pour iou50 et ioub50. Le présentateur montre comment interpréter la matrice de confusion et valider le modèle sur l'ensemble de données de validation. Le modèle est ensuite testé sur deux vidéos de démonstration, toutes deux montrant des résultats de détection précis. Dans l'ensemble, YOLOv8 fonctionne bien pour détecter les panneaux de signalisation et les feux de circulation.

  • 00:00:00 Dans cette section du didacticiel vidéo, le présentateur présente l'ensemble de données de signalisation routière qui sera utilisé pour entraîner le modèle YOLOv8 sur la détection des panneaux de signalisation. L'ensemble de données contient 17 classes différentes de panneaux de signalisation, avec un total de 2093 images à des fins de formation, de validation et de test. L'ensemble de données est équilibré, ce qui signifie que toutes les classes ont une distribution d'images presque égale, à l'exception des feux verts qui ont un nombre légèrement supérieur d'images. Le présentateur montre également comment importer l'ensemble de données de RoboFlow dans le bloc-notes Google Colab et installer les bibliothèques nécessaires à la mise en œuvre de YOLOv8, y compris les bibliothèques ultralytics et glob pour gérer les chemins de fichiers, et les bibliothèques d'images et d'affichage pour afficher les images d'entrée et de sortie. Le présentateur propose également des options pour installer YOLOv8 soit en clonant le référentiel GitHub, soit en l'installant à partir du package ultralytics via pip.

  • 00:05:00 iou50 sont de bons indicateurs de la performance du modèle YOLOv8 formé sur la tâche de détection des panneaux routiers et de reconnaissance des couleurs. Le modèle a été entraîné sur un grand ensemble de données et affiné sur 100 époques, ce qui a donné une précision moyenne moyenne avec iou50 de 95,8 % et une précision moyenne moyenne avec ioub 50 de 81,3 %. Les meilleurs poids, avec la précision moyenne la plus élevée, ont été enregistrés sous "best.pt". Dans l'ensemble, les résultats sont assez bons pour détecter 17 classes différentes de panneaux de signalisation et de feux de circulation dans l'ensemble de données d'image.

  • 00:10:00 Dans cette section de la vidéo, le présentateur explique les différents fichiers enregistrés dans le dossier de formation après avoir exécuté le modèle YOLOv8 pour la détection des panneaux de signalisation et des feux de circulation et la reconnaissance des couleurs. Ces fichiers incluent la matrice de confusion, la courbe F1, la courbe de précision, la courbe de rappel et les performances du modèle pour chaque époque. Ils montrent également comment interpréter la matrice de confusion et comment valider le modèle sur l'ensemble de données de validation en utilisant les meilleurs poids du modèle. Enfin, ils suggèrent que l'entraînement du modèle sur une durée plus longue pourrait encore améliorer la précision moyenne moyenne des résultats.

  • 00:15:00 Dans cette section de la vidéo, le présentateur valide le modèle sur les images du jeu de données de validation et obtient un impressionnant score de précision moyenne principale. Le modèle est ensuite testé sur deux vidéos de démonstration, où il détecte avec succès des signes tels que "ne tournez pas à gauche", "stationnement", "feu rouge", etc. Les vidéos de démonstration sont téléchargées à partir du site Pixel, puis téléchargées sur Google Drive. Les vidéos de sortie sont affichées et présentées pour avoir des résultats de détection précis. Dans l'ensemble, le modèle fonctionne bien dans la détection des panneaux de signalisation et des feux de circulation à l'aide de YOLOv8.
 

Détection et segmentation des nids-de-poule à l'aide de YOLOv8 (images et vidéos) | Ensemble de données personnalisé | Guide complet



Détection et segmentation des nids-de-poule à l'aide de YOLOv8 (images et vidéos) | Ensemble de données personnalisé | Guide complet

Cette vidéo montre comment créer un jeu de données personnalisé pour la détection et la segmentation des nids-de-poule à l'aide de YOLOv8. Le présentateur montre les étapes de clonage et d'annotation des données d'image et recommande d'utiliser Google Collab pour former le modèle. Les dépendances nécessaires pour YOLOv8 sont également abordées, ainsi que la configuration de l'emplacement de l'ensemble de données et la formation du modèle. Le modèle a atteint une précision moyenne moyenne de 0,532 pour la détection et de 0,531 pour la segmentation, et a bien performé dans la détection des nids-de-poule dans les vidéos. Le présentateur conclut la vidéo après avoir validé le modèle personnalisé et obtenu de bons résultats.

  • 00:00:00 Dans cette section de la vidéo, l'auteur montre comment créer un jeu de données personnalisé pour la détection et la segmentation des nids-de-poule à l'aide de YOLOv8. L'auteur utilise Roboflow pour créer son propre espace de travail et projet, et explique l'importance de choisir un plan public pour l'espace de travail afin de pouvoir exporter l'ensemble de données vers Google Colab. L'auteur montre également comment importer des vidéos ou des images, ainsi que comment cloner des ensembles de données accessibles au public pour compléter les leurs. Enfin, l'auteur montre comment cloner des images et des annotations, aboutissant finalement à un ensemble de données de 50 images pour la détection et la segmentation des nids-de-poule.

  • 00:05:00 Dans cette section de la vidéo, le présentateur montre comment cloner et annoter des données d'image pour la détection et la segmentation des nids-de-poule à l'aide de YOLOv8. Ils commencent par cloner les 46 images restantes de l'ensemble de données d'origine, portant le total à 96 images. Le processus d'annotation consiste à connecter des points en forme de polygone pour indiquer l'emplacement du nid-de-poule sur chaque image. Le présentateur montre ensuite comment enregistrer et attribuer les annotations à chaque image. Le processus prend du temps, mais il peut être fait facilement en suivant les étapes décrites dans la vidéo.

  • 00:10:00 Dans cette section de la vidéo, le présentateur discute du processus d'annotation d'un ensemble de données pour la détection et la segmentation des nids-de-poule. Il montre comment générer un ensemble de données à l'aide de l'outil d'annotation, puis procède à la formation du modèle à l'aide de l'algorithme YOLOv8 sur Google Collab. Le présentateur mentionne également que l'on peut entraîner le modèle sur RoboFlow en un seul clic et sans aucun codage, mais il recommande d'utiliser Google Collab pour apprendre de nouvelles choses. La vidéo montre comment importer les bibliothèques requises et cloner un référentiel GitHub avant de définir le répertoire de travail et d'installer les dépendances.

  • 00:15:00 Dans cette section de la vidéo, le présentateur fournit des instructions pour installer les dépendances nécessaires pour YOLOv8 et la segmentation, soulignant qu'il est important de le faire avant la formation pour éviter les problèmes de bibliothèque plus tard. Le présentateur explique également comment importer l'ensemble de données de RoboFlow dans le dossier Google et le télécharger, ainsi que la configuration de l'emplacement de l'ensemble de données et la formation du modèle. Le présentateur reconnaît et corrige également une erreur dans le fichier predict.py qui a été ajusté pour le suivi.

  • 00:20:00 capable de détecter les nids-de-poule avec une précision moyenne moyenne de 0,532 à une IOU de 50 et de 0,218 lorsque l'IOU varie de 0,50 à 0,95. Le modèle a été testé sur un échantillon vidéo et a bien performé dans la détection des nids-de-poule. La matrice de confusion affichée montre la répartition des données entre les différentes classes. Dans l'ensemble, le modèle fonctionne bien pour détecter les nids-de-poule.

  • 00:25:00 Dans cette section de la vidéo, le présentateur tente de valider le modèle personnalisé pour la détection et la segmentation des nids-de-poule à l'aide de YOLOv8. Ils ont rencontré un problème où le modèle ne parvenait pas à détecter les nids-de-poule 50 % du temps, ce qui entraînait un écran vide. Le présentateur a ensuite ajouté le meilleur chemin de pondération DOT et a pu corriger le problème. Ils ont ensuite procédé à l'affichage de la prédiction sur le lot de validation et ont obtenu une précision moyenne moyenne de 0,538 pour la détection et de 0,531 pour la segmentation. Le modèle a été testé sur plusieurs vidéos de démonstration et a bien fonctionné, et le présentateur conclut la vidéo.
1...313233343536373839404142434445...75
Nouveau commentaire
Raison: