Apprentissage Automatique et Réseaux Neuronaux - page 41

 

Détection d'objets Tensorflow en 5 heures avec Python | Cours complet avec 3 projets

Obtenez le code du cours Python de détection d'objets Tensorflow : https://github.com/nicknochnack/TFODCourse

Application Tensorflow Object Detection React : https://github.com/nicknochnack/TFODApp

Détection d'objets Tensorflow pour Raspberry Pi : https://github.com/nicknochnack/TFODRPi



Détection d'objets Tensorflow en 5 heures avec Python | Cours complet avec 3 projets


Partie 1

  • 00:00:00 Dans cette section, l'instructeur présente le cours de détection d'objets qui est destiné à amener les débutants complets en détection d'objets à un niveau compétent en tant que praticiens. Le cours est complet et couvre l'installation et la configuration de l'API de détection d'objets TensorFlow, la collecte et l'étiquetage des images, la formation du modèle, l'exportation du modèle de détection vers différents formats et le test des modèles sur divers cas d'utilisation. Le cours est entièrement réalisé à l'aide d'outils open source, principalement la détection d'objets Python et TensorFlow, ce qui facilite la réutilisation du code pour détecter divers objets. L'instructeur explique également les avantages de l'utilisation de l'API de détection d'objets TensorFlow, qui accélère le processus de création de modèles de détection d'objets grâce aux diverses fonctionnalités supplémentaires qu'elle offre.

  • 00:05:00 Dans cette section, l'instructeur explique la différence entre la programmation traditionnelle et l'apprentissage automatique, où au lieu de définir des règles explicites pour détecter des objets, l'apprentissage automatique utilise des données et des réponses pour entraîner un modèle de détection d'objets à apprendre les règles. Le modèle peut détecter des objets dans des images statiques et des flux vidéo en temps réel, et peut être exporté et converti en différents formats comme tensorflow.js et tf lite en utilisant le gel et la conversion. Le réglage des performances est crucial pour améliorer la précision du modèle, et l'instructeur aborde ce sujet à l'étape six. Enfin, l'instructeur présente trois projets, notamment l'utilisation d'un microscope USB pour détecter des défauts dans de petites pièces, la détection d'objets dans un jeu vidéo et le comptage du nombre d'objets passant par une webcam.

  • 00: 10: 00 Dans cette section, l'instructeur présente les trois projets qui seront couverts dans le didacticiel, qui impliquent la formation d'un modèle de détection d'objets pour identifier les défauts des cartes de circuits imprimés, la détection des gestes de la main et l'intégration du modèle dans une application Web, et effectuer une détection d'objets en temps réel à l'aide d'un Raspberry Pi. L'instructeur fournit trois ensembles de code sur Github pour chacun des projets, qui seront utilisés pour construire les modèles étape par étape. La première étape consiste à cloner le code et à créer un environnement virtuel, qui est expliqué comme étant comme une pièce séparée dans une maison. Cette section comprend également des conseils utiles pour suivre le didacticiel, tels que passer en revue chaque étape avant de continuer, prendre des notes et demander de l'aide si nécessaire via le serveur Discord fourni.

  • 00:15:00 Dans cette section de la vidéo, l'instructeur explique l'importance d'utiliser un environnement virtuel tout en travaillant avec les modèles de détection d'objets TensorFlow. Il le décrit comme la création d'une nouvelle pièce dans une maison où toutes les dépendances de détection d'objets sont installées pour s'assurer qu'elles n'entrent pas en conflit avec les bibliothèques précédemment installées. L'instructeur parle ensuite des dépendances requises pour travailler avec TensorFlow, y compris Visual C++ Build Tools, et CUDA et CUDNN pour l'accélération basée sur GPU. Il explique que ces bibliothèques sont essentielles pour une formation plus rapide des modèles de détection d'objets et montre comment les télécharger et les installer. Dans l'ensemble, cette section fournit une base essentielle nécessaire à la configuration d'un environnement de développement pour la création de modèles de détection d'objets TensorFlow.

  • 00:20:00 Dans cette section du didacticiel vidéo, l'instructeur décrit les exigences nécessaires à l'installation de TensorFlow Object Detection, y compris les versions spécifiques de Python, du compilateur GCC, de Bazel, de CUDA et de cuDNN qui sont nécessaires. L'instructeur souligne qu'il est essentiel de faire correspondre les versions de TensorFlow, CUDA et cuDNN pour utiliser les GPU pendant la formation. Ils fournissent des liens vers des guides d'installation pour Windows et Linux/macOS et conseillent aux utilisateurs de vérifier leur version de TensorFlow et d'obtenir les versions CUDA et cuDNN appropriées. De plus, l'instructeur mentionne qu'il a créé un guide d'erreur pour les problèmes courants qui se produisent lors de l'installation ou lors de l'exécution du bloc-notes de détection d'objets. Le guide comprend des solutions à différentes erreurs et peut être trouvé dans le lien de référentiel GitHub fourni.

  • 00:25:00 Dans cette section, l'instructeur montre comment configurer un environnement virtuel pour la détection d'objets TensorFlow à l'aide de Python. Il indique les étapes à suivre pour créer l'environnement, ce qui implique de cloner un référentiel avec le code et les dépendances nécessaires, de créer un environnement virtuel à l'aide du package venv de Python et d'activer l'environnement. La création d'un environnement virtuel est similaire à la création d'une nouvelle pièce dans une maison, où l'on peut isoler des bibliothèques et des dépendances pour travailler sur des projets de détection d'objets TensorFlow dans un environnement isolé.

  • 00:30:00 Dans cette section, le créateur de la vidéo explique le processus de création d'un environnement virtuel pour la détection d'objets TensorFlow (TFOD) afin de séparer la formation, l'application et le code Raspberry Pi. Le créateur de la vidéo suit les étapes pour activer l'environnement virtuel, y compris l'exécution d'une commande sur une machine Windows pour activer l'environnement. Il y a une démonstration de la mise à jour du programme d'installation de pip, puis de l'installation de TensorFlow. L'avantage de ces mises à jour est la possibilité de voir les installations en temps réel dans le dossier des packages du site. Il est à noter que l'installation de TensorFlow nécessite parfois plusieurs tentatives et que le créateur de la vidéo dispose d'un script de vérification pour s'assurer que tout est correctement installé.

  • 00:35:00 Dans cette section, l'orateur explique comment installer les packages nécessaires et configurer un environnement virtuel avec Jupyter Notebook à l'aide d'iPy Kernel. Ils fournissent également des instructions pour l'installation des ordinateurs portables Anaconda Python et Jupyter pour les débutants. Ensuite, ils expliquent comment installer le noyau iPy et l'associer au bloc-notes Jupyter pour permettre une charge de travail de science des données plus efficace. Enfin, l'orateur montre comment valider l'environnement virtuel et commencer à collecter et à étiqueter des images dans le cadre de la prochaine étape vers la construction d'un modèle de détection d'objets TensorFlow.

  • 00:40:00 Dans cette section, l'instructeur insiste sur l'importance de collecter et d'étiqueter de bonnes images lors de la formation de modèles de détection d'objets. Pour le démontrer, il utilise un notebook Jupyter pour collecter des images à partir d'une webcam et la bibliothèque LabelImg pour étiqueter les images. L'instructeur partage les meilleures pratiques à garder à l'esprit lors de l'étiquetage, comme garder les étiquettes aussi serrées que possible et inclure des images d'objets sous différents angles et sous différentes conditions d'éclairage. Une autre bonne pratique importante consiste à commencer avec 10 à 20 images de chaque classe, mais l'instructeur commence avec moins et montre comment ajouter des images supplémentaires pour recycler le modèle si les performances ne sont pas optimales. Enfin, l'instructeur explique que fournir au modèle une variété d'images sans écran vert derrière l'objet le rendra plus général et plus apte à détecter les objets.

  • 00:45:00 Dans cette section, l'instructeur guide les spectateurs à travers le composant de collecte d'images du didacticiel de détection d'objets TensorFlow. Le didacticiel commence par installer OpenCV, une bibliothèque de vision par ordinateur populaire utilisée pour accéder à la webcam et collecter des images. L'instructeur insiste sur l'importance de s'assurer que les dépendances s'installent dans l'environnement virtuel pour garder le contrôle et assurer le bon fonctionnement. Le code importe ensuite les dépendances nécessaires, notamment l'UUID, le système d'exploitation et l'heure, qui seront utilisées pour garantir la conformité avec différents chemins de fichiers et capturer des images sous différents angles. Le tutoriel définit ensuite les différentes étiquettes à collecter et explique que les étiquettes peuvent être modifiées en fonction des objets que l'on souhaite détecter. Les étiquettes sont stockées dans une liste, et l'instructeur explique que le nombre d'images collectées pour chaque étiquette est défini par la variable "nombre d'images".

  • 00: 50: 00 Dans cette section, l'instructeur explique comment configurer la structure de dossiers pour la détection d'objets, l'importance d'avoir un bon nombre d'images au démarrage et comment capturer des images à l'aide d'une webcam ou d'un autre périphérique de capture. La structure de dossiers est créée à l'aide d'un chemin de fichier spécifique qui doit être suivi tout au long du didacticiel. Le code parcourt toutes les étiquettes, se connecte à la webcam et capture des images pour chaque étiquette. L'instructeur insiste sur l'importance de spécifier correctement le numéro de périphérique de capture vidéo pour la webcam, car des erreurs peuvent survenir s'il est incorrect.

  • 00:55:00 Dans cette section, l'instructeur explique le code de collecte d'images pour la détection d'objets. Le code parcourt les étiquettes et capture les images à l'aide de la webcam. Il crée une nouvelle image et la place dans le dossier d'étiquettes respectif avec un nom d'identification unique. La commande cv2.iamwrite est utilisée pour écrire l'image dans un fichier et l'afficher à l'écran. Le code permet également à l'utilisateur d'appuyer sur la touche q pour s'échapper à tout moment et ferme tout une fois terminé. L'instructeur souligne qu'il est essentiel de capturer des images dans différentes positions pour construire un modèle généralisé.

Partie 2

  • 01:00:00 Dans cette section, l'orateur souligne l'importance du prototypage le plus rapidement possible pour les projets scientifiques afin d'établir la faisabilité et la possibilité du projet. Pour illustrer, le conférencier donne un exemple de détection de LED déformées, qui nécessiterait un modèle hyper précis ou un capteur tel qu'un microscope. Le prototypage rapide avec un modèle de réseau mobile et une webcam peut montrer des performances médiocres, ce qui indique la nécessité d'une technique ou d'un capteur différent. Le prototypage aide rapidement à établir une base d'amélioration, et l'orateur procède à la formation du modèle avec les images collectées pour la détection du pouce levé, tout en soulignant l'importance de supprimer les images de mauvaise qualité et de capturer davantage d'images de bonne qualité pour une meilleure détection.

  • 01:05:00 Dans cette section, l'instructeur présente le package Label Image qui sera utilisé pour étiqueter les images. Les utilisateurs peuvent accéder au référentiel Github pour vérifier le package. Après cela, l'instructeur montre comment installer les dépendances requises, pi qt5 et lxml, et créer un nouveau dossier appelé tensorflow et étiqueter l'image pour enregistrer le package. Ensuite, l'instructeur montre comment cloner le référentiel Github et installer le package d'image d'étiquette en exécutant des commandes spécifiques. Enfin, l'instructeur ouvre l'application d'image d'étiquette et se prépare à étiqueter les images.

  • 01:10:00 Dans cette section, l'instructeur démontre le processus d'étiquetage des images pour la détection d'objets à l'aide du logiciel OpenCV Labeling. Le processus comprend l'ouverture du répertoire spécifique dans le logiciel et la sélection des images à étiqueter. L'instructeur conseille d'être aussi précis que possible avec les étiquettes de détection et de s'assurer que les noms des étiquettes correspondent à ceux des annotations et de l'étape de formation. En outre, l'instructeur encourage les spectateurs à réfléchir à différentes applications de détection d'objets et à les essayer en utilisant le même processus de définition d'étiquettes, de collecte d'images et de les étiqueter. L'importance de s'assurer que les annotations correspondantes existent pour chaque image est également soulignée.

  • 01:15:00 Dans cette section, l'instructeur explique comment étiqueter une image en créant un fichier d'annotation. Le fichier d'annotation est un fichier xml qui décrit l'emplacement de l'objet dans l'image. L'instructeur montre comment étiqueter une image avec plusieurs objets et explique comment enregistrer correctement les annotations. Le processus d'étiquetage des images peut être étendu en externalisant ou en utilisant des outils plus récents qui automatisent le processus d'étiquetage à l'aide de modèles de détection d'objets légers.

  • 01:20:00 Dans cette section, l'instructeur vidéo montre comment étiqueter des images à l'aide d'une image d'étiquette et comment créer un prototype pour s'assurer que vous utilisez la bonne technique avant de créer un énorme modèle de détection d'objets avec des milliers d'images. Il recommande de commencer par étiqueter 10 à 25 images pour le garder super rapide et d'utiliser les bons capteurs pour obtenir les bons niveaux de données. L'instructeur explique également l'importance de diviser les images en une partition d'entraînement et de test pour entraîner le modèle sur un segment d'images et le tester sur un ensemble d'images qu'il n'a jamais vu auparavant. Il crée deux nouveaux dossiers appelés train et test dans le dossier images pour stocker les images et les annotations de formation et de test.

  • 01:25:00 Dans cette section, nous apprenons à préparer les données d'image que nous avons collectées et étiquetées pour entraîner notre modèle de détection d'objets. Nous créons deux dossiers, formation et test, pour stocker nos images et annotations, en veillant à récupérer les fichiers d'image et d'annotation pour chaque classe. Nous expliquons ensuite comment les convertir en enregistrements TensorFlow à utiliser pour la formation. Nous couvrons également quelques bonnes pratiques pour nommer et organiser nos données. Enfin, nous présentons les dépendances nécessaires à la formation d'un modèle de détection d'objets TensorFlow et comment évaluer notre modèle à l'aide de métriques d'évaluation.

  • 01:30:00 Dans cette section, l'intervenant discute des métriques d'évaluation que vous obtenez après l'entraînement de votre modèle de détection d'objets. Ces métriques incluent la précision et la précision moyenne moyenne (MAP), qui calcule la proportion de détections correctes. Ils sont calculés en fonction du nombre de vrais positifs, de faux positifs, de vrais négatifs et de faux négatifs. Le conférencier explique que la précision et le rappel sont très importants lors de l'évaluation des performances du modèle. De plus, l'orateur mentionne que le choix du zoo modèle TensorFlow affecte la précision et la vitesse du modèle. Différents modèles ont différentes architectures qui se traduisent par différents niveaux de précision et de vitesse, et les praticiens doivent choisir le modèle approprié pour leur cas d'utilisation.

  • 01:35:00 Dans cette section, la transcription traite des compromis entre la vitesse et la précision du modèle lors du choix d'une architecture de modèle pour la détection d'objets TensorFlow. La vidéo présente différentes options de modèle et leurs vitesses d'image correspondantes et les scores moyens de précision moyens. Le présentateur note que certaines architectures peuvent être rapides et très précises, tandis que d'autres peuvent être plus lentes mais plus précises. Les avantages de l'utilisation de l'API du modèle de détection de mise à jour TensorFlow sont également mentionnés, tels que l'utilisation de techniques de prétraitement et de post-traitement et l'augmentation d'image. La section se termine par une discussion sur la façon de former un modèle à l'aide d'une instance cloud si vous le souhaitez.

  • 01:40:00 Dans cette section, l'instructeur explique la configuration du modèle de détection d'objets TensorFlow, qui implique la configuration du nom et de l'URL du modèle pré-formé, ainsi que des variables telles que le script d'enregistrement tf généré et le nom de la carte d'étiquettes. La structure des dossiers du modèle est également affichée, avec l'espace de travail contenant des dossiers pour les annotations, les images, les modèles et les points de contrôle. L'étape suivante consiste à télécharger les modèles TensorFlow à partir du zoo de modèles TensorFlow et à installer le package de détection d'objets TensorFlow, que l'instructeur décrit étape par étape pour garantir une installation réussie. Le processus implique le clonage du référentiel TensorFlow Object Detection et l'installation des dépendances nécessaires.

  • 01:45:00 Dans cette section, le présentateur explique comment cloner et installer l'API du modèle de détection d'objets TensorFlow. L'API de modèle peut être téléchargée à partir du jardin de modèles TensorFlow, qui contient de nombreuses documentations et des didacticiels open source. Le présentateur montre ensuite comment accéder au dossier de recherche, qui contient tous les fichiers requis pour utiliser l'API du modèle de détection d'objets TensorFlow. Après avoir cloné le dossier de recherche, le présentateur explique comment installer le protocole et les autres composants nécessaires pour installer avec succès l'API du modèle de détection d'objets TensorFlow. Enfin, le présentateur montre comment vérifier l'installation en exécutant un script de vérification pour vérifier si l'API de détection d'objets TensorFlow a été installée avec succès.

  • 01:50:00 Dans cette section, l'instructeur passe par le processus de vérification et d'installation de Tensorflow pour la détection d'objets. Il explique qu'un script de vérification est utilisé pour s'assurer que Tensorflow est correctement installé et qu'il peut être exécuté pour vérifier d'éventuelles erreurs. Le script est un script de détection d'objet Tensorflow standard qui indique si Tensorflow est installé ou non lors de son exécution. Si Tensorflow n'est pas installé correctement, l'instructeur fournit des conseils sur la façon de le configurer, y compris l'installation de packages supplémentaires tels que matplotlib et yaml. L'instructeur assure au spectateur que s'il rencontre des erreurs, il peut les rechercher sur Google, car elles sont courantes et faciles à résoudre. Enfin, il déclare qu'atteindre avec succès le signe "ok" au bas du script de vérification signifie que Tensorflow a été installé correctement.

  • 01:55:00 Dans cette section, la vidéo couvre le processus d'installation de TensorFlow et les packages nécessaires à la détection d'objets. L'instructeur montre comment installer TensorFlow, Matplotlib, Protobuf, Pillow et Pymel. L'instructeur recommande de vérifier le processus d'installation, car il peut être différent selon votre environnement. La vidéo passe également en revue les étapes d'installation de CUDA et CuDNN, qui sont nécessaires si vous souhaitez utiliser le GPU pour la formation. L'instructeur explique comment trouver la bonne version de CUDA et CuDNN et passe par le processus d'installation. Enfin, l'instructeur montre comment importer avec succès l'API de détection d'objets dans le bloc-notes en redémarrant le noyau.

Partie 3

  • 02:00:00 Dans cette section, l'instructeur passe par le processus de téléchargement et d'installation de Nvidia cuDNN, qui est nécessaire si vous vous entraînez sur un GPU. Tout d'abord, vous devez vous inscrire pour un compte Nvidia Developer gratuit, puis sélectionner télécharger cuDNN et vous connecter. Deux versions sont disponibles et vous devez télécharger la version compatible avec votre version de TensorFlow. L'instructeur explique comment extraire le fichier compressé et copier les fichiers cuDNN dans leurs dossiers respectifs à l'intérieur de votre emplacement d'installation CUDA. Après avoir copié les fichiers, la dernière étape consiste à s'assurer que le dossier CUDA est ajouté à votre chemin sur une machine Windows.

  • 02:05:00 Dans cette section de la vidéo, l'instructeur explique le processus d'installation de TensorFlow et comment tester s'il fonctionne correctement ou non. La vidéo passe ensuite au processus de téléchargement d'un modèle de détection d'objets pré-formé à partir du zoo modèle TensorFlow, qui sera utilisé pour l'apprentissage par transfert afin de détecter des objets personnalisés. L'instructeur montre comment télécharger le modèle et explique les différents composants des fichiers téléchargés. Enfin, une carte d'étiquettes est créée pour représenter les différentes étiquettes pour la détection d'objets personnalisés.

  • 02:10:00 Dans cette section, l'instructeur explique la création d'une carte d'étiquettes et la génération d'enregistrements tf. Il souligne l'importance d'un étiquetage approprié car le fichier de carte d'étiquettes sera utilisé par la suite tout au long du processus de formation. La vidéo explique comment générer un train et un enregistrement de test et comment mettre à jour les composants du chemin pour le modèle, en particulier le point de contrôle de réglage fin, le chemin de la carte d'étiquettes et le chemin d'entrée. Enfin, il souligne la pertinence du fichier de configuration du pipeline, qui détermine l'architecture du modèle et doit être personnalisé pour des modèles spécifiques.

  • 02:15:00 Dans cette section de la vidéo, l'instructeur explique comment configurer le fichier de configuration pour former le modèle. Le fichier de pipeline est copié à partir du dossier des modèles pré-formés, puis la configuration est effectuée via le code en configurant tous les différents chemins de fichier avec le nombre de classes et en configurant un point de contrôle précis, le chemin de la carte d'étiquettes, le chemin d'entrée, etc. Une fois la configuration terminée, le modèle peut être formé en exécutant le script de formation du modèle avec les arguments nécessaires tels que le chemin du fichier pipeline.config, la configuration du pipeline et le nombre d'étapes de formation. Il est suggéré d'exécuter la commande dans une invite de commande distincte en dehors du bloc-notes pour voir la progression de la formation du modèle.

  • 02:20:00 Dans cette section, l'instructeur résout les erreurs qui se produisent pendant le processus de formation à la détection d'objets. Il explique que la plupart des erreurs sont résolues en installant la bonne bibliothèque ou en recherchant des solutions en ligne. Il note également que les utilisateurs doivent s'assurer qu'ils ont installé la bonne version de TensorFlow GPU s'ils souhaitent tirer parti du GPU. L'instructeur guide ensuite les spectateurs tout au long du processus de désinstallation et de réinstallation des bibliothèques pour résoudre des erreurs spécifiques, en soulignant que ce processus peut prendre un certain temps mais qu'il est nécessaire pour une formation réussie à la détection d'objets. En fin de compte, il montre aux téléspectateurs comment vérifier qu'ils ont installé les bonnes bibliothèques et comment surveiller la progression de l'exécution de la formation.

  • 02:25:00 Dans cette section, l'instructeur décrit le processus de formation du modèle et d'évaluation de ses métriques de performance. Une fois la formation lancée, les métriques de perte apparaissent toutes les 100 étapes, indiquant que le modèle est correctement formé. La sortie du modèle de formation pour 2000 pas est générée, indiquant que le modèle a été formé avec succès avec une perte finale de 0,188. L'instructeur explique ensuite comment évaluer le modèle à l'aide de la bibliothèque de détection d'objets TensorFlow et exécuter le script d'évaluation, qui génère des métriques de performances pour le modèle entraîné. Les mesures de précision et de rappel moyennes peuvent ensuite être consultées à l'aide de TensorBoard, un outil de surveillance interactif pour TensorFlow.

  • 02:30:00 Dans cette section, l'instructeur guide les spectateurs dans l'utilisation de Tensorboard pour afficher et suivre les métriques pendant la formation et l'évaluation. En accédant au dossier train, ils peuvent afficher les métriques de perte au fil du temps, et en accédant au dossier eval, ils peuvent voir les métriques d'évaluation telles que la précision moyenne moyenne, la précision et le rappel. Les téléspectateurs peuvent également voir les performances en temps réel du modèle en visualisant les images et s'il les classe correctement, et ils apprennent à exporter le graphique après l'avoir figé.

  • 02:35:00 Dans cette section, le modèle formé est chargé à partir du point de contrôle et la détection d'objet est effectuée sur une image. Le dernier point de contrôle se trouve dans le dossier du modèle personnalisé, qui contient le pipeline et tous les points de contrôle. Une fois le dernier point de contrôle importé, une image peut être sélectionnée et la détection d'objet peut être effectuée à l'aide de la fonction de détection. La fonction de détection est également utilisée pour effectuer des détections d'objets en temps réel à partir d'une webcam. Malgré une formation pour seulement 2000 étapes avec peu d'images, le modèle fonctionne bien pour détecter différents gestes de la main.

  • 02:40:00 Dans cette section, l'instructeur démontre les performances du modèle de détection d'objet sur différents gestes de la main, tels que le pouce vers le haut, le pouce vers le bas, la vie longue et les deux mains. Les performances du modèle varient en fonction du geste de la main et de la distance par rapport à la caméra, mais elles peuvent être affinées en ajoutant plus d'images à l'ensemble d'entraînement. La section passe ensuite au gel et à la conversion du modèle en créant un graphique gelé et en l'exportant vers TensorFlow.js et TFLite. Le modèle converti peut être utilisé pour une application Web ou pour un projet Raspberry Pi. La sortie finale du modèle personnalisé est similaire aux modèles pré-formés, avec un point de contrôle, des actifs de modèle enregistrés, des variables et une configuration de pipeline.

  • 02:45:00 Dans cette section, l'orateur discute de la dernière conversion qui doit être faite, qui est la conversion en tf light. Cela se fait en deux parties : d'abord, le graphique est exporté vers un graphique tf lite, puis il est exécuté à l'aide du convertisseur tf lite pour générer la sortie exacte nécessaire pour l'exploiter. L'orateur note qu'il s'agit du modèle de bout en bout et qu'ils ont gelé le graphique, l'ont exporté vers tfjs et tf lite, complétant ainsi la procédure complète de travail avec l'API de détection d'objet tensorflow. L'orateur poursuit également en discutant de l'optimisation des performances et note trois choses clés qui peuvent être faites pour améliorer les performances du modèle : ajouter plus d'images d'une classe peu performante à l'ensemble de données d'entraînement, entraîner le modèle plus longtemps et modifier l'architecture du modèle.

  • 02:50:00 Dans cette section de la vidéo, le présentateur montre comment améliorer les performances des classes peu performantes dans le modèle de détection d'objets en ajoutant des images d'entraînement plus pertinentes. Plutôt que de collecter des images de chaque classe, le présentateur collecte davantage d'images de pouces vers le haut et vers le bas, qui n'ont pas bien fonctionné avec des mains différentes. Le présentateur importe OpenCV et met à jour la carte d'étiquettes avant de collecter les images des pouces vers le haut et vers le bas uniquement. Les images collectées sont stockées dans l'espace de travail Tensorflow, où le présentateur les évalue et supprime celles de mauvaise qualité. Enfin, le présentateur ajoute quelques images supplémentaires de pouces vers le bas avec une main différente pour améliorer les performances du modèle.

  • 02:55:00 Dans cette section de la vidéo, l'instructeur exécute du code pour capturer plus d'images pour les gestes de la main vers le haut et vers le bas. Après avoir capturé les images, l'instructeur vérifie la qualité des images et décide de conserver toutes les images du pouce vers le haut et de supprimer certaines des images du pouce vers le bas qui sont hors de l'écran. L'instructeur ouvre ensuite l'outil LabelImg et étiquette à nouveau les nouvelles images, en faisant attention à la sensibilité à la casse des noms d'étiquettes. L'instructeur mentionne que cette étape d'étiquetage des images est un essai et une erreur, et on peut évaluer et voir ce qui rend le modèle plus performant. L'instructeur suggère d'examiner les outils d'étiquetage automatique pour améliorer l'efficacité, mais conseille de prêter attention à leurs performances pour éviter tout besoin de peaufinage manuel.

Partie 4

  • 03:00:00 Dans cette section, l'instructeur montre comment étiqueter rapidement des images afin d'améliorer la formation du modèle de détection d'objets TensorFlow. Il explique qu'il est important de copier les images étiquetées dans les dossiers de formation et de test afin d'évaluer la précision du modèle. Ensuite, il montre comment entraîner un modèle "réglé" en modifiant le nom du modèle personnalisé dans le bloc-notes d'entraînement et de détection pour créer un nouveau dossier. Il explique ensuite comment copier la configuration de pipeline pré-formée dans le nouveau modèle optimisé et effectuer des mises à jour dans la configuration de pipeline. Enfin, il configure tous les chemins nécessaires à l'aide du code fourni pour créer les nouveaux fichiers d'enregistrement tf nécessaires à la formation.

  • 03:05:00 Dans cette section, l'instructeur met à jour la configuration du pipeline qui définit tous les chemins de carte d'étiquettes pour la formation à l'aide de la configuration standard. La mise à jour du pipeline est une étape essentielle car elle ouvre la voie à l'exécution du script de formation. Le nombre d'étapes de formation est mis à jour à partir de la configuration précédente à 3000, et la commande est exécutée pour créer le modèle formé. Après l'achèvement des étapes de formation, ce modèle est évalué et comparé au modèle précédent en exécutant le code à l'étape 7. Les métriques d'évaluation montrent que la précision moyenne est passée de 0,7 à 0,834, et la détection est plus rapide et plus précise. En ajoutant plus d'images, des étiquettes supplémentaires et différentes positions, l'instructeur démontre l'amélioration du modèle et la production d'un meilleur modèle de détection d'objet. Enfin, le nouveau modèle est chargé et le code est exécuté pour la détection en temps réel, qui détecte les objets très rapidement et avec précision.

  • 03:10:00 Dans cette section, l'instructeur explique comment améliorer les performances du modèle de détection d'objets Tensorflow en modifiant l'architecture du modèle. Pour ce faire, l'utilisateur doit mettre à jour le lien du modèle pré-formé qu'il souhaite utiliser dans le carnet de détection. En copiant et collant le nouveau lien et le nouveau nom, l'utilisateur peut ensuite télécharger le nouveau modèle pré-formé dans son dossier de modèles pré-formés. Cependant, l'instructeur souligne que de meilleures performances sont obtenues en améliorant la qualité de l'image, par exemple en utilisant différents styles d'images, des images avec des angles différents et un entraînement sur de plus longues périodes. L'instructeur montre également comment entraîner un modèle dans Google Colab en compressant les images et en les archivant avant de les importer dans le cahier d'entraînement et de détection sur Colab.

  • 03:15:00 Dans cette section, l'instructeur guide les spectateurs tout au long du processus de téléchargement d'images à utiliser dans le programme de détection d'objets TensorFlow, ainsi que de clonage du référentiel de modèles TensorFlow et d'installation du logiciel de détection d'objets TensorFlow. Le modèle pré-formé est importé et la carte d'étiquettes est créée. L'instructeur établit ensuite une configuration personnalisée dans le dossier models/my_ssd_mobnet avant de former le modèle. Le spectateur est averti que la détection d'objets en temps réel ne peut pas être effectuée avec une webcam à l'aide de Colab, mais peut être effectuée avec une image. Au fur et à mesure que le spectateur progresse dans le processus, il peut évaluer son modèle pour voir la précision moyenne moyenne et le rappel moyen.

  • 03:20:00 Dans cette section de la vidéo, l'instructeur montre comment détecter des objets dans une image à l'aide du modèle formé. Le dernier point de contrôle est chargé et le nom de l'image est spécifié pour exécuter le script de détection. L'instructeur souligne que l'image doit être valide et située dans le dossier images. Après avoir exécuté la cellule, le modèle de détection d'objet formé identifie l'objet dans l'image. L'instructeur explique en outre comment compresser et exporter les fichiers et insiste sur la nécessité d'installer l'API de détection d'objet lors de l'exécution du code localement. La section se termine par un aperçu des trois projets qui seront abordés ensuite, notamment l'utilisation d'un microscope pour la détection d'objets, la création d'une application Web TensorFlow.js et la détection des sentiments Raspberry Pi.

  • 03:25:00 Dans cette section, l'instructeur commence par expliquer le premier projet, qui consiste à utiliser un microscope USB pour détecter les défauts dans les petites LED. Le microscope est traité comme n'importe quelle autre caméra et le flux vidéo est obtenu à l'aide de la bibliothèque OpenCV. L'instructeur montre comment positionner et zoomer le microscope à l'aide du code Python et affiche le flux vidéo. Le flux vidéo est ensuite utilisé pour collecter des images d'entraînement pour la détection d'objets. L'objectif de ce projet est de former un modèle pour détecter les défauts dans les LED et les classer comme étant pliés ou non pliés.

  • 03:30:00 Dans cette section du cours complet sur la détection d'objets TensorFlow avec trois projets, l'instructeur montre comment utiliser OpenCV pour capturer des images à partir d'une webcam ou d'un flux de microscope. Il passe en revue les meilleures pratiques pour libérer le périphérique de capture et détruire toutes les fenêtres OpenCV, y compris l'exécution de "cap.release" après la fermeture de toute capture Web cv2. Il montre ensuite comment ajuster la position et la mise au point du microscope pour capturer des images de broches LED, et comment créer deux nouveaux dossiers pour stocker des images de broches défectueuses et non défectueuses. Enfin, il teste le flux de la webcam pour la capture d'image afin de s'assurer que tout fonctionne comme prévu.

  • 03:35:00 Dans cette section de la vidéo, l'instructeur montre comment collecter des images d'une broche défectueuse et d'une broche non défectueuse pour la détection d'objets. Ils positionnent les broches et ajustent le temps de veille entre les captures d'images, puis utilisent la fonction de veille pour faire une pause entre les captures. L'instructeur explique également comment étiqueter les images à l'aide de la ligne d'étiquetage et de l'emplacement du dossier. Ils encouragent les téléspectateurs à demander des éclaircissements ou à fournir des commentaires dans la section des commentaires ou sur le serveur Discord.

  • 03:40:00 Dans cette section de la vidéo, l'instructeur passe par le processus d'étiquetage des images pour former un modèle de détection d'objet personnalisé à l'aide de TensorFlow. À l'aide d'un microscope, l'instructeur capture des images de broches défectueuses et non défectueuses et les étiquette en conséquence. Ils copient ensuite les images dans des dossiers de formation et de test avant de configurer leur pipeline de formation. L'instructeur explique comment créer un nouveau dossier pour son modèle de détection d'objet personnalisé et mettre à jour la carte d'étiquettes pour inclure les nouvelles étiquettes. La base de code utilisée dans cette section est assez polyvalente, permettant de nombreuses personnalisations, et l'instructeur fournit des conseils sur le réglage des performances.

  • 03:45:00 Dans cette section du didacticiel, l'accent est mis sur la création d'enregistrements TensorFlow, qui permettent la formation du modèle. Les cellules nécessaires pour télécharger des modèles pré-formés et créer des cartes d'étiquettes sont discutées, mais l'accent est mis sur la création d'enregistrements TensorFLow qui permettront la formation du modèle. Une fois les enregistrements TensorFlow créés, le modèle est mis à jour avec les nouvelles classes et la configuration mise à jour est enregistrée. Le modèle est formé pour 2000 étapes et le nouveau modèle est testé pour détecter les broches défectueuses et non défectueuses. Le cahier est esquissé, et l'utilisateur est dirigé vers des cellules spécifiques permettant le développement de ce modèle.

  • 03:50:00 Dans cette section, l'instructeur met à jour l'image pour détecter une broche défectueuse et une broche non défectueuse. Le système détecte avec succès les deux broches avec une grande confiance. Cependant, l'instructeur remarque que le système ne fonctionne pas bien avec la broche défectueuse dans une position spécifique, mettant en évidence un compromis de réglage. L'instructeur montre que la trame de détection a des paramètres qui peuvent être modifiés pour déterminer le niveau de précision de la détection. En réduisant le seuil de score minimum, le système peut détecter raisonnablement bien la broche défectueuse, mais au prix de détecter de nombreuses autres choses comme défectueuses. L'instructeur teste le système avec des broches de différentes couleurs, dont une qui n'a pas été entraînée, et à un angle, montrant la robustesse du système.

  • 03:55:00 Dans cette section, l'instructeur démontre les résultats du premier projet en utilisant un microscope comme méthode de détection d'objet. Il indique les broches détectées et comment elles sont classées comme défectueuses ou non défectueuses en modifiant les angles et les positions des broches. Il résume le processus du premier projet, qui implique la capture et l'étiquetage des images, la mise en place d'un dossier de microscope et la formation du modèle. Le prochain projet se concentre sur la création d'une application Web pour détecter la direction d'un objet. Cela implique de combiner le code du cours de détection d'objets TensorFlow avec le référentiel Github de l'application de détection d'objets TensorFlow. L'objectif est de détecter les mouvements haut-bas-gauche-droite qui peuvent être déployés en tant que site Web à l'avenir.

Partie 5

  • 04:00:00 Dans cette section de la vidéo, l'instructeur explique comment définir et réinitialiser les étiquettes pour la détection d'objets Tensorflow. Au lieu de définir des étiquettes telles que les pouces vers le haut ou vers le bas, ou des broches défectueuses et non défectueuses, ils montrent comment définir des mouvements directionnels tels que gauche, droite, haut et bas à la place. Ils montrent ensuite comment créer des dossiers pour les différentes directions et collecter des images à utiliser pour la formation. L'instructeur explique également comment étiqueter les images à l'aide de LabelImg, en prêtant attention aux cas d'image, et suggère un réglage des performances en cas de résultats médiocres. Enfin, ils montrent comment étiqueter les images dans la bonne direction.

  • 04:05:00 Dans cette section de la vidéo, l'instructeur montre comment étiqueter des images à utiliser dans le modèle de détection d'objet. Seules cinq images sont utilisées par objet/classe, mais l'utilisateur peut ajuster le nombre comme il le souhaite. L'instructeur indique qu'il s'agit d'un processus itératif et qu'il est acceptable d'expérimenter avec différents nombres d'images. Une fois les images étiquetées, elles sont triées dans des dossiers de formation et de test, avec une répartition 80/20 pour chaque image/classe. Lorsque les dossiers sont configurés, l'instructeur modifie le nom du dossier et crée un nouveau chemin de fichier appelé "directions". Enfin, l'instructeur note que l'environnement virtuel est déjà configuré et qu'il n'est pas nécessaire d'effectuer d'étapes supplémentaires.

  • 04:10:00 Dans cette section, la carte des étiquettes est mise à jour avec de nouvelles étiquettes pour "gauche", "droite", "haut" et "bas", et des identifiants uniques sont attribués à chacune. Les annotations sont ensuite exécutées pour mettre à jour la carte d'étiquettes et générer les fichiers d'apprentissage et de test requis. Le modèle est ensuite formé à l'aide d'une commande pour générer le script de formation, et la perte est calculée à 0,299. Le point de contrôle 3 est restauré pour importer les dépendances pour les détections en temps réel, et le seuil de score minimum est défini sur 90. Enfin, la webcam est activée pour générer des détections en temps réel pour le modèle de détection d'objets.

  • 04:15:00 Dans cette section, l'instructeur montre comment évaluer le modèle et améliorer sa précision en ajoutant plus d'images des classes particulières qui ne fonctionnent pas bien. Il le démontre en pointant
    dans différentes directions en utilisant les deux mains et en voyant comment le modèle fonctionne. Il continue ensuite à geler le graphique, à l'exporter et à le convertir en tensorflow.js. Il explique également comment télécharger le modèle sur IBM Cloud Object Store et parcourir les étapes disponibles dans le référentiel github. L'instructeur continue ensuite à cloner le référentiel, ouvre une nouvelle invite de commande et montre comment naviguer vers les dossiers appropriés.

  • 04:20:00 Dans cette section de la vidéo, l'instructeur explique étape par étape comment préparer un environnement de développement pour utiliser la détection d'objets TensorFlow pour la reconnaissance d'images. L'instructeur montre d'abord comment accéder aux dossiers nécessaires et cloner le référentiel de détection d'objets TensorFlow. Ensuite, l'instructeur montre comment installer Node.js et les dépendances pour le référentiel. Enfin, l'instructeur montre comment créer un nouveau bucket de stockage d'objets cloud sur IBM Cloud et comment le nommer. Ce processus est nécessaire pour utiliser l'interface utilisateur Web dans les sections ultérieures de la vidéo.

  • 04:25:00 Dans cette section, l'instructeur passe à l'étape cinq du didacticiel, qui consiste à créer un compartiment dans IBM Cloud Object Storage et à y télécharger les fichiers model.json et .bin. Ensuite, il active une politique d'accès public, permettant d'accéder au modèle depuis n'importe quel emplacement, et montre comment récupérer l'URL du fichier model.json pour une utilisation ultérieure dans l'application. Il parcourt ensuite le processus d'activation du partage de ressources cross-origin (CORS) en exécutant des commandes CLI après avoir installé l'interface de ligne de commande IBM Cloud Object Storage.

  • 04:30:00 Dans cette section, la vidéo montre comment installer l'interface de ligne de commande IBM Cloud et IBM Cloud Object Storage via une interface de ligne de commande, permettant le partage de ressources cross-origin (CORS), qui permet à une application Web d'accéder à une URL d'ailleurs. La commande installe également le client IBM Cloud Storage et le configure avec un fichier de configuration. La vidéo montre comment remplacer le nom du compartiment d'un utilisateur dans une commande qui place la stratégie de cause dans le dossier racine du compartiment. Enfin, la vidéo explique que la politique de cause est contenue dans le fichier de configuration du cloud et fait partie du référentiel cloné, ce qui signifie qu'aucune création de fichier n'est nécessaire.

  • 04:35:00 Dans cette section, l'instructeur explique comment mettre à jour les fichiers nécessaires pour exécuter l'application Web TensorFlow.js. Les étapes comprennent la définition des informations d'identification Google Cloud Storage, la mise à jour de l'URL du modèle dans app.js, la mise à jour de la carte d'étiquettes dans utilities.js et le démarrage de l'application à l'aide de npm start. L'instructeur explique également comment déboguer l'application si elle ne fonctionne pas, notamment en modifiant la métrique de confiance et en vérifiant l'ordre des objets dans le tableau des résultats de détection. Dans l'ensemble, ces étapes permettent aux utilisateurs de personnaliser l'application Web en fonction de leur cas d'utilisation spécifique et de s'assurer qu'elle fonctionne correctement.

  • 04:40:00 Dans cette section, la vidéo montre comment déterminer où se trouvent les objets et comment manipuler le tableau de résultats. En inspectant le code, l'utilisateur peut identifier que le tableau de résultats contient cinq valeurs, et chaque tableau a différentes classes qui sont disponibles pour une application particulière. La vidéo guide en outre l'utilisateur sur la façon d'utiliser correctement chaque tableau d'objets, tel que l'objet trois, qui est des classes de boîtes de processus non post-processus représentées par des nombres très faibles. La vidéo montre ensuite comment modifier les valeurs de mesure et de score de confiance et ajuster la valeur de la boîte, ce que l'utilisateur peut faire rapidement en modifiant les valeurs du tableau des boîtes.

  • 04:45:00 Dans cette section, la vidéo conclut le deuxième projet et passe au troisième projet qui consiste à exécuter des modèles de détection d'objets sur un Raspberry Pi. L'orateur note que l'exécution de modèles de détection d'objets sur le Raspberry Pi est différente des deux projets précédents en raison de l'absence de GPU, et par conséquent, ils convertiront spécifiquement le modèle au format Tensorflow lite. Ils collecteront des images de visages heureux et tristes et formeront leur modèle en utilisant le même processus qu'auparavant. Cependant, ils utiliseront le Raspberry Pi pour ce projet et y accéderont à distance pour les détections. La vidéo se termine en mentionnant la possibilité d'exécuter plusieurs modèles différents sur différents appareils et encourage les téléspectateurs à partager leurs idées sur ce sujet.

  • 04:50:00 Dans cette section de la vidéo, l'instructeur montre comment rassembler et étiqueter des images pour un détecteur de sentiments qui reconnaît les visages heureux et tristes. Le processus consiste à supprimer des images existantes, à créer des chemins pour de nouvelles images, à collecter cinq images de chaque émotion, à étiqueter les images et à enregistrer chaque objet. L'instructeur rappelle aux téléspectateurs que la sensibilité à la casse est cruciale dans l'étiquetage et que les écrans verts ne sont pas nécessaires pour cet exercice. De plus, l'instructeur note que les utilisateurs peuvent toujours revenir au répertoire d'images pour mettre à jour une étiquette d'image.

  • 04:55:00 Dans cette section, l'instructeur montre comment organiser et déplacer les images et les annotations collectées dans les dossiers de formation et de test. Ils montrent comment créer un nouveau modèle personnalisé et étiqueter les images collectées comme heureuses et tristes en mettant à jour la carte d'étiquettes. Ils créent ensuite des enregistrements tf et copient la configuration du modèle pré-formé dans le dossier du modèle personnalisé. Après avoir mis à jour la configuration, ils forment le modèle à l'aide de la commande générée, qui s'exécute dans l'environnement virtuel, et attendent la fin du processus.

Partie 6

  • 05:00:00 Dans cette section, l'instructeur parle d'une erreur courante qui peut se produire lors de l'exécution de la formation du modèle de sentiment lorsque vous travaillez sur une machine GPU. Le message d'erreur indique que le GPU est complètement consommé, ce qui fait que le système passe un mauvais moment. Pour résoudre ce problème, les utilisateurs doivent arrêter tout ce qui pourrait utiliser le GPU à tout moment, puis relancer l'entraînement. Une fois la formation terminée, les utilisateurs peuvent importer le système d'exploitation et ces chemins et vérifier également le dernier point de contrôle. L'instructeur démontre également l'utilisation du modèle de sentiment en temps réel, qui est un processus rapide et facile une fois le système configuré.

  • 05:05:00 Dans cette section, l'instructeur explique les étapes nécessaires pour créer un modèle de détection Raspberry Pi à l'aide de la détection d'objets TensorFlow. La première étape consiste à créer les fichiers TfLite en suivant le cours de détection d'objets TensorFlow. Ensuite, les utilisateurs doivent cloner le référentiel de détection Raspberry Pi, le télécharger sur leur PC ou le cloner à partir du Raspberry Pi. Une fois cela fait, les utilisateurs doivent installer les dépendances requises, copier leur modèle converti et l'exécuter en utilisant le modèle detect.tf lite existant. L'instructeur montre également comment connecter le bureau à distance au Raspberry Pi à l'aide de xrdp, ce qui facilite le processus.

  • 05:10:00 Dans cette section, l'instructeur parcourt le processus d'installation de toutes les dépendances nécessaires pour travailler avec l'API de détection d'objets de TensorFlow sur un Raspberry Pi. L'instructeur montre comment installer OpenCV Python, ainsi que plusieurs autres dépendances nécessaires pour qu'OpenCV fonctionne sur le Raspberry Pi. Ensuite, l'instructeur installe le runtime TensorFlow Lite, qui est nécessaire pour exécuter les modèles TensorFlow Lite sur le Raspberry Pi. Une fois toutes les dépendances installées, ils exécutent un exemple de modèle de détection d'objet sur le Raspberry Pi pour montrer comment cela fonctionne. Enfin, l'instructeur explique comment ajouter un modèle personnalisé et des étiquettes au système.

  • 05:15:00 Dans cette section, l'instructeur explique la détection d'objets personnalisés et comment ajuster le seuil de détection pour obtenir de meilleurs résultats. La détection d'objets personnalisés comprend deux étiquettes ; Joyeux et triste. L'instructeur ajuste l'ordre des étiquettes à heureux comme premier objet et triste comme deuxième objet. En exécutant le modèle personnalisé, il ne détecte aucun objet et l'instructeur décide d'abaisser le seuil de détection à 20 %. Après avoir réexécuté la commande, le modèle détecte des objets ; un grand objet triste et un objet heureux. L'instructeur souligne la nécessité d'entraîner le modèle avec plus d'images pour obtenir de meilleurs résultats de performance. L'instructeur effectue un réglage supplémentaire des performances en ajoutant plus d'images des classes performantes et en entraînant le modèle plus longtemps.

  • 05:20:00 Dans cette section, l'orateur explique comment il a amélioré les performances de son modèle d'analyse des sentiments. Tout d'abord, il a ajouté des images supplémentaires de lui-même sous différents angles, ce qui augmente les chances que le modèle se généralise bien. Deuxièmement, il a formé son modèle pour 5600 étapes supplémentaires, lui donnant un tout nouveau modèle avec un point de contrôle d'index plus grand. Il est ensuite allé convertir ce nouveau modèle en un graphique tf-lite gelé et l'a introduit dans Raspberry Pi, qu'il a utilisé pour détecter s'il était heureux ou triste. L'orateur démontre que l'écran vert en haut ou en bas n'a pas eu d'impact sur les performances de son modèle, et il a pu détecter correctement quand il était heureux ou triste. L'orateur met l'accent sur la puissance du réglage des performances et sur la manière dont il peut être utilisé pour améliorer la précision du modèle.

  • 05:25:00 Cet extrait final conclut le cours de détection d'objets Tensorflow en 5 heures avec Python, l'instructeur rappelant aux téléspectateurs de tendre la main dans les commentaires ou via le canal Discord s'ils ont besoin d'aide supplémentaire. Le cours est bénéfique pour les téléspectateurs qui souhaitent en savoir plus sur la détection d'objets et souhaitent acquérir une connaissance approfondie de Tensorflow, car il couvre trois projets dans le cadre du cours lui-même.
GitHub - nicknochnack/TFODCourse
GitHub - nicknochnack/TFODCourse
  • nicknochnack
  • github.com
This set of Notebooks provides a complete set of code to be able to train and leverage your own custom object detection model using the Tensorflow Object Detection API. This accompanies the Tensorflow Object Detection course on my YouTube channel. Steps Step 1. Clone this repository: https://github.com/nicknochnack/TFODCourse Step 2. Create a...
 

Reconnaissance automatique des plaques d'immatriculation avec Tensorflow et EasyOCR Cours complet en 2 heures | Python

Cahier final : https://github.com/nicknochnack/RealTimeAutomaticNumberPlateRecognition

Code de base : https://github.com/nicknochnack/TFODCourse



Reconnaissance automatique des plaques d'immatriculation avec Tensorflow et EasyOCR Cours complet en 2 heures | Python

La vidéo YouTube intitulée « Automatic Number Plate Recognition using Tensorflow and EasyOCR Full Course in 2 Hours | Python » fournit un guide complet pour créer un système précis et efficace de reconnaissance automatique des plaques d'immatriculation (ANPR) à l'aide de Tensorflow et EasyOCR. Le système ANPR utilise un système en deux parties, TensorFlow étant utilisé pour détecter la région d'intérêt de la plaque d'immatriculation, tandis qu'EasyOCR extrait le texte de la région détectée. La vidéo couvre une gamme de sujets, de la configuration des environnements virtuels et l'installation des dépendances nécessaires, à la préparation des données pour la formation et le dépannage des erreurs qui peuvent survenir pendant la formation. Dans l'ensemble, les téléspectateurs peuvent acquérir une compréhension détaillée de la façon de créer un système ANPR de qualité production avec des capacités de détection d'images en temps réel ou standard.

Le didacticiel YouTube sur la reconnaissance automatique des plaques d'immatriculation (ANPR) avec TensorFlow et EasyOCR explique comment détecter avec précision les plaques d'immatriculation à l'aide de la détection d'objets et comment extraire les numéros de plaque à l'aide de l'OCR. L'instructeur explique comment filtrer le texte en fonction de la taille et des coordonnées pour extraire uniquement les informations pertinentes de la plaque. Ils montrent comment allouer des ressources GPU et limiter la consommation de mémoire pour TensorFlow, extraire les scores d'image, les classes et les boîtes qui dépassent le seuil de détection, et appliquer l'OCR à l'aide d'EasyOCR. De plus, la vidéo explique comment enregistrer les résultats de sortie dans un fichier CSV et un chemin de dossier pour les résultats en temps réel et les images. L'orateur souligne que le code est disponible pour les téléspectateurs et les encourage à demander de l'aide et à partager leurs commentaires.

  • Le système 00:00:00 est l'OCR ou la reconnaissance optique de caractères. Cette étape consiste à utiliser une bibliothèque appelée EasyOCR pour extraire le texte du flux de plaques d'immatriculation détecté, ce qui nous permet de lire et d'analyser le texte des plaques d'immatriculation en temps réel ou sur des images standard. De plus, le cours couvre également la construction d'un système plus avancé qui imite les systèmes AMPR pré-construits de qualité de production en enregistrant et en enregistrant les plaques précédemment détectées et leurs régions d'intérêt. Dans l'ensemble, le cours offre un guide complet pour créer un système de reconnaissance automatique de plaques d'immatriculation précis et efficace à l'aide de Tensorflow et EasyOCR.

  • 00:05:00 cette section, le présentateur explique le système en deux parties utilisé pour la reconnaissance automatique des plaques d'immatriculation. La première partie utilise le modèle de détection d'objets TensorFlow pour détecter la région d'intérêt qui est la plaque d'immatriculation. La deuxième partie utilise EasyOCR pour extraire le texte de la région détectée. Le présentateur montre comment installer les composants nécessaires, y compris TensorFlow et EasyOCR, et fournit un lien vers le référentiel GitHub contenant les fichiers requis. Le présentateur explique comment cloner le référentiel et montre le contenu du dossier qui est créé en conséquence. Le dossier contient un fichier de bloc-notes utilisé pour la formation et la détection de la plaque d'immatriculation.

  • 00:10:00 Dans cette section de la vidéo, le présentateur décrit les étapes de configuration d'un environnement virtuel et d'installation des dépendances nécessaires pour exécuter la reconnaissance automatique des plaques d'immatriculation (ANPR) à l'aide de TensorFlow et EasyOCR. Le présentateur clone d'abord le référentiel ANPR et crée un environnement virtuel avec Python. Il active ensuite l'environnement virtuel et installe les dépendances importantes telles que le noyau ipi et les mises à jour pip. À travers ces étapes, il montre comment associer l'environnement virtuel à un bloc-notes Jupyter pour tirer parti de toute la puissance de l'ANPR.

  • 00:15:00 Dans cette section, l'instructeur guide le spectateur à travers le processus d'association de son environnement virtuel à son bloc-notes Jupyter en utilisant l'environnement "ampr sys" comme exemple. L'instructeur note que c'est important car souvent, les personnes qui travaillent avec des environnements virtuels installent tout dans leur environnement, mais lorsqu'elles entrent dans leur Jupyter Notebook, cela dit toujours que ce n'est pas là. Une fois l'environnement virtuel associé au bloc-notes Jupyter, l'instructeur guide ensuite le spectateur tout au long du processus d'installation de l'API de détection d'objets TensorFlow et de configuration de la structure de dossiers pour pouvoir effectuer la détection d'objets à l'aide de TensorFlow.

  • 00:20:00 Dans cette section, l'instructeur commence par expliquer le concept d'apprentissage par transfert, selon lequel un modèle de pointe déjà existant peut être affiné pour un cas d'utilisation spécifique, tel que la détection de plaques d'immatriculation. L'instructeur procède ensuite au téléchargement des modèles pré-formés à partir du zoo de modèles TensorFlow et installe l'API de détection d'objets TensorFlow en exécutant plusieurs cellules de code. L'API et ses composants, tels que le dossier de détection d'objets, sont clonés dans le référentiel de jardins de modèles TensorFlow, et l'installation du modèle de détection d'objets TensorFlow est lancée. L'installation implique plusieurs dépendances et protocole, le système de tampons de protocole, et peut prendre un certain temps.

  • 00:25:00 Dans cette section, l'instructeur décrit l'installation de TensorFlow et de sa version GPU. Ils installent TensorFlow 2.4.1 et TensorFlow GPU 2.4.1, qui n'est compatible qu'avec les GPU Nvidia. Ils montrent comment vérifier que l'installation a réussi en exécutant un script de vérification, qui devrait afficher "Ok" à la fin. L'instructeur montre également comment résoudre les erreurs "module introuvable" qui peuvent survenir pendant le processus d'installation, telles que l'installation des bibliothèques Matplotlib et Pillow à l'aide de pip. Le script de vérification garantit que toutes les dépendances nécessaires sont installées avant de passer à la section suivante.

  • 00:30:00 Dans cette section de la vidéo, le présentateur décrit l'installation de divers modules nécessaires à la construction d'un modèle de détection d'objets, en particulier pour la reconnaissance des plaques d'immatriculation. Ils rencontrent plusieurs erreurs au cours du processus d'installation, mais ils expliquent comment les résoudre. Une fois que tous les modules nécessaires, y compris TensorFlow Object Detection et EasyOCR, sont installés, le présentateur passe à l'étape suivante, en travaillant avec des données, et introduit un ensemble de données Kaggle qui contient des images de voiture et des annotations pour les plaques d'immatriculation. Ils montrent comment télécharger et préparer l'ensemble de données à utiliser dans le modèle.

  • 00: 35: 00 Dans cette section, l'instructeur explique comment télécharger les données nécessaires pour la reconnaissance automatique des plaques d'immatriculation (ANPR) et les organiser en ensembles de formation et de test pour la détection d'objets. Les données, qui contiennent des annotations et des images correspondantes, sont téléchargées depuis Kaggle et décompressées dans le dossier ANPR. Deux nouveaux dossiers sont créés dans le dossier images, un pour la formation et un pour les tests, et les images téléchargées sont copiées dans le dossier train. Les annotations sont également divisées en ensembles d'entraînement et de test, les annotations d'entraînement étant placées dans le dossier d'entraînement à côté de leurs images correspondantes. Le but de ces ensembles séparés est de former le modèle de détection d'objets sur un ensemble de données et de le tester sur un ensemble indépendant pour évaluer ses performances.

  • 00:40:00 Dans cette section, la vidéo décrit le processus de préparation des données pour la formation d'un modèle de détection de plaque d'immatriculation. Le présentateur explique qu'il a téléchargé des images de plaques d'immatriculation à partir de Kaggle et copié les annotations correspondantes dans deux nouveaux dossiers, "train" et "test", dans son espace de travail TensorFlow. L'étape suivante consiste à entraîner le modèle de détection d'objets, ce qui implique la mise à jour des étiquettes, la création d'enregistrements tf, la préparation de la configuration et enfin l'entraînement du modèle. Le présentateur utilise une "carte d'étiquettes" pour identifier l'étiquette qu'il utilisera, "licence", puis crée un enregistrement tf, qui est le format requis par le modèle de détection d'objet. Le processus est décrit comme étant simple et un script pour générer l'enregistrement tf est fourni.

  • 00:45:00 Dans cette section, la vidéo explique comment préparer les données pour la formation avec TensorFlow et EasyOCR. Le script décrit ici convertit les données brutes, y compris les images et les annotations, dans un format d'enregistrement tf, mais il doit être mis à jour en raison du format légèrement différent des annotations dans l'ensemble de données Kaggle. La vidéo montre comment corriger les erreurs qui surviennent en raison de cet écart, y compris l'installation des modules manquants, la modification de l'index pour récupérer les métriques de boîte englobante correctes et la copie de la configuration du modèle pré-formé dans le dossier de formation.

  • 00: 50: 00 Dans cette section, l'orateur passe en revue les détails du pipeline de modèles pré-formés, qui contient différentes lignes de configurations qui doivent être mises à jour avant de former le modèle. L'orateur montre comment copier le fichier de configuration mis à jour qui garantit que les paramètres sont mis à jour et exécuter la commande de formation pour former le modèle. Ils mentionnent également l'importance d'exécuter la commande en externe pour voir correctement la progression et comment activer un environnement virtuel pour exécuter la commande. Enfin, ils expliquent comment résoudre une erreur standard pouvant survenir lors de l'installation du modèle.

  • 00: 55: 00 Dans cette section du cours, l'instructeur résout les erreurs pouvant survenir pendant la formation. Il montre comment résoudre des problèmes spécifiques tels qu'une erreur de valeur liée à un changement de taille de tableau numpy dot nd, une erreur de module introuvable pour cv2, une erreur de module introuvable pour les modules complémentaires tensorflow et une erreur de module introuvable pour gin. L'instructeur explique que ces erreurs ne sont pas rares et qu'il est essentiel d'installer les bibliothèques requises pour les résoudre. Une fois le modèle formé, l'instructeur montre comment lire les métriques de perte et comment trouver le point de contrôle du modèle formé le plus récent.

  • 01:00:00 Dans cette section du didacticiel vidéo sur la reconnaissance automatique des plaques d'immatriculation à l'aide de Tensorflow et EasyOCR, l'instructeur explique comment détecter les plaques d'immatriculation à partir d'images ou en temps réel à l'aide du même modèle. En changeant le nom du fichier image, le modèle peut détecter et classer avec précision différents types de plaques. Cette méthode s'avère beaucoup plus performante grâce à la détection d'objets que l'utilisation de techniques de vision par ordinateur traditionnelles, car les formats des plaques peuvent varier. Le modèle peut également détecter les plaques à partir d'un flux vidéo en direct ou en tenant un téléphone devant la plaque de la voiture. L'instructeur souligne que la méthode est efficace et constitue un bon début pour la construction d'un détecteur de plaque d'immatriculation. La prochaine étape consisterait à appliquer des composants OCR pour extraire des données significatives de l'image.

  • 01:05:00 Dans cette section, le didacticiel vidéo explique comment utiliser la bibliothèque open source EasyOCR pour détecter et extraire du texte d'une image afin d'identifier un numéro de plaque d'immatriculation. Le tutoriel note que bien qu'il existe des modèles OCR plus précis disponibles, EasyOCR est utilisé car il fonctionne sur PyTorch, ce qui nécessite un peu de place pour que le GPU puisse l'exécuter avec TensorFlow sans consommer toute la mémoire du GPU. Le didacticiel montre comment allouer des ressources GPU et limiter la consommation de mémoire pour TensorFlow afin de permettre à EasyOCR de fonctionner correctement.

  • 01:10:00 Dans cette section, l'orateur explique comment charger les chemins de fichiers et les étiquettes nécessaires pour la reconnaissance automatique des plaques d'immatriculation (ANPR) à l'aide de TensorFlow et EasyOCR, et comment installer EasyOCR et PyTorch avec l'accélération CUDA. Ils démontrent qu'après avoir chargé un exemple d'image et effectué l'ANPR, les numéros de plaque d'immatriculation et les scores de détection sont stockés dans une variable appelée "détections", qui sont ensuite utilisées pour appliquer l'OCR à l'aide d'EasyOCR. Un seuil de détection est fixé à 0,7, permettant uniquement aux détections avec des scores supérieurs à 0,7 d'être traitées plus avant.

  • 01:15:00 Dans cette section, l'instructeur explique comment extraire les partitions, les classes et les boîtes d'images qui dépassent le seuil de détection à l'aide de quelques lignes de code. Ils montrent comment parcourir chaque valeur dans le tableau des scores de détection et ne renvoient que les scores qui dépassent le seuil. Ils appliquent également des filtres aux boîtes et aux classes pour s'assurer qu'elles ont la bonne taille et le bon format pour la webcam. Enfin, ils saisissent la largeur et la hauteur de l'image pour recalculer les coordonnées de la boîte et appliquent un filtrage sur l'image pour déterminer la région d'intérêt.

  • 01:20:00 Dans cette section, la vidéo montre comment extraire la région d'intérêt de l'image et appliquer la reconnaissance optique de caractères (OCR) pour extraire les résultats de la plaque. Tout d'abord, les paramètres de largeur et de hauteur de l'image sont obtenus en utilisant image.shape. Pour extraire le retour sur investissement, parcourez chaque case dans la variable cases, qui représente les coordonnées de la détection, et filtrez la région d'intérêt. Enfin, l'OCR est appliqué au retour sur investissement à l'aide d'EasyOCR et les résultats sont imprimés sur la console. La vidéo guide le spectateur à travers le processus de configuration du lecteur EasyOCR, en passant par les paramètres de langue et en analysant l'image pour extraire les résultats de la plaque.

  • 01:25:00 Dans cette section, le présentateur explique comment extraire efficacement la plaque imprimée ou le texte de la plaque à l'aide de l'OCR (reconnaissance optique de caractères). Ils montrent une image d'exemple où il y a du texte supplémentaire en plus du numéro de plaque, ce qui peut confondre le lecteur OCR. Pour résoudre ce problème, le présentateur suggère de filtrer les résultats en fonction de la taille et des coordonnées. Ils montrent comment écrire une fonction pour effectuer ce filtrage et l'appliquer à l'image pour obtenir le texte approprié. Les résultats montrent que le lecteur OCR peut extraire avec précision le numéro de plaque, bien qu'il y ait encore place à l'amélioration avec le modèle OCR.

  • 01:30:00 Dans cette section, l'orateur introduit une nouvelle fonction appelée "filtrer le texte". Cette fonction prend trois arguments : la région, le résultat de l'OCR et le seuil de la région. La région représente l'image, le résultat OCR représente le texte extrait d'EasyOCR et le seuil de région est le seuil de taille pour détecter les régions de plaque d'immatriculation. La fonction parcourt les résultats de l'OCR, extrait la longueur et la largeur de chacun, les multiplie, puis les compare au seuil de région. S'il passe ce filtre, il est considéré comme du texte et sa région est stockée dans une variable appelée "plate". L'orateur explique également certaines portions de code qui calculent la taille de la région et illustrent le fonctionnement du filtre.

  • 01:35:00 Dans cette section, l'auteur montre comment filtrer efficacement le texte des images à l'aide du moteur OCR. L'algorithme filterText permettra à l'utilisateur de spécifier un seuil pour la région, qui filtrera uniquement les blocs de texte qui atteignent ou dépassent ce seuil. Ils utilisent cette fonction pour extraire les composants dont ils ont besoin plutôt que de tout récupérer de la plaque. Ils ont également créé une fonction OCR_it qui combine le filtre OCR et les composants OCR, et elle peut être appliquée à n'importe quelle image lors du passage de l'image et des détections avec les seuils correspondants.

  • 01:40:00 Dans cette section, l'instructeur teste sa méthode de reconnaissance optique de caractères (OCR) en faisant passer une image par sa fonction "ocr_it" avec des seuils de détection et de région spécifiés. Le procédé est capable d'extraire avec précision la plaque d'immatriculation et sa région dans l'image. Ils démontrent ensuite l'application de la méthode OCR en temps réel pour détecter les plaques d'immatriculation à l'aide d'un bloc try-except et d'un nouveau code qui appelle la fonction OCR pour chaque détection valide. L'instructeur teste la détection en temps réel sur son téléphone et montre qu'il détecte et extrait avec précision le texte de la plaque d'immatriculation, bien que les résultats ne soient pas parfaits et nécessitent quelques ajustements.

  • 01:45:00 Dans cette section de la vidéo, l'instructeur explique comment enregistrer les résultats de sortie du système OCR qu'il a développé. Ils créent une nouvelle fonction appelée "save_results" qui prend le texte, la région, le nom du fichier et le dossier comme paramètres d'entrée. Ils utilisent ensuite la bibliothèque uuid pour générer un nom de fichier unique et la bibliothèque csv pour enregistrer les résultats de sortie dans un fichier csv. Ils utilisent également la bibliothèque cv2 pour écrire l'image dans le dossier sélectionné. Enfin, ils concluent le code et le testent.

  • 01:50:00 Dans cette section de la vidéo, l'instructeur montre comment configurer un fichier CSV et un chemin de dossier pour écrire tous les résultats ou régions d'image. Ils créent un nouveau dossier appelé detection_images, où tous les résultats d'image seront écrits. L'instructeur montre comment transmettre le nom du fichier CSV et le chemin du dossier, puis tester le code pour enregistrer les résultats. Ils ont mis en place une méthode d'enregistrement des résultats pour écrire les résultats dans le dossier créé, qui comprend le nom de l'image ainsi que la plaque d'immatriculation. L'instructeur montre ensuite comment exécuter le code en temps réel pour enregistrer les résultats pendant que les détections se produisent. Enfin, ils testent le code, ce qui permet de produire avec précision les images tout en enregistrant les résultats en temps réel.

  • 01:55:00 Dans cette section, l'orateur informe les téléspectateurs que la fonction OCR intégrée et l'algorithme de filtrage appliqué en temps réel sont à leur disposition. Il encourage les téléspectateurs à demander de l'aide s'ils rencontrent des difficultés et mentionne que le code sera disponible sur GitHub pour qu'ils puissent l'utiliser. Enfin, il remercie les téléspectateurs de s'être connectés, leur demande d'aimer, de s'abonner et de commenter et de se déconnecter.
GitHub - nicknochnack/RealTimeAutomaticNumberPlateRecognition
GitHub - nicknochnack/RealTimeAutomaticNumberPlateRecognition
  • nicknochnack
  • github.com
Contribute to nicknochnack/RealTimeAutomaticNumberPlateRecognition development by creating an account on GitHub.
 

Apprentissage par renforcement en 3 heures | Cours complet utilisant Python

Code : https://github.com/nicknochnack/ReinforcementLearningCourse



Apprentissage par renforcement en 3 heures | Cours complet utilisant Python

00:00:00 - 01:00:00 Le cours vidéo "Apprentissage par renforcement en 3 heures" couvre une gamme de sujets dans l'apprentissage par renforcement, y compris la mise en œuvre pratique et la réduction du fossé théorie-pratique. Le cours couvre tout, de la configuration de l'environnement RL à la création d'environnements personnalisés, en mettant l'accent sur la formation des agents d'apprentissage par renforcement et leur évaluation à l'aide de différents algorithmes et architectures. Les applications RL populaires telles que la robotique et les jeux sont discutées, ainsi que les limites de RL telles que son hypothèse que les environnements sont markoviens et le potentiel d'entraînement instable. Le cours utilise Stable Baselines, une bibliothèque RL open source et OpenAI Gym pour créer des environnements simulés. L'instructeur explique les différents types d'espaces utilisés pour représenter les actions et les valeurs que les agents peuvent prendre dans un environnement, ainsi que les différents algorithmes RL tels que A2C et PPO. L'importance de comprendre l'environnement avant de mettre en œuvre des algorithmes est soulignée, et les utilisateurs sont guidés dans la configuration de la plate-forme de calcul pour l'apprentissage par renforcement, le choix des algorithmes RL appropriés, ainsi que la formation et le test du modèle.

01:00:00
- 02:00:00 Cette vidéo YouTube propose un cours de trois heures sur l'apprentissage par renforcement à l'aide de Python. L'instructeur explique les composants de base de l'apprentissage par renforcement, y compris l'agent, l'environnement, l'action et la récompense. La section explique comment définir un environnement, former un modèle à l'aide de l'apprentissage par renforcement et afficher les journaux de formation à l'aide de TensorBoard pour surveiller le processus de formation. Le conférencier couvre également d'autres sujets, tels que la sauvegarde et le rechargement d'un modèle entraîné, le test et l'amélioration des performances du modèle, la définition d'une architecture de réseau pour un acteur personnalisé et une fonction de valeur dans un réseau de neurones, et l'utilisation de l'apprentissage par renforcement pour jouer au jeu Atari Breakout. De plus, le cours comprend trois projets que les apprenants construiront à l'aide de techniques d'apprentissage par renforcement, notamment le jeu Breakout dans Atari, la construction d'une voiture de course pour la conduite autonome et la création d'environnements personnalisés à l'aide des espaces OpenAI Gym.

02:00:00 - 03:00:00 Cette vidéo YouTube intitulée "Apprentissage par renforcement en 3 heures | Cours complet utilisant Python" couvre divers sujets liés à l'apprentissage par renforcement. L'instructeur montre comment former un agent d'apprentissage par renforcement pour les jeux Atari et la conduite autonome en utilisant l'environnement des voitures de course. Ils introduisent également diverses dépendances de gym OpenAI, des aides et des lignes de base stables, ainsi que différents types d'espaces pour l'apprentissage par renforcement. De plus, la vidéo explique comment créer un environnement personnalisé pour l'apprentissage par renforcement, définir l'état de l'environnement, ses espaces d'observation et d'action, tester et former le modèle, et enregistrer le modèle formé après l'apprentissage. L'instructeur discute également de l'importance de former des modèles sur de plus longues périodes pour de meilleures performances et encourage les téléspectateurs à tendre la main s'ils rencontrent des difficultés.

  • 00:00:00 Dans cette section de la vidéo, le présentateur présente le cours d'apprentissage par renforcement et décrit les différents sujets qui seront abordés tout au long du cours. Il explique que le cours est conçu pour combler le fossé entre la théorie et la mise en œuvre pratique, et couvre tout, de la configuration de l'environnement RL à la création d'environnements personnalisés. Le présentateur donne un aperçu de haut niveau de l'apprentissage par renforcement, de ses applications et de certaines de ses limites. Le cours fournira une expérience pratique de la formation d'agents d'apprentissage par renforcement et de leur test et évaluation à l'aide de différents algorithmes et architectures, ainsi que de trois projets différents axés sur l'environnement de discussion, l'environnement de conduite autonome et les environnements personnalisés.

  • 00:05:00 Dans cette section de la vidéo sur "L'apprentissage par renforcement en 3 heures", l'instructeur explique les concepts fondamentaux de l'apprentissage par renforcement. Un agent d'apprentissage par renforcement apprend en fonction des récompenses qu'il obtient de l'environnement en prenant différentes actions. L'agent observe l'environnement pour maximiser ses récompenses au fil du temps en prenant certaines décisions. L'instructeur aborde également certaines applications pratiques de l'apprentissage par renforcement, telles que la conduite autonome, le négoce de titres et la recherche d'architecture de réseau neuronal.

  • 00:10:00 Dans cette section, la vidéo aborde certaines des applications populaires de l'apprentissage par renforcement, notamment la robotique, où des environnements simulés peuvent être utilisés pour entraîner des robots à effectuer des tâches spécifiques. La vidéo mentionne également le jeu comme une autre application populaire où la fonction de récompense peut différer à chaque fois, ce qui en fait un environnement approprié pour l'apprentissage par renforcement. Les limites de l'apprentissage par renforcement sont également discutées, y compris l'hypothèse que l'environnement est markovien et le fait que la formation peut être chronophage et instable. La configuration du modèle d'apprentissage par renforcement est discutée, ce qui inclut l'installation de la bibliothèque de lignes de base stables d'OpenAI et l'utilisation de ses guides et de sa documentation utiles.

  • 00:15:00 Dans cette section, l'instructeur présente le cours et décrit les 10 étapes différentes qui seront couvertes. La première étape consiste à importer et à charger les dépendances nécessaires, y compris des lignes de base stables, une bibliothèque open source pour l'apprentissage par renforcement. L'instructeur explique les différents algorithmes disponibles dans la bibliothèque et les avantages de l'utilisation de PPO (Optimal Policy Optimization). Les dépendances incluent également le système d'exploitation, pour les fonctionnalités du système d'exploitation, et la salle de sport, pour créer et travailler avec des environnements. Dans l'ensemble, le processus est simple et ne nécessite que quelques lignes de code pour démarrer avec des lignes de base stables.

  • 00:20:00 Dans cette section, l'instructeur discute des dépendances et des environnements requis pour l'apprentissage par renforcement. Ils introduisent Stable Baselines, qui permet un apprentissage automatique plus rapide grâce à la vectorisation des environnements, et le wrapper Dummy Vec Env. Ils expliquent également comment OpenAI Gym peut être utilisé pour créer des environnements simulés, ce qui peut réduire les coûts et permettre une production de modèles plus rapide. Ils fournissent des exemples d'environnements réels, comme un robot, ainsi que des environnements simulés, comme OpenAI Gym, qui a beaucoup de documentation et de support.

  • 00:25:00 Dans cette section de la vidéo, l'instructeur discute de la norme de création d'environnements d'apprentissage par renforcement, qui est OpenAI Gym. Il explique qu'OpenAI Gym fournit des environnements pré-construits, y compris ceux basés sur des robots réels tels que Fetch Robot et Shadow Hand Robot. Il explique en outre les différents types d'espaces pris en charge par OpenAI Gym, notamment box, discret, tuple, dict, multi-binaire et multi-discret. Il note que ces espaces sont utilisés pour représenter les différents types de valeurs ou d'actions que les agents peuvent entreprendre dans l'environnement. L'instructeur présente ensuite l'environnement de contrôle classique, en particulier le problème CartPole, comme exemple qu'il utilisera pour former un agent d'apprentissage par renforcement. Le but est d'équilibrer une poutre en la déplaçant vers la gauche ou vers la droite en utilisant deux actions.

  • 00:30:00 Dans cette section, l'instructeur explique comment charger et tester un environnement à l'aide d'OpenAI Gym. Ils commencent par instancier l'environnement CartPole-v0 à l'aide de deux lignes de code. Ensuite, ils montrent comment tester l'environnement en parcourant plusieurs épisodes et en utilisant env.reset() pour obtenir l'ensemble initial d'observations. Ces observations seront ensuite transmises à un agent d'apprentissage par renforcement afin de déterminer la meilleure action pour maximiser la récompense. L'instructeur note l'importance de comprendre l'environnement avant de mettre en œuvre des algorithmes.

  • 00:35:00 Dans cette section, l'instructeur explique le code utilisé pour échantillonner un environnement dans l'apprentissage par renforcement. Le code définit un nombre maximal d'étapes pour l'environnement, configure un compteur de score et génère une action aléatoire basée sur l'espace d'action défini par l'environnement. Les observations renvoyées par l'environnement après chaque action sont accompagnées d'une récompense et d'une valeur indiquant si l'épisode est terminé. Les résultats sont imprimés et l'environnement est fermé après le test. L'instructeur explique également le concept d'un espace d'observation et montre comment il peut être échantillonné.

  • 00:40:00 Dans cette section, l'instructeur explique les deux parties de l'environnement, l'espace d'action et l'espace d'observation, et comment elles sont représentées dans la documentation OpenAI Gym. L'espace d'observation se compose de quatre valeurs représentant la position du chariot, la vitesse, l'angle du pôle et les vitesses angulaires du pôle. D'autre part, l'espace d'action a deux actions possibles, zéro ou un, où zéro pousse le chariot vers la gauche et un pousse le chariot vers la droite. La section met également en évidence les différents types d'algorithmes d'apprentissage par renforcement, basés sur un modèle et sans modèle, et leurs différences. L'instructeur se concentre sur l'apprentissage par renforcement sans modèle et approfondit les algorithmes A2C et PPO, qui seront utilisés dans la phase de formation.

  • 00:45:00 Dans cette section de la vidéo, l'instructeur explique comment choisir l'algorithme d'apprentissage par renforcement approprié en fonction de l'espace d'action de l'environnement utilisé. Il poursuit en expliquant les différents types d'algorithmes disponibles dans Stable Baselines, tels que A2C, DDPG, DQN, HER, PPO, SAC et TD3, et avec quels espaces d'action ils fonctionnent le mieux. L'instructeur discute également des métriques de formation qui doivent être prises en compte pendant la formation, telles que les métriques d'évaluation, les métriques de temps, les métriques de perte et d'autres métriques. Il rappelle aux utilisateurs que les lignes de base stables peuvent être installées avec ou sans accélération GPU et fournit des instructions pour installer PyTorch si l'accélération GPU est souhaitée.

  • 00:50:00 Dans cette section, l'instructeur explique comment configurer la plate-forme de calcul pour l'apprentissage par renforcement, ce qui est crucial pour ceux qui souhaitent tirer parti de l'accélération GPU. CUDA et cuDNN ne sont pris en charge que sur les GPU NVIDIA, les utilisateurs doivent donc s'assurer qu'ils disposent d'un GPU NVIDIA pour utiliser CUDA afin de tirer parti de l'accélération GPU. D'autre part, les GPU AMD sont pris en charge par RockM, un package bêta uniquement disponible sur Linux. L'instructeur souligne également que l'apprentissage en profondeur traditionnel peut voir plus d'amélioration des performances grâce à l'utilisation d'un GPU que l'apprentissage par renforcement. Enfin, l'instructeur définit le chemin du journal et instancie l'algorithme et l'agent.

  • 00:55:00 Dans cette section, l'instructeur montre comment encapsuler un environnement non vectorisé dans un environnement vectorisé factice à l'aide d'une fonction lambda. Ensuite, ils définissent le modèle, qui est l'agent qui sera formé, en tant que PPO et passent par la politique, l'environnement, les commentaires et le chemin d'accès au journal du Tensorboard en tant qu'arguments. L'instructeur poursuit en expliquant les différents hyperparamètres qui peuvent être transmis à l'algorithme PPO. Enfin, ils montrent comment entraîner le modèle à l'aide de la fonction model.learn et en passant par le nombre de pas de temps pour l'entraîner, qui dans cet exemple est fixé à 20 000. Une fois le modèle formé, l'instructeur le teste et vérifie les métriques de formation.


Partie 2

  • 01:00:00 Dans cette section de la vidéo, l'instructeur montre comment enregistrer et recharger un modèle entraîné. Le modèle est enregistré à l'aide de la fonction `model.save()` et un chemin est défini pour localiser le modèle enregistré. L'instructeur montre ensuite comment supprimer le modèle enregistré et le recharger à l'aide de la fonction `ppo.load()`. L'étape suivante consiste à tester le modèle formé pour voir comment il fonctionne. L'instructeur explique que les métriques de déploiement dépendent de l'algorithme utilisé pour la formation et montre que l'algorithme "A2C" fournit ces métriques pendant la formation, alors que l'algorithme "PPO" nécessite une commande explicite pour générer ces métriques.

  • 01:05:00 Dans cette section, la vidéo explique comment utiliser la méthode assess_policy pour tester les performances du modèle et déterminer si le modèle PPO est considéré comme "résolu" dans ce cas particulier. La méthode assess_policy est un moyen de tester les performances d'un modèle, et le modèle est considéré comme résolu s'il obtient une moyenne de 200 ou plus. La méthode est passée à travers le modèle, l'environnement, le nombre d'épisodes à tester et si le rendu est requis ou non. La récompense moyenne et l'écart-type de cette récompense sont les valeurs que vous obtenez d'evaluate_policy, et la fermeture de l'environnement se fait à l'aide de emv.close. Enfin, la vidéo explique comment déployer le modèle dans une fonction encapsulée.

  • 01:10:00 Dans cette section, l'instructeur montre comment utiliser les observations de l'environnement pour prédire la meilleure action à l'aide de l'agent, afin de maximiser les récompenses. Le bloc de code montre comment apporter des modifications clés pour utiliser model.predict au lieu de env.actionspace.sample pour effectuer des actions à l'aide du modèle. L'instructeur montre que l'agent réussit mieux que les étapes aléatoires et équilibre la perche. Le code montre également les observations transmises à la fonction model.predict, avec deux valeurs renvoyées, l'action du modèle et l'état suivant. La première valeur est utilisée ici pour déterminer la meilleure action pour l'agent.

  • 01:15:00 Dans cette section, l'instructeur explique les composants de base de l'apprentissage par renforcement : l'agent, l'environnement, l'action et la récompense. Il montre comment définir un environnement et former un modèle en utilisant l'apprentissage par renforcement pour accumuler une valeur de un à chaque fois en gardant le poteau en position verticale et en ne tombant pas. L'instructeur montre également comment afficher les journaux de formation à l'aide de TensorBoard pour surveiller le processus de formation.

  • 01:20:00 Dans cette section de la vidéo, l'instructeur explique comment utiliser TensorBoard dans un notebook Jupiter pour afficher les métriques d'entraînement d'un modèle d'apprentissage par renforcement. Il montre comment exécuter la commande TensorBoard à l'aide d'une commande magique et montre comment spécifier le chemin du journal de formation. L'instructeur montre également comment afficher les métriques de formation, telles que les images par seconde, la perte d'entropie, le taux d'apprentissage et la perte de gradient de politique, dans TensorBoard. Il souligne que la récompense moyenne est la mesure la plus importante à surveiller lors du réglage des performances du modèle. Il conclut en invitant les réactions et les commentaires des téléspectateurs.

  • 01:25:00 Dans cette section, la vidéo traite de deux mesures clés pour déterminer les performances d'un modèle d'apprentissage par renforcement : les mesures de récompense et la durée moyenne des épisodes. La vidéo fournit également trois stratégies pour améliorer les performances du modèle s'il ne fonctionne pas bien, y compris la formation pendant une période plus longue, le réglage des hyperparamètres et l'exploration de différents algorithmes. La section se penche ensuite sur les rappels, les algorithmes alternatifs et les architectures, en expliquant spécifiquement comment configurer un rappel pour arrêter la formation une fois qu'un seuil de récompense est atteint et explorer différentes architectures et algorithmes de réseau neuronal. La vidéo souligne également l'importance d'utiliser des rappels pour les grands modèles qui nécessitent un temps de formation plus long.

  • 01:30:00 Dans cette section, l'instructeur explique comment utiliser les rappels dans l'apprentissage par renforcement pour une formation plus flexible et efficace. Deux callbacks sont utilisés dans l'exemple : le callback stop et le callback eval. Le rappel stop spécifie la récompense moyenne après laquelle l'entraînement doit s'arrêter, tandis que le rappel eval évalue le meilleur nouveau modèle et vérifie s'il a dépassé le seuil de récompense. L'instructeur montre également comment modifier la stratégie en spécifiant une nouvelle architecture de réseau neuronal. Dans l'ensemble, les rappels offrent un meilleur contrôle sur les modèles d'apprentissage par renforcement, permettant une formation plus personnalisée et plus efficace.

  • 01:35:00 Dans cette section, l'orateur discute du processus de spécification d'une architecture de réseau pour un acteur personnalisé et une fonction de valeur dans un réseau de neurones. Cela peut être fait simplement en modifiant le nombre d'unités et de couches et en le transmettant au modèle. L'orateur souligne également que les extracteurs de caractéristiques personnalisés peuvent être définis et montre comment utiliser un algorithme alternatif tel que DQN au lieu de PPO, et met en évidence d'autres algorithmes disponibles dans Stable Baselines. L'orateur conclut en présentant le modèle DQN entraîné.

  • 01:40:00 Dans cette section, l'instructeur discute des projets que les apprenants construiront en utilisant des techniques d'apprentissage par renforcement. Ils commenceront par Project One, qui est le jeu Breakout d'Atari. Ensuite, ils s'attaqueront également au projet 2, où ils utiliseront l'apprentissage par renforcement pour construire une voiture de course simulant la conduite autonome. Enfin, ils travailleront sur le projet 3, qui consiste à créer des environnements personnalisés à l'aide des espaces OpenAI Gym. L'instructeur explique également comment l'importation des bibliothèques et des dépendances nécessaires pour les projets est similaire à celle du cours principal, et ils n'auront qu'à utiliser différents algorithmes en fonction du projet.

  • 01:45:00 Dans cette section, l'instructeur vidéo explique comment configurer l'environnement Atari pour l'apprentissage par renforcement en Python. En raison de changements récents, les utilisateurs doivent télécharger des fichiers bruts depuis atarimania.com et les extraire dans un dossier afin d'utiliser l'environnement. Après avoir installé les packages et les dépendances nécessaires, les utilisateurs peuvent tester l'environnement à l'aide des fonctions "emv.reset" et "emv.action_space". L'espace d'observation est une boîte représentant une image aux dimensions 210x160x3. L'instructeur montre également comment tester un modèle dans l'environnement.

  • 01:50:00 Dans cette section, l'instructeur montre le code pour jouer à Breakout en utilisant des actions aléatoires et souligne que la formation du modèle peut prendre beaucoup de temps. Pour accélérer la formation, l'instructeur vectorise l'environnement et forme quatre environnements différents en même temps. L'environnement utilisé est l'environnement basé sur l'image, par opposition à la version RAM de Breakout, car la politique CNN sera utilisée. Le code de configuration du modèle est affiché, y compris la spécification du chemin du journal et de l'algorithme A2C avec la politique CNN.

  • 01:55:00 Dans cette section, l'instructeur vidéo utilise l'apprentissage par renforcement pour entraîner un modèle à jouer au jeu Atari "Breakout". Le modèle utilise une politique de réseau neuronal convolutionnel (CNN), qui est plus rapide à former qu'une politique de perceptron multicouche. L'environnement est défini à l'aide de la fonction make_atari d'OpenAI Gym et la vectorisation est utilisée pour accélérer le processus d'entraînement. Le modèle est formé pour 100 000 étapes, et après avoir enregistré et rechargé le modèle, il est évalué à l'aide de la méthode d'évaluation de la politique. Le modèle final atteint une récompense moyenne par épisode de 6,1 avec un écart type de 1,9, une amélioration significative par rapport à un agent aléatoire. L'instructeur fournit également des informations sur un modèle pré-formé qui a été formé pour 300 000 étapes et comment le charger et le tester.


Partie 3

  • 02:00:00 Dans cette section, l'instructeur explique comment gérer les problèmes de blocage lors de l'utilisation de l'environnement, en particulier d'Atari. Si l'environnement se fige, le notebook doit être redémarré et le noyau doit être redémarré après avoir enregistré le modèle. L'instructeur montre ensuite comment former un agent d'apprentissage par renforcement pour l'évasion, en parcourant le processus d'importation des dépendances, en installant des ROM Atari, en vectorisant l'environnement pour former sur quatre environnements Atari simultanément, en formant l'agent et enfin en évaluant et en enregistrant le modèle. L'instructeur montre également l'impact de la formation du modèle plus longtemps et met les modèles formés à disposition dans le référentiel Github pour que les apprenants puissent les essayer par eux-mêmes.

  • 02:05:00 Dans cette section de la vidéo sur l'apprentissage par renforcement en trois heures, l'instructeur commence par montrer les résultats du projet 1, qui consistait à entraîner un modèle à jouer à un jeu en utilisant l'apprentissage par renforcement. Le modèle a obtenu des résultats nettement meilleurs que les modèles précédents, avec une récompense moyenne sur 50 épisodes de 22,22 et un écart type de 9,1. L'instructeur présente ensuite le projet 2, qui consiste à utiliser l'apprentissage par renforcement pour la conduite autonome dans l'environnement d'une voiture de course. Pour configurer l'environnement, l'instructeur explique que swig doit être installé et que deux nouvelles dépendances, box 2d et piglet, doivent être installées. L'instructeur passe ensuite par le processus de test de l'environnement et d'importation des dépendances nécessaires.

  • 02:10:00 Dans cette section, la vidéo traite de l'espace d'observation et d'action de l'environnement de course automobile pour l'apprentissage par renforcement. L'espace d'observation est une image 96 par 96 par 3 avec des valeurs comprises entre 0 et 255, tandis que l'espace d'action est compris entre moins un et un pour trois valeurs différentes. La fonction de récompense est moins 0,1 pour chaque image et plus 1000 divisé par n pour chaque tuile de piste visitée. Le jeu est considéré comme résolu lorsque l'agent peut constamment obtenir 900 points ou plus, ce qui peut prendre un certain temps avec la formation. La vidéo continue ensuite à former un modèle à l'aide de l'algorithme PPO et montre comment tester l'environnement de course à l'aide du modèle formé.

  • 02:15:00 Dans cette section, l'instructeur configure l'environnement de la voiture autonome à l'aide d'OpenAI Gym et l'enveloppe à l'intérieur d'un mannequin Vectorize Environment Wrapper. Ensuite, l'agent et le modèle sont spécifiés à l'aide de l'algorithme PPO, et le modèle est formé pour 100 000 étapes. Le modèle enregistré est chargé et évalué dans l'environnement, et malgré le manque de traction de la voiture à haute puissance, il n'avance pas mais tourne et fait des beignets. Enfin, l'environnement est fermé et l'instructeur charge un modèle entraîné pour 438 000 étapes à tester.

  • 02:20:00 Dans cette section, l'instructeur charge un modèle de voiture autonome qui a été formé pour 438 000 pas et le teste sur la piste. Bien qu'il soit plus lent, il suit la piste et obtient un score beaucoup plus élevé que le modèle précédent entraîné pour 100 000 pas. L'instructeur explique que la formation d'agents d'apprentissage par renforcement pendant une période plus longue peut produire de bien meilleurs modèles, et idéalement, ce modèle aurait dû être formé pour 1 à 2 millions d'étapes pour fonctionner de manière optimale. Il montre comment tester le modèle à l'aide d'un extrait de code du didacticiel principal, qui montre que, même lorsqu'il est formé uniquement sur des images, le modèle peut naviguer avec succès sur la piste. En fin de compte, l'instructeur a formé ce modèle pour deux millions d'étapes supplémentaires, améliorant ses performances et atteignant une estimation de récompense d'environ 700.

  • 02:25:00 Dans cette section, l'instructeur charge et exécute un modèle qui fonctionne nettement mieux que les modèles précédents qu'il a entraînés, malgré des rotations occasionnelles dans les virages. Il montre le score d'évaluation du modèle, qui a atteint jusqu'à 800 points, une amélioration significative par rapport aux modèles précédents. Il note que ce modèle a été formé pendant une durée plus longue et avait un écart-type élevé. L'instructeur présente ensuite le dernier projet, qui consiste à utiliser des lignes de base stables pour l'apprentissage par renforcement dans des environnements personnalisés. Il importe les dépendances nécessaires et encourage les téléspectateurs à tendre la main s'ils rencontrent des difficultés.

  • 02:30:00 Dans cette section de la vidéo, l'instructeur passe en revue les différentes dépendances du gymnase ou les dépendances du gymnase OpenAI, les aides et les éléments de base stables qui seront utilisés dans le cours d'apprentissage par renforcement. Ils importent gym, qui est l'importation standard, la classe d'environnement gym d'env, et les différents types d'espaces tels que discret, box, dict, tuple, multi-binaire, multi-discret. L'instructeur explique comment utiliser chacun de ces espaces et comment ils peuvent être utilisés à des fins différentes. L'instructeur passe également en revue les différents assistants qui ont été importés, tels que numpy, random et os, ainsi que les éléments de base stables, notamment ppo, common.vec_env, dummy_vec_nv et la fonction assess_policy.

  • 02:35:00 Dans cette section de la vidéo, le présentateur discute des différents types d'espaces disponibles dans OpenAI Gym pour l'apprentissage par renforcement. Ces espaces incluent discret, boîte, tuple, dict, multi-binaire et multi-discret. Le présentateur fournit des exemples et des explications pour chacun de ces espaces. La vidéo aborde ensuite la création d'un environnement simulé pour former un agent à réguler la température d'une douche. Le but ultime est d'atteindre une température comprise entre 37 et 39 degrés, mais l'agent ne le sait pas a priori et doit apprendre par essais et erreurs.

  • 02:40:00 Dans cette section, l'instructeur construit une coque pour un environnement de douche en mettant en œuvre les quatre fonctions clés. Ces fonctions sont init, step, render et reset. La fonction init initialise l'environnement en définissant l'espace d'action, l'espace d'observation et l'état initial. La fonction step effectue une action et l'applique à l'environnement. La fonction de rendu affiche l'environnement. La fonction de réinitialisation réinitialise l'environnement à son état initial. L'instructeur définit également une durée d'épisode de 60 secondes pour l'environnement.

  • 02:45:00 Dans cette section, l'instructeur définit la fonction d'étape pour l'environnement de douche, qui contient six blocs de code. Le premier bloc applique l'impact de l'action sur l'état, avec zéro, un et deux comme trois actions possibles. Zéro diminue la température d'un degré, un laisse la température inchangée et deux l'augmente d'un degré. Le deuxième bloc diminue le temps de douche d'une seconde. Le troisième bloc définit la récompense, avec une récompense de un si la température est comprise entre 37 et 39 degrés et de -1 si elle est en dehors de cette plage. Le quatrième bloc vérifie si la douche est terminée et définit done sur vrai si le temps de douche est inférieur ou égal à zéro. Le cinquième bloc crée un dictionnaire d'informations vide et le dernier bloc renvoie l'état, la récompense, si la douche est terminée et le dictionnaire. La fonction de réinitialisation réinitialise la température initiale à sa valeur par défaut et réinitialise le temps de douche à 60 secondes.

  • 02:50:00 Dans cette section, l'instructeur explique comment créer un environnement personnalisé pour l'apprentissage par renforcement à l'aide de Python. Il montre comment définir l'état de l'environnement et ses espaces d'observation et d'action. L'instructeur montre également comment tester et former le modèle à l'aide de l'environnement défini, et comment enregistrer le modèle formé après l'apprentissage. Il mentionne que les environnements de jeu prendront plus de temps à former par rapport aux environnements simples, et encourage à garder cela à l'esprit pour la planification des projets et l'engagement envers les clients.

  • 02:55:00 Dans cette section, l'instructeur montre comment tester et enregistrer le modèle entraîné. Ils utilisent la méthode "évaluer la politique" pour tester les performances du modèle, puis enregistrent le modèle à l'aide de la méthode "model.save". En outre, ils fournissent un bref résumé du cours, qui couvre une gamme de sujets allant de la configuration de l'environnement à l'aide de lignes de base stables à la formation de modèles avec différents algorithmes, notamment PPO, A2C et DQN. Ils discutent également de la création d'environnements personnalisés et de projets de construction, tels que la formation d'un modèle pour jouer à Breakout ou faire la course avec une voiture sur une piste.

  • 03:00:00 Dans cette section, l'instructeur recommande des ressources supplémentaires pour un apprentissage plus approfondi, y compris le cours d'apprentissage par renforcement de David Silva, un livre intitulé Apprentissage par renforcement : une introduction par Richard Sutton et Andrew Bartos, ainsi que l'exploration du réglage des hyperparamètres, la création d'environnements personnalisés , et la mise en œuvre de solutions de bout en bout telles que la construction d'un robot à poteau de chariot et sa formation dans un environnement simulé avant de l'implémenter dans un environnement réel à l'aide d'un Raspberry Pi. L'instructeur encourage les commentaires et les questions des téléspectateurs et les remercie d'être à l'écoute.
GitHub - nicknochnack/ReinforcementLearningCourse
GitHub - nicknochnack/ReinforcementLearningCourse
  • nicknochnack
  • github.com
Contribute to nicknochnack/ReinforcementLearningCourse development by creating an account on GitHub.
 

Détection de la langue des signes à l'aide de ACTION RECOGNITION avec Python | Modèle d'apprentissage en profondeur LSTM

Code : https://github.com/nicknochnack/ActionDetectionforSignLanguage



Détection de la langue des signes à l'aide de ACTION RECOGNITION avec Python | Modèle d'apprentissage en profondeur LSTM

Dans cette vidéo YouTube intitulée "Sign Language Detection using ACTION RECOGNITION with Python | LSTM Deep Learning Model", le présentateur explique comment créer un flux de détection de la langue des signes en temps réel à l'aide de la détection d'action et de modèles clés. Le présentateur utilise OpenCV et MediaPipe Holistic pour extraire les points clés des mains, du visage et du corps, puis TensorFlow et Keras pour créer un modèle LSTM qui prédit l'action démontrée dans une séquence d'images. Le présentateur passe par le processus d'accès et d'extraction des points clés de la webcam, configure une boucle pour accéder à la webcam et facilite la détection de la langue des signes en appliquant les points de repère à la dernière image capturée à partir de la webcam. Ils montrent également comment modifier le code pour gérer les points clés manquants et ajouter la gestion des erreurs au modèle de pose et à la détection des points de repère du visage. Enfin, le présentateur explique la fonction d'extraction de points clés pour la détection de la langue des signes à l'aide de la reconnaissance d'action avec Python.

La vidéo explique en détail comment créer un modèle de détection de la langue des signes à l'aide de la reconnaissance d'action avec Python. Pour collecter les données, le présentateur crée des dossiers pour chaque action et séquence et modifie la boucle MediaPipe pour collecter 30 valeurs de points clés par vidéo pour chaque action. Les données sont prétraitées en créant des étiquettes et des fonctionnalités pour le modèle d'apprentissage en profondeur LSTM, et le modèle est formé à l'aide de TensorFlow et Keras. Le modèle formé est évalué à l'aide d'une matrice de confusion multi-étiquettes et d'une fonction de score de précision. Enfin, la détection en temps réel est établie en créant de nouvelles variables pour la détection, en concaténant les trames et en appliquant une logique de prédiction, avec une variable de seuil implémentée pour rendre les résultats supérieurs à une certaine métrique de confiance.

Le didacticiel vidéo montre comment utiliser Python et un modèle LSTM Deep Learning pour la détection de la langue des signes à l'aide de la reconnaissance d'action. L'orateur a parcouru la logique de prédiction et a expliqué le code, le rendant facile à comprendre. Ils ont également montré aux téléspectateurs comment ajuster le code en utilisant la méthode d'ajout, en augmentant le seuil de détection et en ajoutant une visualisation de probabilité pour rendre la détection visuellement convaincante. L'orateur a également expliqué comment vérifier si le résultat est au-dessus du seuil, comment manipuler les probabilités et comment étendre et modifier le projet en ajoutant des actions ou des visualisations supplémentaires. Enfin, le conférencier a présenté la logique supplémentaire du modèle, qui minimise les fausses détections et améliore la précision du modèle, ainsi qu'une invitation à soutenir la vidéo et la chaîne.

  • 00:00:00 Dans cette section de la vidéo, le créateur explique son objectif de produire un flux de détection de la langue des signes en temps réel à l'aide de la détection d'action et de modèles clés. Ils utiliseront MediaPipe Holistic pour extraire les points clés des mains, du visage et du corps, puis utiliseront TensorFlow et Keras pour créer un modèle LSTM qui prédit l'action démontrée dans une séquence d'images. Le processus comprend la collecte de données sur les points clés, la formation d'un réseau de neurones, l'évaluation de la précision et le test du modèle en temps réel à l'aide d'OpenCV et d'une webcam. Le créateur décrit 11 étapes pour réaliser ce processus et commence par installer et importer des dépendances.

  • 00:05:00 Dans cette section, le présentateur discute des différentes dépendances qui seront utilisées dans le projet, notamment OpenCV, MediaPipe, scikit-learn, NumPy, Matplotlib et TensorFlow. Après avoir importé ces dépendances, le présentateur passe par le processus d'accès et d'extraction des points clés de la webcam à l'aide d'OpenCV et de MediaPipe Holistic. Le présentateur configure ensuite une boucle pour accéder à la webcam et rendre plusieurs images à l'écran, permettant de tester le projet en temps réel. Cette boucle sera utilisée plusieurs fois tout au long du projet, y compris lors de l'extraction des images et des tests du projet. Tout le code utilisé dans le projet sera mis à disposition sur Github, y compris les poids formés finaux.

  • 00:10:00 Dans cette section de la vidéo, le présentateur explique comment accéder à la webcam à l'aide d'OpenCV et commencer à parcourir toutes les images. Le présentateur utilise la fonction "capture vidéo" pour lire le flux de la webcam et initie une boucle qui lira, affichera et attendra qu'une pression sur une touche sorte de la boucle. Le présentateur explique également comment rompre la boucle avec élégance et comment résoudre les problèmes de numéro de périphérique si la webcam n'apparaît pas. Enfin, le présentateur présente MediaPipe Holistic et MediaPipe Drawing Utilities, deux modules Python utilisés pour télécharger et exploiter le modèle holistique pour la détection de pose et dessiner les repères de pose sur une image.

  • 00:15:00 Dans cette section de la transcription, l'orateur configure une fonction pour faciliter la détection de la langue des signes. La fonction prend en compte une image et un modèle holistique de canal multimédia et passe par une série d'étapes, y compris la conversion des couleurs de BGR en RVB, la détection et la conversion de l'image en BGR, avant de renvoyer l'image et les résultats dans la boucle pour le rendu. Les étapes sont effectuées de manière symétrique pour garantir que l'image est définie sur non inscriptible avant la détection et de nouveau sur inscriptible par la suite. L'orateur explique également la fonction cvtColor utilisée pour convertir la couleur de l'image et montre comment appeler la fonction de détection de canal multimédia dans la boucle.

  • 00:20:00 Dans cette section, le présentateur explique comment accéder au modèle MediaPipe à l'aide d'une "instruction with" et définit la confiance initiale et de suivi. Ils montrent également comment accéder et visualiser les différents types de repères : visage, main gauche et droite, et repères de pose. Le présentateur montre ensuite comment utiliser MediaPipe Holistic pour détecter des points de repère et affiche les résultats sur le cadre. Enfin, ils montrent comment rendre les points de repère à l'écran en écrivant une fonction.

  • 00:25:00 Dans cette section, le YouTuber met en place une nouvelle fonction appelée "draw_landmarks" qui restituera les données de repère sur une image pour permettre la visualisation des différents repères détectés par les modèles de tuyaux multimédias utilisés dans le projet. La fonction utilise la fonction d'assistance "mp.drawing" fournie par media pipe pour dessiner les points de repère, et nécessite également les données d'image et de point de repère comme entrées. La fonction permet également de spécifier des cartes de connexion et des options de formatage. Le YouTuber explique ensuite comment utiliser la fonction "plot.imshow" de matplotlib pour afficher la dernière image capturée à partir de la webcam.

  • 00:30:00 Dans cette section, le locuteur corrige la couleur de l'image et applique les repères à l'image en les faisant passer par la fonction "dessiner des repères". Les résultats du modèle de détection de canal multimédia sont accessibles en tant que dernière image et résultats de l'exécution de la boucle. Les méthodes "mp_drawing.draw_landmarks" s'appliquent à l'image actuelle pour restituer toutes les connexions de main, de pose et de visage. L'orateur applique ensuite la fonction "dessiner des points de repère" à la boucle en temps réel et avant le rendu, applique le formatage à l'aide de la "spécification de dessin de point de repère" et de la "spécification de dessin de connexion" pour dessiner respectivement les points et les connexions. Enfin, le haut-parleur crée une nouvelle fonction appelée "dessiner des repères de style" pour personnaliser la fonction "dessiner des repères" si vous le souhaitez.

  • 00:35:00 Dans cette section, l'orateur met à jour la mise en forme de la fonction de dessin de points de repère, en ajoutant deux paramètres supplémentaires pour la fonction mp_drawing.drawing_spec - la couleur et le rayon du cercle. Ils démontrent les changements pour le point de repère du visage et expliquent que le premier paramètre colore le point de repère et que le deuxième paramètre colore la connexion. L'orateur copie ensuite les modifications apportées à la fonction pour chacun des modèles de pose et de main, donnant à chaque modèle des couleurs uniques. Les changements sont purement cosmétiques et n'affecteront pas les performances, mais ils démontrent les différents modèles en action.

  • 00:40:00 Dans cette section, le didacticiel vidéo explique comment extraire les valeurs de points clés de la variable de résultats du modèle holistique MediaPipe de manière résiliente en les concaténant dans un tableau numpy et en gérant les erreurs. Le didacticiel explique comment extraire les valeurs d'un point de repère et les mettre à jour pour tous les points de repère à l'aide d'une boucle et d'une compréhension de liste. Le tableau final avec tous les points de repère est ensuite aplati pour avoir toutes les valeurs dans un tableau plutôt que plusieurs ensembles de points de repère.

  • 00:45:00 Dans cette section, le présentateur explique comment modifier le code à gérer lorsqu'il n'y a pas de points clés car la main est hors cadre. Ils commencent par montrer que les points de repère de gauche ont trois valeurs chacun et qu'il y a 21 points de repère pour un total de 63 valeurs nécessaires. Ils appliquent ensuite une instruction if qui remplace les valeurs manquantes par un tableau numpy vide. Cette même modification est ensuite appliquée aux amers de droite, qui ont également 63 valeurs. Le code extrait les différents points clés en concaténant les valeurs x, y et z ensemble dans un grand tableau, puis en l'aplatissant dans le format approprié pour une utilisation dans le modèle LSTM.

  • 00: 50: 00 Dans cette section, l'orateur explique comment ajouter la gestion des erreurs au modèle de pose et à la détection des points de repère du visage, et crée une fonction appelée "extract_key_points" pour extraire les points clés nécessaires à la détection des points de repère et à la détection des actions. La fonction utilise des tableaux numpy et parcourt les résultats pour extraire les valeurs x, y et z de chaque point de repère, puis les aplatit dans un tableau. L'intervenant mentionne également que le code sera disponible dans la description de la vidéo et invite les téléspectateurs à poser des questions dans les commentaires.

  • 00:55:00 Dans cette section de la vidéo, l'orateur explique la fonction d'extraction de points clés pour la détection de la langue des signes à l'aide de la reconnaissance d'action avec Python. La fonction extrait les points clés pour la pose, le visage, la main gauche et la main droite et les concatène dans un tableau numpy aplati. Ces points clés forment les valeurs de trame utilisées pour la détection du langage des signes à l'aide de la détection d'action humaine. Le haut-parleur configure également des variables pour le chemin des données exportées et les actions à détecter - bonjour, merci et je t'aime - en utilisant 30 trames de données pour chaque action.
  • 01:00:00 Dans cette section de la vidéo, le présentateur explique le processus de collecte de données pour détecter la langue des signes à l'aide de la reconnaissance d'action avec Python. Ils expliquent que pour chacune des trois actions qu'ils souhaitent détecter, ils collecteront 30 vidéos de données, chaque vidéo ayant une longueur de 30 images. Cela représente pas mal de données, mais le présentateur rassure les téléspectateurs sur le fait qu'ils procéderont étape par étape. Ils créent ensuite des dossiers pour chaque action et séquence d'action, dans lesquels les 30 points clés de chaque image de chaque séquence seront stockés sous forme de tableau numpy. Le présentateur mentionne également qu'à l'étape 11, il montrera aux téléspectateurs comment concaténer des mots pour former des phrases.

  • 01:05:00 Dans cette section, l'instructeur montre comment collecter des données pour le modèle de reconnaissance de la langue des signes. Il commence par créer des dossiers pour les trois différentes classes de signes - bonjour, merci et je t'aime - et leurs dossiers de séquence individuels correspondants. Ensuite, il modifie la boucle du tube multimédia pour parcourir chaque action, vidéo et image afin de collecter les données. Pour s'assurer que les images ne sont pas collectées trop rapidement, il ajoute une pause entre chaque vidéo à l'aide d'une instruction logique. Ce faisant, le modèle collectera 30 valeurs de points clés par vidéo, créant ainsi un ensemble empilé de trois actions, chacune avec 30 vidéos par action et 30 images par vidéo.

  • 01:10:00 Dans cette section, le créateur de la vidéo fournit une explication de la logique de collecte dans un script Python qui utilise OpenCV et des modèles d'apprentissage en profondeur pour détecter les gestes en langue des signes à partir de la vidéo. La logique consiste à afficher du texte sur l'écran et à faire une pause toutes les deux images. Le créateur de la vidéo montre également l'utilisation de np.save pour enregistrer les images sous forme de tableaux numpy, qui sont stockés dans un dossier mp_data. Ils fournissent ensuite le bloc de code final pour l'extraction des points clés et l'enregistrement des images dans les dossiers appropriés.

  • 01:15:00 Dans cette section de la transcription, l'orateur explique la logique appliquée pour parcourir ses actions et séquences (vidéos), appliquer la détection de canal multimédia, dessiner des points de repère stylisés et extraire différents points clés à enregistrer dans des dossiers spécifiques. Ils utiliseront trois actions (bonjour, merci et je t'aime) et collecteront 30 images par action pour 30 séquences. Avant d'exécuter ce code, ils vérifient les erreurs et ajustent la largeur de la ligne pour s'assurer que la police n'est pas masquée. Une fois le code exécuté, la fenêtre contextuelle indique "Démarrage de la collection", ils ont deux secondes pour se mettre en position pour effectuer l'action, et ils disposent de 30 images pour le faire. Le code doit pouvoir boucler et collecter des données indéfiniment.

  • 01:20:00 Dans cette section de la vidéo, le présentateur montre comment collecter des données en langue des signes à l'aide des bibliothèques MediaPipe et OpenCV en Python. Le présentateur suggère de capturer différents angles de signes de la main pour de meilleures performances du modèle et mentionne également que le fait d'avoir 30 séquences de 30 images chacune a tendance à bien fonctionner. Les points clés collectés par MediaPipe sont utilisés à la place de l'image pour rendre le modèle plus résistant dans divers scénarios. Le présentateur explique également que les données collectées sont stockées sous forme de tableaux numpy pour une utilisation future.

  • 01:25:00 Dans cette section, la vidéo se concentre sur le prétraitement des données et la création d'étiquettes et de fonctionnalités pour le modèle d'apprentissage en profondeur LSTM. La vidéo commence par importer des dépendances, puis par créer une carte d'étiquettes, qui est essentiellement un dictionnaire représentant chacune des différentes actions. Ensuite, les données sont lues et rassemblées pour les structurer en un seul grand tableau avec 90 tableaux, chacun contenant 30 cadres avec 1662 valeurs représentant les points clés. Deux tableaux vides sont créés, les séquences et les étiquettes, où les séquences représentent les données d'entité et les étiquettes représentent les données d'étiquette. Le code parcourt ensuite chacune des actions et des séquences, créant un tableau vide pour que les fenêtres représentent toutes les différentes images de cette séquence particulière. Enfin, numpy.load est utilisé pour charger chaque image.

  • 01:30:00 Dans cette section, l'orateur passe par le processus de prétraitement des données en les stockant dans un tableau numpy et en convertissant les étiquettes en une représentation codée à chaud à l'aide de la fonction "to_categorical". Ils utilisent ensuite la fonction "train_test_split" pour partitionner les données en ensembles d'apprentissage et de test. L'ensemble d'apprentissage se compose de 85 séquences et l'ensemble de test comporte cinq séquences. L'orateur importe également les dépendances nécessaires, y compris le modèle séquentiel, la couche LSTM et la couche dense, alors qu'il se prépare à former un réseau de neurones LSTM à l'aide de TensorFlow et Keras.

  • 01:35:00 Dans cette section, l'orateur discute des dépendances nécessaires à la construction d'un réseau de neurones, y compris séquentiel, lstm, dense et tensorboard. Ils expliquent que séquentiel facilite l'ajout de couches au modèle, et lstm est utilisé pour l'analyse temporelle et la détection d'action. L'orateur montre également comment configurer des rappels de tableau de bord pour surveiller les progrès de la formation. Ils procèdent ensuite à la construction de l'architecture du réseau neuronal, qui comprend l'ajout de trois ensembles de couches lstm et la spécification des fonctions d'activation et de la forme d'entrée. Enfin, ils mentionnent l'importance de ne pas retourner les séquences dans la couche dense et recommandent des ressources d'apprentissage supplémentaires.

  • 01:40:00 Dans cette section de la vidéo, le présentateur passe en revue les différents types de couches ajoutées au modèle LSTM, en précisant que les trois couches suivantes sont toutes des couches denses. Chaque couche dense utilise 64 et 32 unités denses ou neurones entièrement connectés avec des valeurs d'activation de ReLU. La couche finale est la couche d'actions, qui extrait les valeurs renvoyées sous forme de trois unités de réseau neuronal en utilisant la valeur d'activation de softmax. Le modèle prédit une action telle que "Bonjour", et cette sortie est passée à travers 30 images plus 1 662 points clés, et prétraitée pour extraire les actions. Le présentateur explique comment ils sont arrivés à utiliser MediaPipe et la couche LSTM en discutant de la recherche et du développement qu'ils ont menés. Enfin, le modèle est compilé en utilisant l'entropie croisée catégorielle comme fonction de perte, et il est ajusté et formé avec le train x et le train y pour le nombre d'époques spécifié.

  • 01:45:00 Dans cette section, la vidéo montre le processus de formation d'un modèle d'apprentissage en profondeur LSTM pour la détection de la langue des signes à l'aide de la reconnaissance d'action avec Python. Le modèle utilise le modèle de MediaPipe Holistic, qui ne nécessite pas de générateur de données car les données peuvent tenir en mémoire. La vidéo montre comment configurer le processus de formation avec TensorBoard et comment surveiller la précision et la perte du modèle pendant la formation dans TensorBoard. La vidéo explique également comment arrêter le processus de formation une fois qu'un niveau de précision raisonnable a été atteint et comment inspecter la structure du modèle à l'aide de la fonction model.summary.

  • 01:50:00 Dans cette section, l'orateur forme un modèle et fait des prédictions en utilisant le modèle enregistré. Le modèle utilise la technique d'apprentissage en profondeur LSTM pour identifier les actions de la langue des signes. Le modèle prédit la probabilité la plus élevée d'action détectée avec une fonction softmax. La valeur prédite est comparée à la valeur réelle pour évaluer les performances du modèle. L'orateur enregistre le modèle formé sous action.h5 et le recharge avec une fonction de compilation et de chargement. En important des métriques depuis sklearn, l'orateur évalue les performances de la matrice de confusion multi-étiquettes du modèle.

  • 01:55:00 Dans cette section de la vidéo, le présentateur explique comment évaluer les performances du modèle formé à l'aide d'une matrice de confusion multi-étiquettes et d'une fonction de score de précision. La matrice de confusion représente les vrais positifs et les vrais négatifs, et plus le nombre de ces valeurs dans les coins supérieur gauche et inférieur droit est élevé, meilleures sont les performances du modèle. La fonction de score de précision donne le pourcentage de prédictions correctes du modèle. Le modèle formé est ensuite évalué à l'aide des données de test, et la boucle est rétablie pour la détection en temps réel, ce qui implique la création de nouvelles variables pour la détection, la concaténation des trames et l'application d'une logique de prédiction. Une variable de seuil est également implémentée pour rendre les résultats supérieurs à une certaine métrique de confiance.

  • 02:00:00 Dans cette section, l'orateur explique sa logique de prédiction pour la détection de la langue des signes à l'aide de la reconnaissance d'action avec Python et le modèle d'apprentissage en profondeur LSTM. Ils commencent par extraire les points clés et les ajouter à une séquence de 30 images. Si la longueur de la séquence est égale à 30, ils exécutent la prédiction en appelant model.predict avec les dimensions développées de la séquence. Ils impriment ensuite la classe prédite à l'aide de np.argmax et des actions définies précédemment. L'orateur insère également des points clés au début de la séquence pour trier la logique et procède à l'ajout d'une logique de visualisation au code.

  • 02:05:00 Dans cette section, l'orateur décompose le code expliquant comment le programme vérifie si le résultat est supérieur au seuil en extrayant le résultat du score le plus élevé à l'aide de "mp.argmax" et en passant par "res". La logique du programme est de vérifier que le dernier mot correspond à la prédiction actuelle. Si c'est le cas, le programme n'ajoutera pas à la longueur de la phrase. Si cela ne correspond pas, le programme ajoutera l'action actuellement détectée à notre tableau de phrases. La longueur de la phrase ne doit inclure que jusqu'à cinq mots afin que le programme n'essaie pas de restituer un tableau géant. Enfin, le programme mettra du texte et un rectangle sur l'image pour afficher la phrase.

  • 02:10:00 Dans cette section, la vidéo montre comment utiliser Python et un modèle LSTM Deep Learning pour détecter le langage des signes à l'aide de la reconnaissance d'action. Le didacticiel explique comment ajuster le code pour utiliser la méthode d'ajout et augmenter le seuil de détection pour une meilleure précision. La vidéo montre également comment rendre les probabilités avec une fonction rapide pour créer une visualisation de probabilité, rendant la sortie de détection visuellement attrayante. Dans l'ensemble, le didacticiel fournit un excellent exemple d'utilisation de modèles d'apprentissage en profondeur pour détecter la langue des signes avec Python, ce qui en fait une excellente ressource pour quiconque cherche à créer des projets similaires.

  • 02:15:00 Dans cette section de la vidéo, le présentateur démontre une fonction de visualisation de probabilité qui nous permet de visualiser les différentes actions et comment leurs probabilités sont calculées en temps réel. La fonction utilise cv2.rectangle pour placer un rectangle dynamique sur le cadre de sortie, puis le positionne et le remplit en fonction de l'action sur laquelle nous travaillons actuellement, qui utilise ensuite la méthode de texte cv2.put pour générer les valeurs de texte. Le présentateur montre comment cette fonction peut être intégrée à la boucle pour la visualiser en temps réel, et nous pouvons voir qu'elle détecte et reconnaît différentes actions telles que bonjour, merci et je t'aime en fonction des valeurs de probabilité. Le présentateur souligne qu'il existe de nombreuses applications pour cette fonction et montre comment le code peut être utilisé pour détecter et reconnaître différentes actions dans divers scénarios.

  • 02:20:00 Dans cette section de la vidéo, le présentateur récapitule le processus de son projet de détection de la langue des signes. Ils ont créé des dossiers pour la collecte, collecté des points clés, prétraité les données, construit un réseau neuronal LSTM, fait des prédictions et l'ont testé en temps réel. Ils ont pu faire fonctionner efficacement les détections en temps réel, y compris la visualisation des probabilités. Ils fournissent une démonstration de la façon dont ils ont corrigé le code pour saisir les bonnes images et les ajouter à la séquence en déplaçant deux-points et en ajoutant un négatif. Ils ont également ajouté une ligne pour ajouter leurs prédictions à un nouveau tableau de prédiction afin d'assurer plus de stabilité lors de la prédiction d'actions. Enfin, ils offrent aux utilisateurs la possibilité d'étendre et de modifier le projet en ajoutant des actions, des couleurs et/ou des visualisations supplémentaires comme bon leur semble.

  • 02:25:00 Dans cette section, l'orateur démontre comment le modèle de détection d'action est devenu plus stable et résilient en mettant en œuvre une logique supplémentaire. Le modèle est désormais capable de minimiser les fausses détections et de maintenir la détection pendant de plus longues périodes, améliorant ainsi sa précision. L'orateur mentionne également que les poids formés pour le modèle seront disponibles dans le référentiel GitHub pour que les utilisateurs puissent en tirer parti. La vidéo se termine par une invitation à donner un coup de pouce à la vidéo et à s'abonner à la chaîne.
GitHub - nicknochnack/ActionDetectionforSignLanguage: A practical implementation of sign language estimation using an LSTM NN built on TF Keras.
GitHub - nicknochnack/ActionDetectionforSignLanguage: A practical implementation of sign language estimation using an LSTM NN built on TF Keras.
  • nicknochnack
  • github.com
A practical implementation of sign language estimation using an LSTM NN built on TF Keras. - GitHub - nicknochnack/ActionDetectionforSignLanguage: A practical implementation of sign language estim...
 

Numerics of Machine Learning à l'Université de Tübingen au semestre d'hiver 2022/23. Conférence 1 - Introduction -- Philipp Hennig



Numériques de ML 1 -- Introduction -- Philipp Hennig

Dans cette vidéo, Philipp Hennig discute de l'importance de comprendre les algorithmes numériques dans l'apprentissage automatique et présente le contenu du cours pour le semestre. Le premier algorithme numérique couvert est l'algèbre linéaire, avec une application dans la régression de processus gaussien. Hennig discute également du rôle de la simulation, des équations différentielles, de l'intégration et de l'optimisation dans l'apprentissage automatique. Il introduit de nouveaux développements dans les algorithmes numériques, tels que les épines algorithmiques, les observables et les algorithmes numériques probabilistes. Tout au long de la vidéo, Hennig insiste sur l'importance de mettre à jour les algorithmes classiques utilisés dans l'apprentissage automatique pour résoudre des problèmes complexes et met en évidence le rôle de l'écriture de code dans ce cours d'informatique.

Philipp Hennig présente son cours sur Numerics of Machine Learning, qui vise à explorer comment les algorithmes d'apprentissage automatique fonctionnent à l'intérieur de la boîte et comment ils peuvent être adaptés ou modifiés pour améliorer les machines d'apprentissage. Les connaissances hautement techniques en algorithmes numériques et algorithmes d'apprentissage automatique sont très recherchées par les chercheurs et les professionnels de l'industrie. Le cours comprendra des travaux théoriques et de codage, avec des devoirs notés sur un système binaire. Hennig souligne l'importance des algorithmes numériques dans l'apprentissage automatique et invite les étudiants à se joindre à cette expérience d'enseignement unique avec neuf instructeurs différents.

  • 00:00:00 Dans cette section, Philipp Hennig présente l'importance de comprendre les algorithmes numériques dans l'apprentissage automatique. Alors que les algorithmes d'apprentissage automatique prennent des données en entrée et produisent des modèles qui prédisent ou agissent dans le monde, le processus d'apprentissage proprement dit implique un calcul numérique. Contrairement aux algorithmes d'IA classiques, les algorithmes d'apprentissage automatique contemporains utilisent des algorithmes numériques tels que l'algèbre linéaire, la simulation, l'intégration et les méthodes d'optimisation comme primitives pour ces calculs. Philipp définit les algorithmes numériques comme des méthodes qui estiment une quantité mathématique qui n'a pas de solution de forme fermée et peut se tromper contrairement aux opérations atomiques qui fonctionnent toujours. Les algorithmes numériques étant au cœur de l'apprentissage automatique, il est important de les comprendre pour s'assurer qu'ils fonctionnent correctement.

  • 00:05:00 Dans cette section, l'orateur discute de la différence entre les fonctions régulières et les algorithmes numériques, notant que ces derniers ont tendance à avoir leurs propres bibliothèques et plusieurs sous-programmes parmi lesquels choisir. Il donne ensuite un exemple d'algorithme numérique prototypique écrit en 1993 dans le langage Forth, implémentant un algorithme inventé par deux mathématiciens en 1975. Cela met en évidence le fait que les algorithmes numériques sont anciens et ont des interfaces précises, ce qui les rend difficiles à modifier. Les ingénieurs en apprentissage automatique rencontrent fréquemment des tâches numériques et ont pu utiliser ces anciens algorithmes développés par d'autres domaines, mais cela peut être problématique si la tâche à accomplir ne correspond pas précisément aux capacités de la méthode. L'orateur suggère que cela peut devenir un problème dans l'apprentissage automatique lorsqu'on essaie de résoudre des problèmes pour lesquels les méthodes numériques existantes ne sont pas suffisantes.

  • 00:10:00 Dans cette section, Philipp Hennig présente le sujet des algorithmes numériques et le contenu du cours pour le semestre. L'algèbre linéaire, la couche de base de l'apprentissage automatique, est le premier algorithme numérique qu'ils couvrent. Un exemple de son application est dans la régression de processus gaussien, où deux fonctions sont utilisées pour l'inférence : la moyenne postérieure et la fonction de covariance postérieure. Ces fonctions sont définies à l'aide de méthodes du noyau et leur mise en œuvre implique la méthode de décomposition de Cholesky plutôt que le calcul de l'inverse d'une matrice. Hennig présente également un extrait de code Python et explique pourquoi il faut utiliser la décomposition de Cholesky au lieu de calculer l'inverse d'une matrice.

  • 00:15:00 Dans cette section de la vidéo, le conférencier Philipp Hennig discute du problème des machines à noyau, en particulier en ce qui concerne leur incapacité à bien s'adapter à de grandes quantités de données. Il explique que les calculs coûteux requis pour les machines à noyau les rendent difficiles à utiliser dans l'apprentissage automatique contemporain. Cependant, Hennig suggère également qu'il existe d'autres algorithmes d'algèbre linéaire qui peuvent être utilisés pour accélérer les calculs en tirant parti de la structure et des approximations des ensembles de données, conduisant finalement à des solutions avec régression de processus gaussien qui s'adaptent à de grands ensembles de données.

  • 00:20:00 Dans cette section, Philipp Hennig présente les algorithmes de simulation et leur rôle dans l'apprentissage automatique. Les méthodes de simulation simulent la trajectoire d'un système dynamique dans le temps et peuvent estimer X. Elles apparaissent dans l'apprentissage automatique lors de la construction d'agents tels qu'une voiture autonome ou lors de la création d'un algorithme d'apprentissage automatique qui utilise des connaissances physiques telles que des connaissances scientifiques. apprentissage automatique. Les équations différentielles, telles que l'équation de Schrodinger, sont généralement utilisées pour coder la connaissance de la nature. En outre, Hennig fournit un exemple d'un problème de prédiction simple des cas de COVID-19 en Allemagne sur un an et demi pour expliquer pourquoi les réseaux de neurones profonds et les processus gaussiens ne fonctionnent pas pour résoudre ce problème.

  • 00:25:00 Dans cette section, Philipp Hennig discute de l'utilisation des équations différentielles dans les systèmes de modélisation, en particulier les modèles SIR qui sont couramment utilisés dans les simulations, et du défi d'intégrer la dynamique du monde réel, comme les verrouillages, dans ces modèles. Il suggère d'utiliser un réseau de neurones pour rendre le coefficient bêta dépendant du temps, mais note la difficulté de le faire en raison du manque de dérivés dans le code. Cependant, il met en évidence le développement récent d'un algorithme en Jax qui résout ce problème.

  • 00:30:00 Dans cette section, Philipp Hennig discute d'un algorithme appelé inférence basée sur la simulation, qui est un moyen actuel de résoudre des problèmes complexes. Cet algorithme implique une boucle for imbriquée qui évalue la fonction f plusieurs fois et renvoie le gradient et effectue une étape de descente de gradient. Hennig explique que pour créer un algorithme plus flexible et plus rapide que ce code primitif, nous pouvons construire notre propre méthode qui construit une liste de nombres à l'intérieur du code photon de manière procédurale et les adapte. Cette méthode implique une colonne vertébrale d'une chaîne de Markov qui peut y accrocher des opérateurs, tels que des opérateurs de distribution de probabilité et d'information, pour informer l'algorithme des facteurs inconnus. En faisant cela, nous pouvons résoudre ces problèmes sans appeler une boucle for encore et encore dans une boucle externe, ce qui prendrait du temps.

  • 00:35:00 Dans cette section, Philipp Hennig discute de l'importance de mettre à jour les algorithmes classiques utilisés dans l'apprentissage automatique, qui ont plus de 100 ans. Il introduit l'idée de spines algorithmiques qui peuvent opérer sur différents opérateurs d'information et peuvent créer de nouvelles fonctionnalités. Hennig aborde ensuite le rôle de l'intégration dans l'apprentissage automatique, qui est une opération élémentaire d'inférence du patient. L'opération élémentaire de l'apprentissage automatique probabiliste consiste à calculer une distribution a posteriori en prenant une distribution conjointe et en la divisant par une marginale, ce qui implique une intégration. Enfin, Hennig discute de l'importance de l'optimisation, qui est l'opération fondamentale de l'apprentissage automatique, impliquant le calcul de valeurs qui minimisent les fonctions de perte. Ces algorithmes forment la base de programmes différentiables, pour lesquels le gradient de la fonction peut être calculé automatiquement.

  • 00:40:00 Dans cette section, Philipp Hennig discute des algorithmes d'optimisation et de leur importance dans l'apprentissage automatique. Alors que les méthodes classiques telles que BFGS et Minimize sont stockées dans scipy.optimize, de nouvelles méthodes telles que SGD et Adam sont désormais la norme en matière d'apprentissage automatique. Cependant, ces méthodes nécessitent souvent un rythme d'apprentissage et beaucoup de supervision, contrairement aux méthodes plus anciennes, qui peuvent converger au minimum et travailler sur n'importe quel problème différentiable. Pour faire face aux limites de ces nouvelles méthodes sur de grands ensembles de données avec des millions de points de données, une descente de gradient par lots est utilisée pour calculer une somme beaucoup plus petite, qui est un estimateur impartial de la chose qui nous intéresse. Bien que ces nouvelles méthodes soient plus performants et efficaces, ils reposent toujours sur les mêmes principes que les anciens algorithmes, ce qui peut poser des problèmes pour certaines applications.

  • 00:45:00 Dans cette section de la vidéo, l'orateur discute de la possibilité de calculer la variance en plus du gradient dans les algorithmes d'apprentissage en profondeur. Il soutient que l'omission du calcul de la variance du processus d'optimisation est due au fait que l'optimisation est toujours considérée comme un problème de calcul de gradient plutôt qu'un problème d'utilisation de variables aléatoires pour trouver des points qui se généralisent bien. Cependant, il souligne l'importance d'inclure l'incertitude résultant du caractère aléatoire dans les calculs, notant qu'il est essentiel de créer de meilleures configurations de formation pour les réseaux de neurones profonds. Il conclut en mentionnant les conférences à venir qui approfondiront ce sujet.

  • 00:50:00 Dans cette section, Philipp Hennig discute de l'utilisation d'observables pour ajouter de nouvelles fonctionnalités aux réseaux de neurones profonds, tels que l'incertitude ou leur transformation en un réseau de neurones profond bayésien sans utiliser les coûteux algorithmes de Monte Carlo de la chaîne de Markov. Il explique également comment les algorithmes numériques utilisés pour former les algorithmes d'apprentissage automatique sont en fait des algorithmes d'apprentissage automatique eux-mêmes, car ils estiment une quantité inconnue ou une variable latente tout en observant des données traitables et observables. Ceci est similaire au processus d'inférence, où une quantité latente est estimée sur la base des résultats observés à partir d'un calcul.

  • 00:55:00 Dans cette section, Philipp Hennig présente le concept d'algorithmes numériques en tant que machines d'apprentissage et discute de l'idée derrière la construction d'algorithmes numériques à partir de zéro en tant qu'algorithmes numériques probabilistes. Ce sont des algorithmes qui prennent une distribution de probabilité décrivant leur tâche et utilisent le CPU ou le GPU comme source de données pour affiner leur estimation de la solution à la tâche numérique. Hennig souligne que la classe n'est pas une classe d'analyse numérique typique, car l'accent est mis sur la compréhension des machines à l'intérieur en tant que machines d'apprentissage et sur la construction de nouveaux algorithmes dans le langage de l'apprentissage automatique. Les élèves peuvent s'attendre à écrire beaucoup de code dans ce cours d'informatique.

  • 01:00:00 Dans cette section, Philipp Hennig présente son cours sur les numériques de l'apprentissage automatique, qui, selon lui, est le premier cours dédié de ce type au monde. Le cours vise à approfondir le fonctionnement des algorithmes d'apprentissage automatique, en particulier comment ils fonctionnent à l'intérieur de la boîte et comment ils peuvent être modifiés ou adaptés pour améliorer les machines d'apprentissage. La nature hautement technique des algorithmes numériques et des algorithmes d'apprentissage automatique signifie que les connaissances dans ce domaine sont très recherchées à la fois par les chercheurs et les professionnels de l'industrie. Les conférences seront enseignées par son équipe de doctorants hautement expérimentés, qui ont passé des années à rechercher et à réfléchir sur le fonctionnement interne de ces algorithmes, et sont donc mieux équipés pour discuter des détails techniques les plus fins qu'un professeur.

  • 01:05:00 Dans cette section, Philipp Hennig discute de la structure du cours et des exigences du cours. Le cours comprendra à la fois des travaux théoriques et de codage, car les étudiants devront résoudre des problèmes numériques en utilisant le code Python ou Julia. Les exercices seront soumis sous forme de PDF, avec des solutions notées sur une base binaire - une coche sera donnée pour une bonne solution et une croix pour une solution insatisfaisante. Les étudiants recevront un point bonus pour chaque coche, qui comptera dans le résultat de l'examen final. L'examen aura lieu le 13 février ou le 31 mars de l'année prochaine, et la réussite du premier examen est encouragée car une réinitialisation peut ne pas être disponible. Enfin, les étudiants intéressés à obtenir un diplôme supérieur en algorithmes numériques en apprentissage automatique ou en calcul centré sur les données sont encouragés à suivre ce cours car il offre de nombreuses opportunités de recherche appliquée dans divers domaines.

  • 01:10:00 Dans cette section, Philipp Hennig souligne l'importance des algorithmes numériques dans l'apprentissage automatique, affirmant qu'ils sont les moteurs qui animent l'apprentissage automatique. Il décrit comment la compréhension de ces algorithmes et de leur langage d'inférence bayésien peut conduire à des solutions d'apprentissage automatique plus rapides, plus fiables et plus faciles à utiliser. Hennig souligne que si les algorithmes numériques classiques sont importants, ils doivent être considérés à travers le prisme de l'apprentissage automatique, en adoptant la perspective des machines d'apprentissage comme un moyen d'intégrer la simulation et l'apprentissage en profondeur d'une manière plus holistique. Il invite les étudiants à se joindre à cette expérience passionnante d'enseignement de l'apprentissage automatique avec une configuration unique de neuf instructeurs différents.
 

Cours 2 -- Algèbre linéaire numérique -- Marvin Pförtner



Numériques de ML 2 -- Algèbre linéaire numérique -- Marvin Pförtner

L'algèbre linéaire numérique est fondamentale pour l'apprentissage automatique, les processus gaussiens et d'autres méthodes de régression non paramétriques. La conférence couvre divers aspects de l'algèbre linéaire numérique, y compris l'importance de comprendre la structure d'une matrice pour une multiplication plus efficace, l'optimisation des algorithmes d'apprentissage automatique en résolvant des problèmes de sélection d'hyperparamètres et en calculant des matrices de noyau, et la solution d'un système linéaire en utilisant le Décomposition LU, entre autres. La conférence souligne également l'importance d'implémenter correctement les algorithmes, car l'algorithme utilisé pour les opérations mathématiques a un impact significatif sur les performances, la stabilité et la consommation de mémoire.

Dans la deuxième partie de la vidéo, Marvin Pförtner discute de l'importance de l'algèbre linéaire numérique dans les algorithmes d'apprentissage automatique. Il couvre divers sujets, notamment la décomposition LU, la décomposition de Cholesky, le lemme d'inversion de matrice et la régression de processus gaussien. Pförtner souligne l'importance d'utiliser la structure pour rendre les algorithmes plus efficaces et souligne l'importance de la stabilité numérique dans la résolution de grands systèmes d'équations dans la régression de processus gaussien. Il aborde également des techniques telles que l'apprentissage actif et les approximations de rang inférieur pour gérer de grands ensembles de données et les limitations potentielles de la mémoire des matrices du noyau. Dans l'ensemble, la vidéo présente le rôle crucial que joue l'algèbre linéaire numérique dans de nombreux aspects de l'apprentissage automatique.

  • 00:00:00 Dans cette section, un doctorant discute de l'importance de l'algèbre linéaire numérique dans l'apprentissage automatique et les processus gaussiens. L'algèbre linéaire numérique est fondamentale pour l'apprentissage automatique et c'est un ensemble d'outils nécessaires pour implémenter des algorithmes. La conférence couvre les tâches fondamentales de l'algèbre linéaire numérique importantes pour l'apprentissage automatique, l'exploration de la structure pour rendre les algorithmes d'algèbre linéaire numérique rapides et fiables et la mise en œuvre correcte de la régression de processus gaussien. La conférence cite également des exemples d'applications de l'algèbre linéaire numérique comme la théorie des probabilités de base, les modèles linéaires généraux, l'analyse en composantes principales et les produits matrice-vecteur qui réduisent la dimensionnalité.

  • 00:05:00 Dans cette section, l'orateur discute de l'algèbre linéaire numérique dans le contexte de l'apprentissage automatique. Il explique comment les processus gaussiens, une méthode de régression non paramétrique dans l'apprentissage automatique, reposent sur une mesure de probabilité a priori, qui est un processus gaussien qui génère une matrice de Gram à noyau défini symétrique et positif. Les informations génératives de cette matrice permettent des algorithmes efficaces et fiables. L'orateur mentionne également comment des équations similaires s'appliquent à une plus grande classe de modèles, y compris les méthodes du noyau et la régression Ridge. Il explique également brièvement comment l'algèbre linéaire numérique est utilisée pour résoudre des équations différentielles partielles linéaires et dans les méthodes d'optimisation pour l'optimisation locale des fonctions de perte.

  • 00:10:00 Dans cette section, l'orateur discute de l'importance de l'algèbre linéaire dans l'apprentissage automatique et fournit des exemples pour illustrer cette importance. Les opérations d'algèbre linéaire telles que la multiplication vectorielle matricielle, les solutions de systèmes linéaires et les décompositions matricielles sont fondamentales pour de nombreux modèles d'apprentissage automatique. De plus, il note que de nombreux modèles d'apprentissage automatique sont en fait bruités puisqu'ils utilisent une estimation bruitée de la matrice avec laquelle ils visent à résoudre des systèmes linéaires. Enfin, il souligne que les déterminants logarithmiques sont essentiels dans le cas de la densité gaussienne et de la régression GP pour obtenir des estimations a posteriori maximales.

  • 00:15:00 Dans cette section, l'orateur souligne l'importance d'une multiplication efficace des vecteurs matriciels en algèbre linéaire numérique et en apprentissage automatique. Ils donnent un exemple de la façon dont même des tâches simples peuvent devenir irréalisables sur le plan informatique si l'expression mathématique n'est pas correctement transformée en algorithme. L'orateur souligne également l'importance d'identifier la structure dans la matrice pour une multiplication plus efficace. Ils concluent en indiquant que l'algorithme mettant en œuvre une opération mathématique a un impact significatif sur les performances, la stabilité et la consommation de mémoire.

  • 00:20:00 Dans cette section, l'intervenant insiste sur l'importance de comprendre la structure d'une matrice pour optimiser les algorithmes d'apprentissage automatique. Il explique que si vous savez qu'il existe une structure de rang inférieur dans une matrice, vous devez utiliser des méthodes spécialisées dans les matrices inférieures pour la factoriser, plutôt que de multiplier la matrice complète. Il explique que l'abaissement n'est qu'un type de structure et qu'il existe diverses structures matricielles telles que les matrices creuses et les matrices noyaux qui dépendent également des entrées non nulles et des dimensions d'entrée du régresseur. L'orateur aborde également la manière de stocker les matrices du noyau afin d'économiser de la mémoire.

  • 00:25:00 Dans cette section, l'orateur explique comment stocker et évaluer efficacement les matrices du noyau pour les processus gaussiens. Si les points de données dépassent une certaine limite, l'approche naïve consistant à les stocker n'est plus possible en raison de problèmes de mémoire. Il existe des bibliothèques qui écrivent des noyaux CUDA très efficaces et utilisent des GPU pour calculer des processus gaussiens sur un ordinateur portable en utilisant des centaines de milliers de points de données. L'orateur parle également des matrices avec une forme fonctionnelle générale, comme les graphes auto-diff, qui nécessitent les mêmes exigences de temps et d'espace. Enfin, l'orateur se penche sur un algorithme concret d'application de la régression bayésienne aux processus gaussiens, où le noyau de la mesure gaussienne est la covariance de la fonction inconnue. L'orateur présente un tracé de la mesure postérieure sur la fonction en conjonction avec les données observées et comment la quantification de l'incertitude fonctionne bien. Cependant, le problème se pose lors du calcul de l'inverse, qui évolue de manière assez prohibitive, rendant l'approche naïve consistant à calculer une matrice gramme du noyau à partir de n points de données irréalisable pour un grand n.

  • 00:30:00 Dans cette section, l'orateur discute de la complexité numérique du calcul des matrices du noyau dans les processus gaussiens, qui peut devenir prohibitif. De plus, il existe des hyperparamètres qui doivent être réglés pour le noyau, tels que l'échelle de sortie et l'échelle de longueur, afin d'optimiser l'avant pour expliquer l'ensemble de données observé. L'orateur décrit une approche bayésienne pour résoudre ce problème de sélection de modèle en calculant la vraisemblance logarithmique marginale et en minimisant une fonction de perte consistant en un compromis entre l'ajustement du modèle et la complexité représentée par le facteur de normalisation de la distribution gaussienne. L'orateur montre des exemples de sous-ajustement et de surajustement sévères et explique comment le compromis entre ces deux termes peut être trouvé pour obtenir les meilleures performances du modèle.

  • 00:35:00 Dans cette section, Marvin Pförtner discute de la solution d'un système linéaire. La solution nécessite M plus un résout où M est le nombre de points de données auxquels nous voulons évaluer notre régresseur. Le système est symétrique et défini positif dans le cas le plus général, mais il peut y avoir des structures supplémentaires à exploiter car le système est généralement énorme, et nous ne pouvons généralement pas résoudre ce problème pour de très grands ensembles de données. Une décomposition matricielle très importante est la décomposition Lu. L'algorithme utilisé pour résoudre un système triangulaire inférieur est la substitution directe, qui décompose la matrice en quatre parties : scalaire dans le coin inférieur droit, la colonne au-dessus est zéro, un vecteur ligne à gauche et une autre partie triangulaire appelée L moins li moins un au-dessus, qui est également triangulaire inférieur.

  • 00:40:00 Dans cette section, Marvin Pförtner explique comment résoudre des systèmes où la matrice du système est triangulaire inférieure, avec la dimension n moins un. En divisant la dernière ligne, le système peut être résolu à l'aide d'un algorithme simple. Des méthodes récursives sont ensuite utilisées pour résoudre un système pour une dimension donnée. Pförtner explique également comment diviser la matrice en parties triangulaires inférieure et supérieure en utilisant ce qu'il appelle la décomposition de Lu, qui est une définition récursive utilisant des techniques de division pour mieux régner. Cette technique est utile pour inverser les matrices et rendre la résolution des systèmes linéaires moins coûteuse, le processus étant O(N^2) au lieu de O(N^3).

  • 00:45:00 Dans cette section, la méthode de décomposition Lu pour résoudre des systèmes linéaires d'équations est expliquée. Cette méthode décompose une matrice en une matrice triangulaire inférieure et une matrice triangulaire supérieure, permettant un calcul plus rapide des solutions aux systèmes linéaires. Le processus consiste à définir les entrées diagonales de la partie gauche de la matrice triangulaire inférieure à un et à utiliser un pivotement partiel pour assurer la stabilité et la robustesse. Malgré l'efficacité de la méthode, le coût du calcul, qui est O(n^3), doit être pris en compte.

  • 00:50:00 Dans cette section, Marvin Pförtner discute du temps de calcul de la décomposition UD et montre comment l'implémenter sur place. Il explique que la plus grande partie de chaque étape de récurrence est le calcul du produit extérieur et de la soustraction, ce qui donne une sommation sur deux fois (n-1) au carré. En utilisant une stratégie connue sous le nom d'élimination gaussienne, l'algorithme calcule efficacement la matrice triangulaire supérieure. Pförtner montre comment effectuer un exemple de calcul avec une petite matrice, démontrant que la partie non triviale de L est contenue dans les trois entrées sous la diagonale, et la partie triangulaire supérieure contiendra les parties non nulles de U. En gardant tout en mémoire, Pförtner présente une implémentation qui stocke astucieusement L et U dans la même matrice.

  • 00:55:00 Dans cette section, l'orateur explique le processus de décomposition LU en algèbre linéaire numérique. Il montre comment calculer l'algorithme étape par étape et comment l'utiliser pour résoudre des systèmes linéaires. Une fois que nous avons la décomposition LU d'une matrice, nous pouvons l'appliquer pour résoudre efficacement plusieurs systèmes linéaires avec plusieurs côtés droits, ne coûtant que 2N au carré pour une fois la substitution vers l'avant et vers l'arrière. L'inverse d'une matrice de permutation n'est que sa transposée, qui est peu coûteuse à calculer, ce qui permet d'effectuer K résolutions avec la même matrice système dans la régression de processus gaussien.

  • 01:00:00 Dans cette section, l'orateur explique comment résoudre efficacement plusieurs systèmes linéaires avec la même matrice en utilisant une décomposition LU, qui est efficace en termes de calcul. De plus, une méthode de calcul du déterminant logarithmique avec une décomposition LU est présentée, qui permet une représentation efficace d'un système linéaire et l'exécution de diverses tâches d'algèbre linéaire avec celui-ci. L'orateur souligne l'importance d'utiliser la structure pour rendre les algorithmes plus efficaces et note que la décomposition de Cholesky est une version spécialisée de la décomposition LU qui tire parti de la nature symétrique et définie positive de la matrice gramme du noyau.

  • 01:05:00 Dans cette section, l'orateur discute du calcul de la moyenne postérieure et de la covariance dans les processus gaussiens. Pour obtenir la moyenne a posteriori, il faut résoudre un système par substitution vers l'avant et un autre par substitution vers l'arrière. L'orateur note qu'avec la structure des facteurs de cholesky de la matrice de covariance, on peut obtenir une bonne approximation descendante de la matrice. De plus, il parle du problème de ne pas pouvoir potentiellement insérer la grande matrice du noyau dans la mémoire et présente deux approches pour résoudre ce problème ; en utilisant la structure dans les noyaux employés ou en utilisant des approximations creuses.

  • 01:10:00 Dans cette section, le conférencier explique comment inverser efficacement les matrices dans les algorithmes d'apprentissage automatique. Il utilise un ensemble de données généré à partir d'une fonction sinusoïdale comme exemple et montre qu'en connaissant la structure générative de l'ensemble de données, on peut choisir des noyaux qui reflètent cette connaissance et sont efficaces en termes de calcul. Le lemme d'inversion de matrice est un outil qui peut être utilisé pour inverser efficacement des matrices en les perturbant avec un petit nombre de sous-espaces. En utilisant ce lemme, on peut calculer des expressions très efficacement sans même avoir besoin de former la matrice entière en mémoire. L'orateur souligne qu'il existe de nombreuses approches différentes pour utiliser la structure dans les algorithmes d'apprentissage automatique.

  • 01:15:00 Dans cette section, le conférencier discute des méthodes d'algèbre linéaire numérique utilisées dans les inférences gaussiennes et l'optimisation des hyperparamètres dans l'apprentissage automatique. Une méthode pour mettre à l'échelle la régression GP (processus gaussien) à de grands ensembles de données est l'inversion approximative, qui implique la construction itérative d'approximations de rang inférieur à la matrice système représentée dans la matrice du noyau. Le conférencier démontre cette méthode en utilisant l'algorithme de Cholesky comme exemple et montre comment l'approximation de rang inférieur de la matrice peut être obtenue à la volée sans calculer la factorisation de Cholesky entière. La qualité de l'approximation dépend de la matrice du noyau et de l'ordre dans lequel les points de données sont traités. Dans l'ensemble, cette section met en évidence l'importance de l'algèbre linéaire numérique dans divers aspects de l'apprentissage automatique.

  • 01:20:00 Dans cette section, Marvin Pförtner explique comment choisir l'ordre des points de données dans lesquels Cholesky les traite pour approximer la matrice du noyau. Il explique que la pré-multiplication de la matrice gramme avec la matrice de permutation, également connue sous le nom de pivotisation complète ou décomposition de Cholesky pivotée, peut conduire à une approximation plus faible avec moins d'itérations. L'idée est d'observer le prédicteur pour les points de données après une itération de Todeschini, puis d'utiliser les informations recueillies pour sélectionner le point de données à observer lors de la prochaine itération. Cette technique est considérée comme un problème d'apprentissage actif et peut fournir un moyen intelligent de traiter simultanément des lignes et des colonnes et ainsi d'explorer la structure générative de la matrice de manière en ligne.

  • 01:25:00 Dans cette section, l'orateur discute de la décomposition en valeurs singulières (SVD) et comment elle résout un problème d'optimisation pour obtenir les meilleurs facteurs pour une approximation matricielle. Cependant, tronquer un SVD pourrait être arbitrairement mauvais, donc une approche heuristique est utilisée pour approximer le SVD et calculer une décomposition propre. Il existe également un besoin d'une racine carrée matricielle, qui peut être obtenue par la décomposition de Cholesky. Il est important de prendre en compte la structure lors de la mise en œuvre d'algorithmes d'algèbre linéaire numérique dans la pratique, car cela peut considérablement accélérer le processus.

  • 01:30:00 Dans cette section, Marvin Pförtner explique comment la structure de l'algèbre linéaire numérique affecte la régression du processus gaussien. La régression de processus gaussien est intensive en calcul et nécessite la résolution de grands systèmes d'équations, ce qui peut être fait en utilisant des techniques d'algèbre linéaire numérique. L'orateur insiste sur l'importance de la stabilité numérique dans la résolution de ces systèmes d'équations pour éviter de perdre en précision dans les résultats finaux.
 

Cours 3 -- Mise à l'échelle des processus gaussiens -- Jonathan Wenger



Numerics of ML 3 -- Scaling Gaussian Processes -- Jonathan Wenger

Jonathan Wenger discute des techniques de mise à l'échelle des processus gaussiens pour les grands ensembles de données dans la vidéo "Numerics of ML 3". Il explore des méthodes itératives pour résoudre des systèmes linéaires et apprendre l'inverse de la matrice, dans le but principal d'atteindre la généralisation, la simplicité/l'interprétabilité, les estimations d'incertitude et la vitesse. Wenger introduit des approximations de rang inférieur à la matrice du noyau telles que la décomposition itérative de Cholesky, Cholesky partiel et les méthodes de gradient conjugué. Il discute également du préconditionnement pour accélérer la convergence et améliorer la stabilité lorsqu'il s'agit de grands ensembles de données. Enfin, il propose d'utiliser une matrice orthogonale Z pour réécrire la trace d'une matrice, ce qui pourrait potentiellement conduire à un temps quadratique pour la mise à l'échelle des processus gaussiens.

Dans la deuxième partie de la conférence, Jonathan Wenger discute de la mise à l'échelle des processus gaussiens (GP) pour les grands ensembles de données dans cette vidéo. Il présente diverses stratégies pour améliorer le taux de convergence des estimations de Monte Carlo pour la régression GP, y compris l'utilisation de préconditionneurs existants pour la résolution du système linéaire pour estimer la matrice du noyau et son inverse. Il introduit également l'idée de temps linéaire GP par approximation variationnelle et aborde la quantification de l'incertitude à l'aide de la méthode du point inducteur. En utilisant ces stratégies, la mise à l'échelle vers des ensembles de données contenant jusqu'à un million de points de données est possible avec le GPU, ce qui facilite l'optimisation rapide des hyperparamètres.

  • 00:00:00 Dans cette section de la vidéo, Jonathan Wenger explique comment mettre à l'échelle les processus gaussiens pour de grands ensembles de données à l'aide de méthodes itératives pour résoudre des systèmes linéaires. Il explique que ces méthodes peuvent être considérées comme des algorithmes d'apprentissage pour l'inverse de la matrice, qui est l'objet principal nécessaire pour calculer la postérieure GP. Wenger décrit également les principaux objectifs de la régression, notamment la généralisation, la simplicité/l'interprétabilité, les estimations d'incertitude et la rapidité. Il note que les médecins généralistes sont d'excellents exemples de modèles qui peuvent atteindre tous ces objectifs, mais ils sont coûteux à former et à faire des inférences. Cependant, en développant des méthodes modernes pour résoudre des systèmes linéaires avec des matrices de noyau, l'inférence de temps quadratique pour le GPS peut être effectuée plus rapidement que le temps cubique. Wenger laisse également entendre qu'il existe un moyen de le faire encore plus rapidement en temps linéaire, mais reconnaît qu'il peut y avoir certains inconvénients dont il discutera plus en détail dans la prochaine conférence.

  • 00:05:00 Dans cette section, l'orateur discute des limites de la décomposition de Scholesky pour les processus gaussiens lorsqu'il s'agit de grands ensembles de données, car elle devient prohibitive en termes de complexité temporelle et spatiale. Il propose des méthodes itératives pour réduire la complexité au carré du nombre de points de données, montrant comment Cholesky itératif est utilisé pour l'approximation de rang inférieur de la matrice du noyau. Cependant, le problème n'est pas d'approximer la matrice du noyau elle-même, puisque la régression GP nécessite une approximation de l'inverse de la matrice du noyau ou de la matrice de précision, donc la question est de savoir si la formulation itérative du Cholesky peut être interprétée comme une approximation de la précision. Matrice pour les résolutions linéaires.

  • 00:10:00 Dans cette section, l'orateur explore une forme itérative de la décomposition de Cholesky, qui peut être utilisée pour des approximations de rang inférieur aux matrices du noyau. En suivant des quantités supplémentaires, il est possible d'obtenir une approximation inverse de la matrice, qui est également de rang inférieur, similaire au Cholesky. L'orateur montre comment calculer cette approximation inverse de manière récursive, en termes de facteurs de Cholesky et de résidu. Cette méthode itérative peut être utilisée comme algorithme d'inversion de matrice approximative pour les matrices définies positives, telles que les matrices de noyau, et constitue un outil utile pour la mise à l'échelle des processus gaussiens.

  • 00:15:00 Dans cette section, l'orateur discute de l'utilisation de la méthode partielle de Cholesky pour la mise à l'échelle des processus gaussiens. La méthode consiste à modifier la décomposition de Cholesky avec un facteur et à la multiplier par un vecteur. Il en résulte un processus itératif qui produit une approximation inverse en ajoutant des produits externes de vecteurs. L'analyse de la complexité montre qu'elle est aussi coûteuse que l'approximation de la matrice elle-même. L'orateur compare également la méthode de Cholesky partielle à la régression GP et souligne l'importance de sélectionner les bons points de données ou vecteurs unitaires pour améliorer le processus d'apprentissage.

  • 00:20:00 Dans cette section, Jonathan Wenger explique l'importance de sélectionner les bons points de données lors de l'approximation de la matrice du noyau pour les processus gaussiens (GP). Il illustre comment une sélection aléatoire de points de données à conditionner peut entraîner un processus d'apprentissage plus lent. Il introduit la "méthode des gradients conjugués", conçue à l'origine pour résoudre des systèmes linéaires dans la régression GP. Cette méthode reformule le problème de ax=B, où a est une matrice noyau et B est un vecteur de taille n, en un problème d'optimisation quadratique, ce qui équivaut à résoudre le système linéaire ax=B. En prenant le gradient de la fonction quadratique et en le mettant à zéro, la colonne à ax est égale à B, et un résidu peut être défini comme B moins ax, qui peut être utilisé pour trouver un moyen meilleur et plus efficace de sélectionner des points de données pour accélérer le processus d'apprentissage.

  • 00:25:00 Dans cette section, Jonathan Wenger discute de l'utilisation des directions conjuguées pour l'optimisation dans les processus gaussiens. Il explique qu'en modifiant la direction dans laquelle nous marchons, nous pouvons converger au plus en n étapes lorsque nous utilisons des directions conjuguées. Pour commencer, il utilise le gradient négatif comme premier pas dans la direction de descente la plus raide et modifie les pas pour satisfaire la condition de conjugaison. Il présente l'algorithme et explique ses parties de haut niveau, y compris le critère d'arrêt basé sur la norme du gradient.

  • 00:30:00 Dans cette section, Jonathan Wenger discute de la méthode des gradients conjugués, qui est une méthode d'approximation de l'inverse lors de la résolution de plusieurs systèmes linéaires pour la covariance a posteriori. La méthode des gradients conjugués construit une approximation de l'inverse, qui est de rang bas au même titre que le Swarovski partiel. La mise à jour de l'estimation de la solution implique une direction conjuguée di, et la matrice CI se rapproche de l'inverse avec la forme de toutes les directions de recherche précédentes empilées en colonnes. Cette méthode permet de résoudre rapidement le système de scénarios, et sa structure de rang inférieur en fait une méthode efficace pour mettre à l'échelle les processus gaussiens.

  • 00:35:00 Dans cette section, l'orateur compare la méthode partielle de Scholastic à la méthode du gradient conjugué pour l'inférence de processus gaussien. La méthode du gradient conjugué converge beaucoup plus rapidement, et l'orateur explique que les "actions" utilisées dans la méthode du gradient conjugué sondent la matrice d'une manière différente, ce qui permet une meilleure convergence. Cependant, l'orateur note qu'il est important d'analyser la vitesse de convergence de la méthode, ce qui nécessite une compréhension des valeurs numériques, en particulier la précision de la machine et le nombre de conditions. Le nombre de condition est la valeur propre maximale divisée par la valeur propre minimale en termes absolus et mesure l'amplification d'erreur inévitable lors de la mise en œuvre d'algorithmes d'inversion.

  • 00:40:00 Dans cette section, Jonathan Wenger discute de la stabilité et du comportement de convergence des méthodes de résolution de systèmes linéaires avec des matrices noyaux, telles que la méthode du gradient conjugué ou la décomposition de Cholesky. La stabilité est déterminée par le nombre de condition de la matrice, qui dépend de ses valeurs propres, et plus le nombre de condition est grand, plus la méthode est instable. Le comportement de convergence est déterminé par le nombre de conditions de la matrice et le plus grand divisé par la plus petite valeur propre. Plus le nombre de conditions est proche de un, plus la convergence est lente. Malgré le nombre de conditions modérément élevé de la matrice du noyau avec un millier de points de données, Wenger montre que la méthode du gradient conjugué converge toujours rapidement en quelques centaines d'itérations par rapport à la taille du problème.

  • 00:45:00 Dans cette section, Jonathan Wenger discute de la mise à l'échelle des processus gaussiens et de l'impact du bruit d'observation sur la convergence. Lorsque le bruit d'observation diminue, la convergence de CG ralentit en raison de l'explosion du nombre de conditions de la matrice du noyau. Le nombre de condition est la plus grande valeur propre divisée par la plus petite valeur propre, et à mesure que les points de données se rapprochent les uns des autres, le nombre de condition explose. Pour résoudre ce problème, le préconditionnement peut être utilisé pour approximer la matrice du noyau, en supposant que le stockage de la matrice est plutôt bon marché par rapport au stockage de la matrice réelle. En évaluant efficacement l'inverse de l'approximation, le préconditionneur peut remplacer le problème d'origine par un problème plus facile à résoudre, ce qui entraîne une convergence plus rapide de CG.

  • 00:50:00 Dans cette section, Jonathan Wenger discute du concept de préconditionnement dans la mise à l'échelle des processus gaussiens pour une résolution de système linéaire plus efficace. Il utilise l'exemple des méthodes d'apprentissage probabiliste pour expliquer comment la connaissance préalable d'un problème peut faciliter sa résolution, et de même, le préconditionnement transforme un problème pour qu'il soit plus proche de la matrice d'identité et donc plus facile à résoudre. En utilisant un préconditionneur, le numéro de condition du système est abaissé, ce qui accélère le CG et le rend plus stable. Wenger démontre l'efficacité du préconditionnement en utilisant un préconditionneur de rang inférieur plus diagonal et un SVD partiel pour résoudre un système linéaire à grande échelle avec 100 000 points de données en sept minutes.

  • 00:55:00 Dans cette section, l'orateur discute de l'utilisation du gradient conjugué préconditionné (CG) pour résoudre des systèmes linéaires lors de l'optimisation des hyperparamètres pour Cholesky. Afin d'évaluer la perte et de calculer son gradient, nous devons résoudre des systèmes linéaires et calculer des traces. Cependant, le calcul de la trace implique n multiplications matrice-vecteur, ce qui est trop coûteux pour les grands ensembles de données. Pour résoudre cela, l'orateur propose d'utiliser une matrice orthogonale Z telle que cx Z(transposée) = matrice identité, permettant de réécrire la trace de a comme la trace de Z(transposée) xax Z. Cette méthode d'approximation pourrait potentiellement conduire à temps de mise à l'échelle des processus gaussiens.

  • 01:00:00 Dans cette section, le présentateur aborde le défi de la mise à l'échelle du calcul de la trace de la matrice du noyau, qui implique d'effectuer plusieurs multiplications matrice-vecteur. Une solution potentielle consiste à randomiser le calcul en dessinant des vecteurs aléatoires, mis à l'échelle avec la racine carrée de la dimension, puis en calculant la covariance d'identité. Avec la covariance du vecteur aléatoire approximée, la trace peut être calculée, ce qui revient à résoudre le problème d'origine sans vecteurs aléatoires. Cependant, l'utilisation d'estimateurs de Monte Carlo dans cette méthode est insuffisante pour les grands ensembles de données car elle nécessite des dizaines de milliers de vecteurs aléatoires, ce qui ralentit l'optimisation des hyperparamètres.

  • 01:05:00 Dans cette section, Jonathan Wenger discute de la mise à l'échelle des processus gaussiens (GP) pour les grands ensembles de données. Il explique que les préconditionneurs existants pour la résolution du système linéaire peuvent être utilisés pour estimer la matrice du noyau et son inverse pour traiter le problème de mise à l'échelle des données. L'utilisation du préconditionneur avec Cholesky partiel ou l'estimation de trace stochastique aide à estimer la trace. En utilisant les mêmes informations, on peut également estimer le gradient du déterminant logarithmique. En utilisant ces stratégies, la mise à l'échelle vers des ensembles de données contenant jusqu'à un million de points de données est possible avec le GPU. Wenger note que la pré-formation consiste à utiliser un petit ensemble de données comme tremplin pour optimiser les paramètres hybrides.

  • 01:10:00 Dans cette section, l'orateur discute de différentes stratégies pour améliorer le taux de convergence des estimations de Monte Carlo pour la régression de processus gaussien. En héritant du taux de convergences de préconditionnement, il est possible de converger plus rapidement vers la vraie valeur de manière exponentielle ou polynomiale. Le choix des actions pour observer la matrice du noyau par la multiplication des vecteurs matriciels peut également affecter la rapidité avec laquelle la convergence peut être atteinte. Par conséquent, afin de développer des algorithmes numériques rapides pour le processus gaussien, une expertise du domaine est nécessaire, qui peut être fournie par des préconditions ou le choix d'actions pour converger rapidement. De plus, l'idée de temps linéaire GP par approximation variationnelle est introduite, ce qui implique de compresser des données de grande dimension dans un ensemble de données d'apprentissage plus petit pour les résumer de manière plus efficace.

  • 01:15:00 Dans cette section, Wenger discute de l'utilisation des processus gaussiens et de la façon dont ils peuvent être mis à l'échelle efficacement. L'idée est de résumer les données d'apprentissage pour fournir une approximation directe de la postérieure, qui ne prend que I au carré n, où I est le nombre d'entrées inductrices et n est la taille des données d'apprentissage. Cependant, les méthodes itératives nécessitent une optimisation des hyperparamètres, qui doit également être prise en compte. Des méthodes stochastiques telles que l'optimisation par lots ou sdd peuvent être utilisées dans ce cas, qui peuvent être optimisées rapidement à l'aide d'un optimiseur préféré. Toutes les opérations essentielles sont I au cube ou I au carré fois n, à l'exception de l'évaluation de la matrice du noyau, qui est l'opération la plus coûteuse.

  • 01:20:00 Dans cette section, l'orateur aborde la question de la quantification de l'incertitude avec la mise à l'échelle des processus gaussiens à l'aide de la méthode des points inducteurs, qui nécessite de définir a priori le nombre de points inducteurs pour l'ensemble de données. Au fur et à mesure que l'optimiseur recherche de meilleurs points de données récapitulatifs, la quantification de l'incertitude qui en résulte devient significativement différente du véritable processus gaussien. Alors que les méthodes itératives peuvent contrôler la précision de l'approximation jusqu'à la fin du temps, la méthode du point inducteur nécessite de contrôler la fidélité de l'approximation avant l'optimisation. L'orateur pose la question de savoir si une méthode peut être conçue où la quantification de l'incertitude peut être fiable à n'importe quel point de l'approximation, quel que soit le temps de calcul.
 

Cours 4 -- Processus gaussiens sensibles au calcul -- Jonathan Wenger



Numerics of ML 4 -- Processus gaussiens sensibles au calcul -- Jonathan Wenger

Dans cette vidéo sur Numerics of ML, Jonathan Wenger discute des processus gaussiens sensibles au calcul et de leur capacité à quantifier l'erreur d'approximation et l'incertitude dans les prédictions. Il explore l'importance de choisir les bonnes actions et comment les gradients conjugués peuvent réduire considérablement l'incertitude et accélérer l'apprentissage. Wenger parle également de l'utilisation d'approximations GP en temps linéaire basées sur des points inducteurs, mais met en évidence les problèmes qui découlent de ces approximations. Enfin, il discute de la mise à jour des croyances sur les poids représentatifs et de l'utilisation d'algorithmes d'apprentissage probabiliste pour résoudre l'erreur dans les poids représentatifs. Dans l'ensemble, la vidéo démontre l'efficacité des processus gaussiens sensibles au calcul pour améliorer la précision des prédictions en tenant compte des incertitudes de calcul.

Jonathan Wenger discute également du processus gaussien sensible au calcul et de sa complexité dans cette vidéo. Il explique qu'il suffit de calculer et de stocker le quadrant supérieur de la matrice du noyau, et que le coût de calcul de l'algorithme est proportionnel à la taille de ce quadrant. Le processus gaussien peut être utilisé sur des ensembles de données de taille arbitraire, tant que les calculs ne ciblent que certains points de données, brouillant la frontière entre les données et le calcul. Wenger soutient que le GP peut être modélisé pour tenir compte de cette situation en conditionnant sur les données projetées. Il introduit un nouveau théorème qui permet une quantification exacte de l'incertitude avec un modèle approximatif. Enfin, il donne un aperçu de la conférence de la semaine prochaine sur l'extension du modèle GP aux cas où une loi physique régit partiellement la fonction apprise.

  • 00:00:00 Dans cette section, Jonathan Wenger parle de l'aboutissement final de leurs conférences sur les processus gaussiens, où il montre comment effectuer une quantification exacte de l'incertitude en temps arbitraire. Il explique que cette approche permet aux utilisateurs de toujours quantifier à quel point ils sont éloignés de la fonction qu'ils essaient d'apprendre, quelle que soit la quantité de calculs qu'ils mettent en œuvre ou quel que soit leur budget. En réinterprétant les algorithmes des cours précédents en tant qu'agents d'apprentissage, ils sont capables de quantifier l'erreur d'approximation, qui est introduite dans la prédiction à posteriori. De plus, ils discutent de ce que signifie observer des données à travers un ordinateur et du débat philosophique qui l'entoure.

  • 00:05:00 Dans cette section, Jonathan Wenger explique l'importance de choisir les bonnes actions lorsqu'il s'agit de processus gaussiens sensibles au calcul. Il montre que le choix des actions peut réduire considérablement l'incertitude et accélérer le processus d'apprentissage des phénomènes prédits. De plus, il explore la méthode des gradients conjugués comme moyen de trouver de meilleures actions lors de la résolution de systèmes linéaires ou de la minimisation de fonctions quadratiques. En tenant compte de la géométrie du problème, les gradients conjugués peuvent converger vers une solution en un petit nombre d'étapes.

  • 00:10:00 Dans cette section de la vidéo, Jonathan Wenger discute des processus gaussiens sensibles au calcul et de la façon dont ils diffèrent des autres méthodes d'approximation. Il parle de l'opération la plus coûteuse dans les méthodes d'approximation inverse du gradient partiellement conjugué et du ciel partiel étant la multiplication matrice-vecteur. Il taquine ensuite l'idée d'approximations GP en temps linéaire qui sont basées sur l'induction de points en tant que points de données récapitulatifs, et il discute des problèmes qui découlent d'une approximation en temps linéaire. Wenger présente ensuite l'inférence GP consciente du calcul, qui aborde les problèmes de quantification exacte de l'incertitude et indique que ce sont des recherches de pointe qui seront présentées au NURBS plus tard cette année.

  • 00:15:00 Dans cette section, Jonathan Wenger discute du processus gaussien sensible au calcul et de la manière de quantifier l'erreur d'approximation résultant de l'utilisation de méthodes itératives pour résoudre un système linéaire de poids représentatifs. Il explique que les fonctions du noyau dans le modèle GP encodent des hypothèses sur ce à quoi ressemble la vraie fonction, et que les solveurs itératifs approximent ces poids pour construire une prédiction moyenne a posteriori. En quantifiant cette erreur d'approximation de manière probabiliste, il est possible d'ajouter l'incertitude supplémentaire à la prédiction, ce qui peut améliorer la précision du modèle. Wenger donne également un bref récapitulatif de l'algèbre linéaire des distributions gaussiennes et comment elles facilitent les calculs en théorie des probabilités, en particulier en ce qui concerne le conditionnement et les observations.

  • 00:20:00 Dans cette section, Jonathan Wenger discute des propriétés des distributions gaussiennes et de la manière dont elles peuvent être utilisées pour déterminer la distribution a posteriori sur une variable X compte tenu des observations Y. En combinant les propriétés de mise à l'échelle et de marginalisation, les processus gaussiens peuvent être utilisés pour quantifier l'erreur d'approximation dans les estimations des poids représentatifs. Wenger explique comment une distribution gaussienne antérieure peut être mise à jour et utilisée pour connaître les vrais poids représentatifs, qui ne peuvent pas être observés directement. La propagation et l'orientation d'une courbe en cloche gaussienne peuvent être utilisées pour déterminer la direction dans laquelle rechercher les vrais poids représentatifs.

  • 00:25:00 Dans cette section, Jonathan Wenger explique comment observer indirectement un point noir dans un processus gaussien sensible au calcul en utilisant un résidu et une transformation vectorielle. Il montre comment appliquer le théorème d'inférence gaussien affine pour calculer la distance entre les représentations et les poids estimés. Le processus consiste à regrouper la croyance sur une ligne orthogonale et à développer une croyance de probabilité unidimensionnelle, qui est utilisée pour trouver les poids représentés. Wenger explique également comment sélectionner une ligne rouge plus informative qui s'aligne sur la croyance antérieure pour parvenir à une solution plus précise.

  • 00:30:00 Dans cette section, Jonathan Wenger discute d'un algorithme pour mettre à jour une croyance sur les poids représentatifs dans les processus gaussiens sensibles au calcul grâce à une observation faite par une action multipliée par un résidu. Il explique que la mise à jour implique une inférence gaussienne affine et souligne les éléments clés du processus de mise à jour. Bien que l'algorithme soit similaire à CG et Cholesky partiel, il note que le choix de l'a priori est toujours un problème qui doit être résolu, car il doit être lié à l'endroit où se situent les véritables poids représentatifs pour obtenir une bonne estimation de l'erreur. Wenger propose que le GP prior et les hypothèses faites soient liés aux poids représentatifs car ils sont impliqués dans l'inverse de la matrice du noyau, ce qui les rend significatifs dans le GP prior.

  • 00:35:00 Dans cette section, Jonathan Wenger explique comment comprendre à partir de quelles données de distribution ont été générées avant de faire des observations avec un processus gaussien (GP). En supposant une distribution sur f, Wenger explique que les étiquettes sont distribuées selon la moyenne nulle lors de l'utilisation d'un prior gaussien à moyenne nulle et varient selon la matrice du noyau plus le bruit indépendant, qui fait partie du modèle d'observation. Wenger discute ensuite de la recherche des représentants à l'aide d'un algorithme d'apprentissage probabiliste qui met à jour l'a priori en se projetant sur les actions. Enfin, Wenger explique comment résoudre le problème de la nécessité de l'inverse de K hat antérieur calibré en calculant une distribution de l'étoile mu évaluée à un point de données, qui est une fonction linéaire de l'étoile V.

  • 00:40:00 Dans cette section, Jonathan Wenger explique les processus gaussiens sensibles au calcul et comment tenir compte des incertitudes de calcul. Il discute de l'idée de marginalisation, où plusieurs options pour une variable aléatoire sont considérées et une prédiction moyenne a posteriori qui prend en compte toutes les estimations de poids représentatives possibles est calculée. Il explique comment fonctionne la marginalisation linéaire et comment elle ajoute une incertitude supplémentaire à la covariance. Wenger poursuit ensuite en discutant de l'interprétation de l'incertitude d'un GP en tant qu'estimation d'erreur moyenne et de la manière dont l'incertitude de calcul peut également être considérée comme une estimation d'erreur. Dans l'ensemble, la section explique le calcul de l'incertitude combinée qui inclut l'erreur sur la vraie fonction et l'erreur sur les poids représentatifs en une seule estimation.

  • 00:45:00 Dans cette section, l'orateur discute des processus gaussiens sensibles au calcul, qui combinent l'erreur résultant du manque de données observées avec l'erreur de ne pas avoir effectué suffisamment de calculs pour apprendre la prédiction. L'orateur montre deux exemples de ce processus en action avec les actions Ed Cholesky et CG. La méthode proposée appelée GP calcule la postérieure et combine une croyance représentative avec l'initialisation pour obtenir des prédictions plus précises grâce au suivi de l'incertitude. La méthode est simple et efficace, comme le montrent l'incertitude de calcul réduite et l'approximation plus proche de la vraie moyenne a posteriori dans les graphiques tracés.

  • 00:50:00 Dans cette section, l'orateur discute des processus gaussiens sensibles au calcul et de l'utilisation de la croyance sans avoir besoin d'inverser la matrice du noyau. Ils choisissent une action dans une direction spécifique et observent à quel point ils sont proches des deux poids représentés dans le sous-espace choisi, ce qui affecte la rapidité avec laquelle ils convergent vers les poids représentés. Pour mettre à jour l'estimation des poids représentatifs, ils observent le résidu projeté et calculent la direction à suivre. Ils calculent également une approximation de rang inférieur et mettent à jour leur estimation des représentants et la matrice de précision. Ils appliquent les mêmes quantités en utilisant l'Alaska partiel et le CG, choisissent des actions vectorielles unitaires pour récupérer certaines actions et conçoivent une méthode comme la méthode en temps linéaire qui pèse les points de données en fonction de la fonction noyau centrée sur un point inducteur.

  • 00:55:00 Dans cette section, Jonathan Wenger discute des processus gaussiens (GP) sensibles au calcul et les compare avec le GP conditionnel d'entraînement entièrement indépendant (FITC-GP). Il présente les actions vectorielles du noyau, qui résolvent certains des problèmes avec FITC-GP, mais sont denses, ce qui entraîne une complexité de N au carré et, par conséquent, elles ne sont pas rentables. Wenger montre qu'en prenant des actions spécifiques qui ne ciblent qu'une partie des points de données, ils peuvent réduire la complexité nécessaire au calcul de la matrice du noyau. Au final, la GP computationnelle a de meilleures performances et de telles actions s'avèrent être une approche utile pour un calcul évolutif avec une grande précision.

  • 01:00:00 Dans cette section, Jonathan Wenger discute du processus gaussien sensible au calcul et de sa complexité. Il montre qu'il suffit de calculer et de stocker le quadrant supérieur de la matrice du noyau, et par conséquent, le coût de calcul de l'algorithme n'est proportionnel qu'à la taille de ce quadrant. De plus, il souligne que l'algorithme peut être utilisé sur des ensembles de données de taille arbitraire, tant que les actions qui ont des zéros dans le quadrant inférieur sont choisies pour cibler uniquement certains points de données avec calcul. Wenger soutient que cela brouille la distinction entre les données et le calcul, car seules les observations ciblées pour le calcul sont considérées comme des données. Enfin, il note que le processus gaussien peut être modélisé pour tenir compte de cette situation en conditionnant sur des données projetées.

  • 01:05:00 Dans cette section, Jonathan Wenger explique que les processus gaussiens (GP) peuvent être considérés de deux manières : comme un modèle plus précis de ce qui se passe ou comme un outil numérique probabiliste qui quantifie l'erreur introduite par approximation et prend en compte dans les prévisions. Il poursuit ensuite en discutant de l'interprétation des erreurs au carré en tant que mesures probabilistes et de la manière dont la combinaison a posteriori peut être utilisée comme outil de prédiction. Wenger introduit également un nouveau théorème qui permet une quantification exacte de l'incertitude avec un modèle approximatif, permettant aux utilisateurs de faire confiance à leur quantification de l'incertitude de la même manière qu'ils font confiance aux processus gaussiens.

  • 01:10:00 Dans cette section, Jonathan Wenger explique que les processus gaussiens (GP) peuvent être approximés en concevant un algorithme d'apprentissage, qui peut quantifier de manière probabiliste l'erreur de l'algorithme et pousser l'erreur sur le GP postérieur utilisé pour faire des prédictions, permettant pour une quantification exacte de l'incertitude quelle que soit la puissance de calcul utilisée. Wenger note également que bien que différentes variantes de la méthode existent, elles fournissent une quantification exacte de l'incertitude tant que les actions sont linéairement indépendantes. Enfin, Wenger donne un aperçu de la conférence de la semaine prochaine, dans laquelle Jonathan discutera de l'extension du modèle GP aux cas où une loi physique régit partiellement la fonction apprise.
 

Cours 5 -- Modèles d'espace d'état -- Jonathan Schmidt



Numériques de ML 5 -- Modèles d'espace d'état -- Jonathan Schmidt

Dans cette section, Jonathan Schmidt présente les modèles d'espace d'état et leur application à l'apprentissage automatique. Il explique que les modèles d'espace d'états sont utilisés pour modéliser des systèmes dynamiques complexes, qui ne sont que partiellement observables et impliquent des interactions hautement non linéaires. Le cours couvre la représentation graphique des modèles d'espace d'états et les propriétés importantes de la propriété de Markov et des mesures conditionnellement indépendantes. Schmidt présente différents algorithmes pour calculer diverses distributions telles que les distributions de prédiction, de filtrage et de lissage, qui sont utilisées pour estimer l'état d'un système, en utilisant des mesures obtenues à différents moments. Le cours couvre également l'implémentation d'algorithmes de filtre de Kalman dans Julia et le calcul d'estimations de lissage dans des modèles d'espace d'états gaussiens linéaires. Enfin, Schmidt discute du filtre de Kalman étendu, qui permet l'estimation de la dynamique non linéaire et des mesures dans les modèles d'espace d'états.

Jonathan Schmidt discute également des modèles d'espace d'états et de leur implémentation à l'aide de code, en se concentrant spécifiquement sur la dynamique non linéaire et le filtre de Kalman étendu. Il démontre également des algorithmes de lissage et des méthodes alternatives de filtrage bayésien, en soulignant leurs avantages et leurs inconvénients. La conférence se termine par une recommandation pour un apprentissage plus approfondi et une anticipation pour la prochaine conférence, où Nathaniel présentera les numériques probabilistes pour simuler des systèmes dynamiques.

  • 00:00:00 Dans cette section, Jonathan Schmidt présente les modèles d'espace d'états et les systèmes dynamiques comme un nouveau centre d'intérêt pour le cours magistral sur les numériques de l'apprentissage automatique. Il explique que les systèmes dynamiques évoluent avec le temps et ne peuvent être observés que partiellement, ce qui les rend difficiles à modéliser. Schmidt fournit des exemples tels que le nombre de cas de COVID-19 et l'estimation de l'orientation des smartphones pour illustrer la structure temporelle et les composants cachés des systèmes dynamiques. Le but ultime est d'utiliser des méthodes probabilistes pour simuler ces systèmes, mais d'abord, un langage et un cadre algorithmique doivent être établis pour découvrir des composants latents à partir de données observables.

  • 00:05:00 Dans cette section, l'orateur discute des modèles d'espace d'états, qui impliquent une tâche d'estimation en ligne où le but est de mettre à jour rapidement l'estimation d'un système dynamique complexe à mesure que de nouvelles données arrivent. Ces modèles ne sont souvent que partiellement observables et impliquent des fonctions et des interactions hautement non linéaires. Pour y parvenir, un cadre algorithmique est nécessaire pour mettre à jour la croyance en conséquence. L'orateur discute de la représentation graphique du langage de modélisation utilisé dans les modèles d'espace d'états, où la séquence de nœuds blancs représente des variables aléatoires modélisant l'état du système, et la boîte rouge représente les données observées. L'état d'un système dynamique est un ensemble de grandeurs physiques qui déterminent l'évolution du système, qui sont suivies et interagissent les unes avec les autres. Les données observées, y, dépendent de l'état actuel et ne sont souvent disponibles que pour certains états de la trajectoire, mais pas pour d'autres.

  • 00:10:00 Dans cette section, Jonathan Schmidt présente les modèles d'espace d'états en tant que cadre probabiliste pour la modélisation de systèmes dynamiques. Il met l'accent sur deux propriétés importantes des modèles d'espace d'états : la propriété de Markov et les mesures conditionnellement indépendantes. À l'aide de ces propriétés, il définit un modèle d'espace d'états comme un modèle bayésien qui comprend une distribution initiale pour le premier état, un modèle dynamique pour les états suivants et un modèle de mesure pour les observations. Schmidt note que ces composants distillés formeront la base du reste de la série de conférences.

  • 00:15:00 Dans cette section, l'orateur explique comment analyser des systèmes à l'aide de modèles d'espace d'états et calcule quatre distributions de probabilités conditionnelles différentes. Celles-ci incluent la distribution de prédiction, la distribution de filtrage, la vraisemblance des données et la distribution de lissage, qui sont calculées pour chaque étape d'une séquence continue. La dérivation consiste à introduire la quantité calculée et à construire une distribution conjointe basée sur ce qui est déjà connu. L'équation de Chapman Kolmogorov est utilisée pour prédire dans le futur compte tenu des mesures passées, et l'étape de correction utilisant le théorème de Bayes est utilisée pour intégrer de nouvelles données dans l'estimation.

  • 00:20:00 Dans cette section, l'orateur explique le concept d'un modèle d'espace d'états et le schéma de prédiction et de mise à jour utilisé. En calculant la distribution prédite via l'équation de Chapman-Homographe, le modèle met à jour la prédiction via le théorème de Bayes. Le locuteur présente alors un pseudo-code pour l'algorithme, qui fonctionne dans une boucle temporelle linéaire sans retour en arrière. L'orateur souligne l'importance de produire une séquence de distributions pour les états actuels compte tenu de toutes les mesures précédentes. Enfin, l'orateur présente un modèle d'espace d'état gaussien linéaire et comment il produit des distributions.

  • 00:25:00 Dans cette section, l'orateur présente des modèles d'espace d'états pour un système gaussien linéaire avec une matrice de covariance de bruit de processus Q et un modèle de mesure avec une matrice de mesure H et une matrice de covariance de mesure R. La conférence explique comment la prédiction et les moments de filtrage du modèle peuvent être calculés à l'aide de l'inférence gaussienne, la distribution postérieure étant une collection compliquée de termes. L'orateur présente ensuite le filtre de Kalman, du nom du scientifique hongrois Rudolph Kalman, qui permet le calcul des moments de prédiction et de filtrage sous forme fermée. Les équations de prédiction et de correction du filtre de Kalman sont présentées, le gain de Kalman étant une quantité importante qui traduit l'information acquise dans l'espace de mesure vers l'espace d'état pour mettre à jour la moyenne de filtrage.

  • 00:30:00 Dans cette section de la vidéo, Jonathan Schmidt présente les modèles d'espace d'état et explique comment les utiliser pour filtrer les trajectoires basées sur des mesures bruitées. Il fournit un exemple de suivi d'une voiture dans un avion 2D à l'aide de mesures GPS et écrit le code dans Julia. Schmidt explique que le modèle dynamique est un modèle gaussien linéaire et que la covariance du bruit de processus implique des termes polynomiaux du pas de temps. Il souligne également que la trajectoire de filtrage n'utilise que des points de données antérieurs et présents et n'est pas informée par l'avenir.

  • 00:35:00 Dans cette section, l'orateur explique l'implémentation du filtre de Kalman pour les modèles d'espace d'état utilisant le code Julia. Il explique comment configurer les modèles de transition et de mesure, prédire la moyenne et la covariance et corriger l'estimation à l'aide du modèle de mesure. L'orateur montre ensuite comment exécuter le filtre de Kalman et fournit une visualisation de l'estimation résultante et de l'incertitude correspondante.

  • 00:40:00 Dans cette section, Jonathan Schmidt explique comment les modèles d'espace d'états sont utilisés pour décrire les systèmes dynamiques et comment ils peuvent être construits à l'aide de modèles gaussiens linéaires qui permettent le calcul de quantités intéressantes à l'aide de l'algèbre linéaire. Il introduit également le concept de lissage des postérieurs, qui fournit la meilleure estimation d'une trajectoire compte tenu de tous les points de données disponibles, et s'appuie sur le filtrage des distributions pour les calculer dans un algorithme récursif rétroactif. Alors que la dérivation des équations de lissage implique la théorie des probabilités et la propriété de Markov, la collection résultante de variables aléatoires gaussiennes facilite le calcul de la distribution de lissage à chaque pas de temps.

  • 00:45:00 Dans cette section, l'orateur explique le processus de calcul des estimations de lissage dans les modèles linéaires d'espace d'état gaussien. Cela implique d'utiliser des opérations de produit vectoriel matriciel et de marginaliser au cours du prochain pas de temps tout en marginalisant pour calculer la postérieure à partir de la postérieure de filtrage. L'algorithme de lissage des estimations est calculé via des boucles car il ne fonctionne que s'il existe un ensemble de données ou une partie fixe de pas de temps à prendre en compte. Le processus consiste à partir de la fin de la série temporelle et à remonter jusqu'au début en calculant le gain de lissage et en l'utilisant pour calculer les moments lisses. L'orateur mentionne également que l'estimation de filtrage coïncide avec l'estimation de lissage à la fin de la série temporelle. L'algorithme de lissage fournit finalement un processus gaussien a posteriori comme a posteriori de lissage.

  • 00:50:00 Dans cette section, l'orateur explique comment calculer les postérieurs du processus gaussien en temps linéaire en faisant des hypothèses qui incluent la transition linéaire, les mesures linéaires, le bruit gaussien additif pour la dynamique et les mesures, et la propriété de Markov. Cependant, tous les processus a posteriori gaussiens ne peuvent pas être calculés à l'aide du filtrage et du lissage gaussiens. L'orateur discute également de la possibilité d'abandonner l'hypothèse gaussienne, mais cela nécessiterait une toute nouvelle classe d'algorithmes. L'étape suivante consiste à examiner des modèles non linéaires utilisant une approximation de Taylor au premier ordre pour linéariser les fonctions, puis à utiliser un filtrage commun.

  • 00:55:00 Dans cette section, Jonathan Schmidt discute des modèles d'espace d'états et du filtre de Kalman étendu, qui est une extension du filtre de Kalman pour la dynamique et les mesures non linéaires. La linéarisation de la dynamique non linéaire et des modèles de mesure est obtenue grâce à l'utilisation de matrices jacobiennes, permettant l'utilisation des équations de filtre de Kalman standard avec quelques modifications. La moyenne prédite est évaluée à la moyenne de filtrage précédente, permettant un calcul facile de la matrice de covariance prédite. Le modèle de mesure est linéarisé de manière similaire et les équations étendues du filtre de Kalman sont dérivées. Schmidt note que le filtre de Kalman étendu est utile lorsqu'il n'est pas possible ou souhaitable de différencier des fonctions non linéaires.

  • 01:00:00 Dans cette section, Jonathan Schmidt explique ce qui se passe si nous ne pouvons pas différencier notre fonction et comment la contourner. Une solution possible consiste à utiliser une différence finie dans le schéma, où nous construisons une différence comme des différences finies standard, puis faisons la même chose. Schmidt construit également le lisseur à racine étendue en examinant les équations lissées et en insérant, comme matrice de transition transposée, la matrice jacobienne de la fonction non linéaire évaluée à la moyenne de filtrage. Schmidt fournit un exemple de code utilisant un modèle d'espace d'état non linéaire d'un pendule, où la dimension d'état est 2 et les mesures sont scalaires. Il établit le modèle dynamique à l'aide d'une transformation non linéaire et discute de la covariance du bruit de procédé.

  • 01:05:00 Dans cette section, Jonathan Schmidt discute des modèles d'espace d'état et de la manière de les implémenter à l'aide de code. Il explique la dynamique non linéaire du système et le modèle de mesure linéaire simple utilisé pour les mesures. Il montre également comment implémenter un filtre de Kalman étendu pour estimer la trajectoire d'un pendule. Le filtre utilise la différenciation automatique pour calculer la matrice jacobienne pour la fonction dynamique non linéaire et le gradient pour la fonction de mesure. L'animation résultante montre la trajectoire prédite et les mesures bruitées.

  • 01:10:00 Dans cette section, Jonathan Schmidt discute de l'estimation de filtrage et du lissage étendu dans les modèles d'espace d'états. L'estimation de filtrage affiche l'estimation d'incertitude dans la zone ombrée, tandis que l'algorithme de lissage range l'estimation de filtrage à l'aide de la différenciation automatique, en calculant le gain de lissage, la moyenne lissée et la covariance lissée. Le lisseur renvoie un processus gaussien marginal postérieur, qui couvre bien la trajectoire de la vérité-terrain dans son incertitude. Schmidt mentionne également des méthodes alternatives pour le filtrage bayésien, telles que le filtre de Kalman non parfumé pour approximer les distributions, et le filtre à particules, qui se rapproche de la vraie postérieure réelle. Bien que ces méthodes aient leurs avantages et leurs inconvénients et puissent être plus difficiles à mettre en œuvre, elles peuvent être efficaces pour les modèles non linéaires ou non gaussiens. Schmidt recommande le livre "Bayesian Filtering and Smoothing" de Simo Särkkä pour ceux qui souhaitent en savoir plus sur ces méthodes.

  • 01:15:00 Dans cette section, le conférencier résume ce qu'il a appris sur les modèles d'espace d'état, leur modèle gaussien linéaire et les filtres de Kalman et de Kalman étendu utilisés pour gérer la dynamique et les mesures non linéaires. La prochaine conférence est recommandée, où Nathaniel présentera un langage puissant pour capturer les lois de la nature et le combiner avec la conférence en une semaine pour apprendre à simuler ces systèmes dynamiques en utilisant des numériques probabilistes via le filtrage et le lissage bayésiens. L'orateur conclut en demandant des commentaires et en remerciant les auditeurs pour leur temps.
 

Cours 6 -- Résolution d'équations différentielles ordinaires -- Nathanael Bosch



Numériques de ML 6 -- Résolution d'équations différentielles ordinaires -- Nathanael Bosch

Nathanael Bosch couvre le concept d'ODE dans l'apprentissage automatique, qui décrit la dérivée d'une fonction compte tenu de ses systèmes d'entrée et de modèle qui évoluent dans le temps. Il discute des défis de la résolution d'ODE et introduit des méthodes numériques, telles que l'Euler avant et l'Euler arrière, et leurs propriétés de stabilité. Bosch explore différentes méthodes numériques et leurs compromis en termes de précision et de complexité, telles que les méthodes explicites du point médian et les méthodes classiques du quatrième ordre. Il souligne l'importance de l'erreur locale, de l'ordre et de la stabilité de la compréhension pour éviter les problèmes d'utilisation des bibliothèques pour résoudre les ODE.

Cette deuxième partie de la vidéo aborde le problème de l'estimation du champ vectoriel et de la valeur initiale d'une équation différentielle ordinaire (ODE) à l'aide de techniques d'apprentissage automatique. L'orateur explique l'importance d'écrire le modèle génératif et le modèle d'observation des états de l'ODE pour résoudre le problème d'inférence. La fonction de vraisemblance est maximisée en minimisant la vraisemblance logarithmique négative, ce qui donne une estimation de paramètre. Le conférencier démontre cette approche à l'aide d'un modèle SIR-D et discute de l'utilisation de réseaux de neurones pour améliorer l'estimation du taux de contact. L'importance des ODE dans la recherche sur l'apprentissage automatique et leur rôle dans la résolution de problèmes du monde réel sont également mis en évidence.

  • 00:00:00 Dans cette section de la conférence, Nathanael Bosch présente le concept d'équations différentielles ordinaires (ODE) et comment elles sont utilisées dans l'apprentissage automatique. Il définit une ODE comme un moyen de décrire la dérivée d'une fonction compte tenu de son entrée, et explique que souvent dans l'apprentissage automatique, les ODE sont utilisées pour modéliser des systèmes qui évoluent dans le temps. Il fournit des exemples d'endroits où les ODE apparaissent dans l'apprentissage automatique, y compris dans les modèles de diffusion et dans les problèmes d'optimisation. Bosch aborde également les défis de la résolution des ODE, qui nécessitent des solveurs numériques complexes en raison de l'impossibilité de les résoudre parfaitement.

  • 00:05:00 Dans cette section, l'orateur explique comment les ODE sont utilisées pour transformer le bruit en données pour modéliser des distributions complexes, ce qui se fait en normalisant les flux. Il explique également le concept d'ODE neuronaux, qui a suscité de nombreuses recherches et réinterprète les réseaux de neurones résiduels comme des discrétisations d'une chose plus continue. De plus, l'orateur relie les ODE à l'optimisation, en particulier au flux de gradient, sur lequel il est plus facile d'écrire un théorème que la descente de gradient discrète. Enfin, l'orateur explique comment l'inférence de paramètres est un exemple d'utilisation des ODE pour apprendre quelque chose d'inconnu, et dans la prochaine conférence, il interprétera les solutions numériques ODE comme des algorithmes d'apprentissage automatique. L'orateur conclut que même si nous pouvons écrire une solution pour un ODE, cela n'est pas utile en raison du problème d'intégration et des variables inconnues.

  • 00:10:00 Dans cette section, le narrateur présente les équations différentielles ordinaires (ODE) et les problèmes de valeur initiale, qui sont cruciaux pour comprendre de nombreux algorithmes d'apprentissage automatique. Les ODE représentent le taux de changement d'un système au fil du temps, et la valeur initiale est nécessaire pour résoudre le problème. La solution d'une ODE est donnée par une fonction qui dépend de la valeur initiale, et les solutions numériques aux ODE nécessitent une extrapolation pas à pas. Le narrateur présente un problème d'ODE logistique pour la croissance démographique, et la solution est donnée. Le narrateur souligne que l'objectif de la résolution d'un problème de valeur initiale est de trouver la solution pour un point de départ spécifique compte tenu du champ vectoriel des ODE. La difficulté de résoudre les ODE est à la fois de résoudre l'intégrale et de gérer le terme différentiel. Le narrateur suggère de petites tailles d'étapes pour les solutions numériques des ODE afin d'approximer avec précision la vraie solution.

  • 00:15:00 Dans cette section, Nathanael Bosch explique différentes méthodes numériques pour résoudre des équations différentielles ordinaires. La première méthode qu'il présente est l'approximation en série de Taylor d'ordre zéro, où seule la valeur de la fonction au pas de temps actuel est prise en compte pour l'approximation. Cela conduit à la méthode Forward Euler, qui est une formule simple et explicite pour calculer le point suivant dans le temps. Bosch note que bien que cette méthode soit une mauvaise approximation, elle est encore largement utilisée dans les simulations logicielles et dynamiques.

  • 00:20:00 Dans cette section, la vidéo traite de deux méthodes de résolution d'équations différentielles ordinaires (ODE) : la méthode d'Euler vers l'avant et la méthode d'Euler vers l'arrière. La méthode d'Euler avant utilise la pente au point actuel pour approximer la valeur au point suivant, tandis que la méthode d'Euler arrière utilise une approximation en série de Taylor autour de Tau égal à t plus h. La vidéo fournit des exemples de code pour les deux méthodes utilisant l'ODE logistique, qui produisent des solutions raisonnables. Cependant, la vidéo avertit que des équations différentielles plus complexes peuvent nécessiter une attention supplémentaire lors du choix d'un solveur numérique. De plus, la vidéo aborde la complexité des méthodes numériques et l'importance de connaître les algorithmes sous-jacents lors de l'utilisation de packages numériques.

  • 00:25:00 Dans cette section, l'orateur discute de la différence entre les méthodes explicites et implicites dans la résolution des équations différentielles ordinaires (ODE) et de l'importance de la stabilité dans le choix de l'algorithme approprié. Le locuteur compare les méthodes d'Euler avant et d'Euler arrière pour une ODE scalaire simple, x' = λx, où λ est inférieur à zéro. La méthode d'Euler vers l'avant n'est stable que pour les tailles de pas où 1 + hλ est inférieur à un, tandis que la méthode d'Euler vers l'arrière est stable pour toutes les tailles de pas. L'orateur démontre que le choix d'une taille de pas inappropriée peut conduire à un comportement de divergence, soulignant l'importance de la stabilité dans le choix d'une méthode appropriée pour résoudre les ODE.

  • 00:30:00 Dans cette section, Nathanael Bosch discute des différences entre les méthodes d'Euler avant et arrière pour résoudre les équations différentielles ordinaires (ODE). Alors que les deux méthodes utilisent des mathématiques similaires, Euler en arrière nécessite de petites exigences de convergence et peut gérer des zones rigides dans les ODE qu'Euler en avant ne peut pas. La quadrature numérique est nécessaire et il existe de nombreuses façons de le faire. De plus, la construction de X hat, l'approximation de la fonction à un instant donné, est un autre problème pour lequel différentes méthodes donnent des réponses différentes. Dans l'ensemble, le choix de la méthode dépend de facteurs tels que le temps de calcul et la pente attendue de l'ODE.

  • 00:35:00 Dans cette section, Nathanael Bosch explique la formulation générale des méthodes numériques pour résoudre les équations différentielles ordinaires (ODE), qui implique trois variables : bi, Qi et X hats. Il présente également les tableaux de boucher comme un moyen de rendre la discussion sur les différentes méthodes plus compacte et lisible, et souligne que les différentes façons de calculer le bi et le Qi, ainsi que la façon de construire les chapeaux X, sont ce qui rend chaque méthode unique. . Bosch donne des exemples de différentes méthodes numériques, dont la plus simple, Forward Euler, qui satisfait l'équation générale et a un tableau de boucher qui contient des zéros mais qui reste une méthode suffisamment utile. Il introduit également l'Euler en arrière comme une méthode implicite qui n'a pas de zéro et est calculée légèrement différemment de l'Euler en avant.

  • 00:40:00 Dans cette section, la vidéo explore les différentes stratégies qui peuvent être utilisées pour résoudre les équations différentielles ordinaires (ODE). Une suggestion d'un auditeur était de diviser l'intégrale en différents termes et de prendre des mesures entre chaque terme, mais le présentateur explique que cela se traduirait par un algorithme différent avec des propriétés différentes. La vidéo poursuit en démontrant la règle explicite du point médian, qui est proche de faire deux étapes d'Euler, mais pas tout à fait la même. Le présentateur explique que la règle du point médian extrapole à partir du point et réduit ce que l'attaquant Euler a fait pour obtenir une meilleure extrapolation. De plus, la vidéo explore la méthode classique du quatrième ordre, appelée ainsi car il s'agissait de la méthode originale développée par Byron et Kota. Enfin, la vidéo note que bien qu'il y ait une certaine liberté dans le choix des coefficients pour résoudre les ODE, il existe déjà des centaines de méthodes connues sur Wikipedia.

  • 00:45:00 conduit à deux solutions. Dans la méthode Dobre-Fermi, il y a deux lignes à la fin car elle donne deux solutions à chaque étape. Cette méthode est compliquée car elle satisfait plusieurs propriétés et devient plus complexe lorsque le Tableau s'agrandit. L'objectif ne devrait pas être de comprendre comment fonctionne le gradient, mais plutôt de se concentrer sur les propriétés que les coefficients doivent satisfaire. La méthode était motivée par des règles de quadrature, et bien qu'il n'y ait peut-être pas de correspondance directe avec les ODE, elles sont toujours très motivées par des règles de quadrature.

  • 00:50:00 Dans cette section, la vidéo explique comment la résolution d'équations différentielles peut être compliquée en raison des méthodes qui visent l'efficacité en fournissant deux méthodes à la fois avec différents degrés de précision. L'un est plus précis que l'autre, et l'utilisation du plus précis peut aider à estimer l'erreur du moins précis, ce qui peut être utile pour ajuster la taille du pas lors de la résolution de l'ODE tout en satisfaisant une erreur locale. La vidéo mentionne également qu'il existe différents types de méthodes avec des propriétés différentes, et la stabilité est également un facteur à prendre en compte lors du choix d'une méthode pour résoudre un problème. Enfin, la vidéo aborde brièvement l'importance de l'ordre dans la résolution d'équations différentielles.

  • 00:55:00 Dans cette section, Nathanael Bosch discute des différentes méthodes de résolution des équations différentielles ordinaires (ODE) et du compromis entre précision et complexité. Il souligne l'importance de l'erreur locale, qui mesure l'erreur en une seule étape de l'estimation, et comment elle peut être réduite en réduisant la taille de l'étape. Différentes méthodes telles que les méthodes Hard Euler et Explicit Midpoint sont ensuite discutées, chacune avec son propre ordre et taux de convergence d'erreur. Bosch aborde également les diverses cloches et sifflets qui accompagnent l'utilisation de bibliothèques pour résoudre les ODE, telles que la sélection de la taille des étapes et la sélection automatique du serveur, mais avertit qu'il est toujours important de comprendre la stabilité et d'éviter les problèmes potentiels lorsque les choses se cassent.

  • 01:00:00 Dans cette section de la vidéo, l'orateur aborde le problème de l'estimation du champ vectoriel et de la valeur initiale d'une équation différentielle ordinaire (ODE) à partir de données à l'aide de techniques d'apprentissage automatique. Il donne un exemple de modèle épidémiologique dont le but est d'estimer les paramètres bêta, gamma et lambda qui ajustent l'ODE aux données observées. L'orateur explique que l'écriture du modèle génératif et du modèle d'observation pour les états de l'ODE est essentielle pour résoudre le problème d'inférence. Il note que l'estimation des paramètres permet une meilleure compréhension du processus qui a généré les données et que le recoupement des paramètres déduits avec la littérature peut fournir des informations supplémentaires.

  • 01:05:00 Dans cette section, l'orateur discute du problème de l'inférence des paramètres et de la manière de calculer l'estimation du maximum de vraisemblance pour résoudre les équations différentielles ordinaires (ODE). La fonction de vraisemblance est un produit de Gaussiens qui ne peut pas être évalué en raison de l'hypothèse que le vrai X ne peut pas être obtenu, par conséquent une approximation est nécessaire. En supposant que le solveur est assez bon, l'orateur démontre que le branchement d'une solution estimée pour la vraie solution produit un terme évaluable. La fonction de vraisemblance est ensuite maximisée en minimisant la vraisemblance logarithmique négative et la fonction de perte résultante donne une estimation de paramètre. L'orateur conclut avec un exemple utilisant un modèle SIR-D où le nombre d'individus infectés au début est inconnu et doit être estimé.

  • 01:10:00 Dans cette section, l'orateur explique comment effectuer une inférence de paramètres sur un modèle d'équations différentielles ordinaires (ODE). La simulation du modèle ODE est effectuée en en prenant des échantillons bruyants, et deux paramètres sont utilisés pour former une fonction de perte qui est calculée en comparant les lignes du nuage de points aux données réelles. L'optimiseur est utilisé pour parcourir l'estimation initiale et les paramètres, et l'optimiseur L-BFGS est utilisé pour générer des données de sortie. Les données résultantes peuvent être utilisées pour interpréter le modèle et ses paramètres, qui peuvent être comparés à la littérature. Le modèle est ensuite amélioré en faisant varier le taux de contact dans le temps, ce qui le rend légèrement plus complexe, et l'ensemble du processus d'inférence des paramètres est refait.

  • 01:15:00 Dans cette section, Nathanael Bosch aborde les défis de l'estimation du bêta de t, qui décrit une estimation variable dans le temps d'un taux de contact dans les ODE, et souligne la nécessité de meilleurs outils pour résoudre le problème d'estimation. Pour résoudre ce problème, il propose d'utiliser un réseau de neurones pour modéliser le bêta de t et minimiser une fonction de perte L2 dans l'inférence des paramètres. Bien que l'approche du réseau neuronal soit moins interprétable et ne fournisse pas de bonnes estimations de l'incertitude, elle fournit une estimation ponctuelle du taux de contact. De plus, les résultats suggèrent que l'approche du réseau neuronal a encore besoin d'améliorations significatives pour correspondre à l'ajustement du modèle GP, et les incertitudes dans les résultats doivent être prises en compte.

  • 01:20:00 Dans cette section, l'orateur discute de l'approche d'utilisation des réseaux de neurones pour résoudre les ODE et mentionne que bien que la quantification de l'incertitude ne soit pas facilement disponible en utilisant cette méthode, c'est toujours une approche conceptuelle valide. Les estimations du maximum de vraisemblance sont discutées et la possibilité d'ajouter des priors et un échantillonnage afin de fournir une quantification de l'incertitude est mentionnée. L'orateur aborde également le sujet à venir des solveurs numériques probabilistes d'ODE et souligne l'importance des ODE dans la recherche sur l'apprentissage automatique et son rôle dans la résolution de problèmes du monde réel. Les ODE neuronaux sont également brièvement mentionnés comme une approche plus générale et sans structure, mais avec des similitudes dans la fonction de perte et les procédures de formation.