Apprentissage Automatique et Réseaux Neuronaux - page 17

[MetaQuotes]

PyTorch pour Deep Learning & Machine Learning - Cours complet (parties 10-14)

PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique - Cours complet

Partie 10

• 09:00:00 Dans cette section, la vidéo se concentre sur la création d'un jeu de données personnalisé à l'aide de la bibliothèque scikit-learn. Le jeu de données make circles est importé et 1000 échantillons sont créés avec un peu de bruit supplémentaire pour le caractère aléatoire. La longueur de X et Y est imprimée, ce qui indique qu'il existe 1 000 échantillons d'entités et d'étiquettes. Les cinq premiers échantillons de X et Y sont ensuite imprimés, montrant que les données sont déjà numériques et n'ont que deux classes : zéro et un pour la classification binaire. Une base de données pandas est ensuite créée, avec les caractéristiques étiquetées X1 et X2, et l'échantillonnage aléatoire est discuté comme une approche potentiellement utile pour explorer de grands ensembles de données.
  
  
• 09:05:00 Dans cette section du cours, l'instructeur explique l'ensemble de données jouet qui sera utilisé pour s'entraîner à construire un réseau de neurones dans PyTorch pour la classification binaire. L'ensemble de données a été généré à l'aide de scikit-learn et se compose de deux cercles de couleurs différentes représentant les deux classes du problème de classification binaire. L'instructeur montre comment la visualisation des données peut aider à comprendre l'ensemble de données et à préparer la création d'un réseau de neurones. Les formes d'entrée et de sortie du problème sont également abordées, ainsi que la manière de diviser l'ensemble de données en ensembles d'apprentissage et de test, qui seront abordés dans la prochaine section du cours.
  
  
• 09:10:00 Dans cette section, l'instructeur explique l'importance de vérifier les formes d'entrée et de sortie dans l'apprentissage automatique, car elles sont des sources courantes d'erreurs. Ils montrent comment afficher les formes d'entrée et de sortie d'un ensemble de données à l'aide de tableaux NumPy et convertir les données en tenseurs PyTorch. Le processus de conversion des données en tenseurs et de leur division en ensembles de train et de test est une étape cruciale dans l'apprentissage automatique, même pour les ensembles de données jouets comme celui utilisé dans cet exemple. L'instructeur montre comment importer PyTorch et s'assurer que la version utilisée est 1.10, comment convertir des tableaux NumPy en tenseurs PyTorch et comment créer des ensembles d'entraînement et de test pour les données.
  
  
• 09:15:00 Dans cette section, l'instructeur montre comment convertir les données des tableaux NumPy en type flottant 32 par défaut de PyTorch à l'aide de la commande "torch.float". Ne pas le faire peut entraîner des erreurs plus tard. L'instructeur montre ensuite comment diviser les données en ensembles d'entraînement et de test à l'aide de la répartition aléatoire, ce qui est fait à l'aide de la fonction "train_test_split" de scikit-learn. L'exemple de code montre l'ordre dans lequel les fonctionnalités et les étiquettes doivent apparaître lors de leur transmission à la fonction. L'instructeur explique également l'utilisation du paramètre "test_size", où la valeur donnée est le pourcentage de données à utiliser comme données de test, et le paramètre "random_state" qui agit comme une graine aléatoire.
  
  
• 09:20:00 Dans cette section, la vidéo couvre la division des données en ensembles de formation et de test à l'aide de la bibliothèque Scikit-learn dans PyTorch. L'ensemencement manuel du point de torche est réglé pour s'assurer que les mêmes fractionnements aléatoires sont utilisés, en veillant à ce qu'ils soient les mêmes que ceux que vous souhaitez comparer. En utilisant la longueur des ensembles de train et de test, la vidéo explique qu'ils ont respectivement 800 et 200 échantillons, constituant l'ensemble de données avec lequel ils travailleront. L'étape suivante consiste à créer et à choisir un modèle pour classer les points rouges et bleus. Pour ce faire, ils ont mis en place un code agnostique incluant l'appareil de sorte qu'il s'exécute sur un accélérateur, construisent le modèle, définissent la perte et utilisent PyTorch pour créer une boucle d'entraînement et de test qui sera explorée plus en détail dans la section suivante.
  
  
• 09:25:00 Dans cette section, nous apprenons à configurer un GPU pour PyTorch et à créer un code indépendant de l'appareil pour garantir que le code s'exécutera sur un CPU sans aucun problème. Nous passons ensuite à la construction d'un modèle en sous-classant un nn.Module et suivons quatre étapes principales. Tout d'abord, nous créons un modèle qui sous-classe un nn.Module. Deuxièmement, nous créons deux couches linéaires capables de gérer les formes de nos données. Troisièmement, nous définissons une méthode avant qui décrit la passe avant du modèle. Quatrièmement, nous instancions l'instance de notre classe de modèle et l'envoyons au périphérique cible. Nous apprenons que notre modèle sera utilisé pour séparer les cercles rouges et bleus à l'aide d'un réseau de neurones.
  
  
• 09:30:00 Dans cette section du cours, l'instructeur explique comment définir une couche de réseau neuronal capable de gérer les caractéristiques d'entrée. Il poursuit en expliquant que le nombre d'entités requises pour chaque couche dépend de l'ensemble de données utilisé. Dans cet exemple, où X a deux caractéristiques, la première couche est définie comme "n-linéaire" avec n caractéristiques égales à deux, tandis que la deuxième couche est définie avec cinq caractéristiques pour aider le modèle à apprendre plus de modèles. L'instructeur explique également que les caractéristiques internes de la deuxième couche doivent correspondre aux caractéristiques externes de la couche précédente pour éviter les erreurs d'incompatibilité de forme. Enfin, il définit une méthode de Ford qui décrit la passe de Ford et renvoie l'auto-couche deux (qui prend l'auto-couche un et X comme entrées).
  
  
• 09:35:00 Dans cette section, l'instructeur explique comment instancier une instance de la classe de modèle et l'envoyer à l'appareil cible. Il montre comment créer un réseau neuronal multicouche simple, qu'il démontre ensuite sur le terrain de jeu TensorFlow en utilisant deux fonctionnalités d'entrée et en les transmettant à une couche cachée avec cinq neurones, qui alimente une autre couche qui a une fonctionnalité de sortie. Il adapte le réseau à certaines données et la perte de test est d'environ 50 %, ce qui signifie que si le modèle ne faisait que deviner au hasard, il obtiendrait une perte d'environ 0,5, car il n'y a que deux classes.
  
  
• 09:40:00 Dans cette section de la vidéo, l'instructeur utilise un outil de tableau blanc appelé Fig Jam pour représenter visuellement un réseau de neurones pour un problème de classification binaire. L'instructeur explique que dans un problème de classification binaire, deviner au hasard vous donnera une précision d'environ 50 %. Le réseau neuronal est construit à l'aide d'entrées, d'unités cachées et d'une couche de sortie, et l'instructeur insiste sur le fait que la forme des couches doit correspondre. Le terrain de jeu TensorFlow est suggéré comme une façon amusante d'explorer et de se mettre au défi de construire un réseau de neurones sur ce type de données. Plus tard, l'instructeur discute de la réplication du réseau de neurones créé précédemment avec encore moins de code à l'aide de deux couches linéaires capables de gérer les caractéristiques d'entrée et de les mettre à l'échelle pour améliorer l'apprentissage du réseau.
  
  
• 09:45:00 Dans cette section, l'instructeur montre comment répliquer un modèle de réseau neuronal à l'aide de nn.Sequential dans PyTorch. En utilisant nn.Sequential, le code du modèle peut être simplifié, car la majeure partie du code est implémentée en coulisses. L'instructeur explique que l'utilisation de nn.Sequential pour des opérations simples et directes peut être plus efficace que la sous-classification, comme démontré dans une section précédente de la vidéo. Cependant, le sous-classement permet des opérations plus complexes, telles que la construction de passes avant plus complexes. Cette section met en évidence la flexibilité de PyTorch et les différentes façons de créer un modèle. L'instructeur montre également comment transmettre des données à travers le modèle et analyser le dictionnaire d'état.
  
  
• 09:50:00 Dans cette section, l'instructeur montre comment PyTorch crée automatiquement des paramètres de pondération et de biais dans les coulisses lors de la mise en œuvre d'un réseau de neurones à deux couches. L'instructeur souligne le fait que le modèle est instancié avec des nombres aléatoires et que PyTorch modifiera légèrement ces valeurs pendant le processus de rétropropagation et de descente de gradient pour mieux s'adapter ou représenter les données. L'instructeur montre également la complexité potentielle d'avoir de nombreuses couches avec de nombreuses fonctionnalités et comment le suivi de ces valeurs à la main peut devenir verbeux. Enfin, l'instructeur poursuit en faisant des prédictions à l'aide du modèle non formé et souligne l'importance du dépannage et de la visualisation des données.
  
  
• 09:55:00 Dans cette section, la vidéo explique comment choisir une fonction de perte et un optimiseur après avoir créé un modèle pour l'apprentissage en profondeur. Le type de fonction de perte et d'optimiseur nécessaire dépend généralement de la nature de l'ensemble de données sur lequel on travaille. Pour les problèmes de régression, l'erreur absolue moyenne ou l'erreur quadratique moyenne peut être appropriée. Pendant ce temps, pour les problèmes de classification, l'entropie croisée binaire ou l'entropie croisée catégorique pourrait être choisie. La vidéo conclut en notant que la fonction de perte aide à mesurer la précision des prédictions d'un modèle.

Partie 11

• 10:00:00 Dans cette section du cours vidéo, l'instructeur donne un aperçu des diverses fonctions de perte et optimiseurs couramment utilisés dans PyTorch pour la classification des réseaux neuronaux. L'instructeur explique la perte d'entropie croisée binaire, la perte d'entropie croisée, l'erreur absolue moyenne et l'erreur quadratique moyenne, et celles qui sont généralement utilisées pour les tâches de régression par rapport aux tâches de classification. Pour les tâches de classification binaire, les exemples de code fournis incluent la perte BCE torch.nn avec logits et la perte BCE. La vidéo couvre également le concept de logit dans l'apprentissage en profondeur et explore deux optimiseurs couramment utilisés, SGD et Adam. L'instructeur note que bien qu'il puisse y avoir d'autres optimiseurs disponibles, s'en tenir à ces deux peut toujours obtenir de bons résultats sur de nombreux problèmes.
  
  
• 10:05:00 Dans cette section de la vidéo, l'orateur configure la fonction de perte et l'optimiseur dans PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique. La fonction de perte est appelée BCE avec perte logit, qui intègre la fonction d'activation sigmoïde. L'orateur explique que si l'on veut en savoir plus sur les fonctions d'activation dans les réseaux de neurones, des ressources en ligne sont disponibles. L'optimiseur choisi est la descente de gradient stochastique (SGD), avec un taux d'apprentissage de 0,1, et les paramètres sont définis pour mettre à jour les paramètres du modèle par rapport à la perte. Enfin, l'orateur crée une métrique d'évaluation.
  
  
• 10:10:00 Dans cette section, l'instructeur explique l'importance de la précision en tant que métrique d'évaluation et montre comment créer une fonction de précision à l'aide de pytorch. La fonction de précision compare les prédictions aux étiquettes de vérité terrain et renvoie le pourcentage de prédictions correctes sur le nombre total d'échantillons. L'instructeur fournit également un aperçu des étapes impliquées dans une boucle de formation pytorch, y compris la passe avant, le calcul de la perte, l'optimiseur zéro grad, la rétropropagation et la descente de gradient. Les étapes sont énumérées et l'importance de chaque étape est discutée.
  
  
• 10:15:00 Dans cette section, l'instructeur explique comment passer des logits bruts aux probabilités de prédiction aux étiquettes de prédiction. Les sorties brutes du modèle sont appelées logits, qui peuvent être converties en probabilités de prédiction en les transmettant à une fonction d'activation telle que sigmoïde pour la classification binaire et softmax pour la classification multiclasse. Les probabilités de prédiction peuvent ensuite être converties en étiquettes de prédiction soit en les arrondissant pour une classification binaire, soit en prenant l'argmax pour une classification multiclasse. L'instructeur explique également le concept d'une fonction d'activation comme quelque chose de distinct d'une couche et montre comment les données transmises à travers une couche linéaire appliquent une transformation linéaire aux données entrantes via un produit scalaire et un terme de biais.
  
  
• 10:20:00 Dans cette section de la vidéo, l'instructeur explique comment utiliser la fonction d'activation sigmoïde pour transformer la sortie brute d'un modèle, appelée logits, en probabilités de prédiction pouvant être utilisées pour la classification binaire. L'instructeur montre comment utiliser la fonction sigmoïde sur les logits du modèle pour créer des predprobs, qui peuvent ensuite être transmis à une fonction ronde de point de torche pour obtenir des étiquettes de prédiction. Ces étiquettes de prédiction sont utilisées pour déterminer à quelle classe appartient une entrée, en utilisant une limite de décision souvent fixée à 0,5. L'instructeur insiste également sur l'importance d'effectuer cette étape sur les logits bruts pour s'assurer que les probabilités de prédiction sont dans le même format que les données de test.
  
  
• 10:25:00 Dans cette section, la vidéo décrit le processus de transformation des logits bruts du modèle en probabilités de prédiction à l'aide d'une fonction d'activation, puis de leur conversion en étiquettes de prédiction. Les étapes sont illustrées par un peu de code, où y-pred est créé à partir de sondes y-pred en utilisant l'étape complète, y compris les prédictions, les logits aux sondes pred aux étiquettes pred. Les prédictions du modèle sont comparées aux étiquettes de test, et le même format est créé à l'aide de la fonction squeeze. L'étape suivante consiste à créer une boucle d'entraînement et de test, qui consiste à effectuer une passe avant, à calculer la perte et à optimiser les gradients. La vidéo encourage le spectateur à essayer par lui-même avant de passer à la vidéo suivante pour plus d'instructions.
  
  
• 10:30:00 Dans cette section, l'instructeur définit une graine manuelle pour la reproductibilité, en particulier une graine aléatoire CUDA pour les opérations sur un appareil CUDA. Ils passent ensuite à la mise en place des données sur l'appareil cible et à la construction de la boucle de formation et d'évaluation. L'instructeur met en évidence une petite friandise dans la passe avant où les logits bruts sont produits et doivent être passés par torch.round et torch.sigmoid pour les convertir en probabilités de prédiction et en étiquettes. Enfin, ils calculent la perte et la précision, notant que bien que le calcul de la précision ne soit pas nécessaire, il peut être utile de visualiser différentes métriques pendant la formation du modèle.
  
  
• 10:35:00 Dans cette section, la vidéo traite de la différence entre la perte BCE et BCE avec perte logits dans PyTorch. Le BCE avec perte de logits attend des logits comme entrée et combine une couche sigmoïde et une perte de BCE, ce qui le rend plus stable numériquement. D'autre part, la perte BCE attend des probabilités de prédiction comme entrée, donc le sigmoïde de la torche doit être appelé sur les logits pour les convertir en probabilités. La vidéo décrit également les étapes de la boucle d'optimisation PyTorch, y compris la mise à zéro des gradients, la rétropropagation et la mise à jour des paramètres pour réduire les gradients. De même, lors des tests ou des prédictions, le modèle doit être mis en mode inférence et les logits de test doivent être traités en appelant la fonction sigmoïde pour acquérir les probabilités de prédiction.
  
  
• 10:40:00 Dans cette section, l'instructeur explique comment calculer la perte de test et la précision pour le modèle de classification. Pour calculer la perte de test, l'instructeur utilise BCE avec la fonction de perte logit et la compare aux étiquettes de test Y. Pour calculer la précision du test, l'instructeur utilise la fonction de précision sur les variables Y true et Y pred. L'ordre des variables est inversé pour la fonction de précision, car l'instructeur l'a basé sur le package de métriques de scikit-learn. Enfin, l'instructeur imprime le numéro d'époque, la perte d'entraînement et la précision, et teste la perte et la précision toutes les 10e époques. L'instructeur encourage les utilisateurs à exécuter ce code gigantesque et à corriger les erreurs éventuelles.
  
  
• 10:45:00 Dans cette section, l'instructeur discute des résultats de la formation sur modèle de la section précédente, qui n'ont montré aucune amélioration significative de la précision. L'instructeur suggère qu'une précision idéale pour le modèle soit de 100 et une valeur de perte de zéro. Cependant, la précision du modèle actuel est inférieure à 50 %, ce qui équivaut à une estimation aléatoire. Pour déterminer la raison de la mauvaise performance, l'instructeur propose de visualiser les prédictions faites par le modèle. L'instructeur importe une fonction appelée "limite de décision de tracé" à partir d'un fichier de fonction d'assistance à utiliser dans ce processus de visualisation. L'instructeur recommande également une ressource, madewithml.com, pour ceux qui souhaitent en savoir plus sur les bases de l'apprentissage automatique et les opérations ml.
  
  
• 10:50:00 Dans cette section, l'instructeur explique comment télécharger des fonctions d'assistance à partir du référentiel d'apprentissage PyTorch de manière programmatique à l'aide des modules "pathlib" et "request" de Python. L'instructeur montre le processus de vérification si le chemin des fonctions d'assistance existe déjà, et s'il n'existe pas, une demande est faite pour télécharger la fonction d'assistance sous la forme d'un fichier appelé "helper_functions.py". L'instructeur démontre l'importation réussie des méthodes "plot_predictions" et "plot_decision_boundary" à partir de la fonction d'assistance téléchargée, qui sera utilisée plus tard dans le cours. Enfin, l'instructeur effectue un test pour visualiser la fonction d'assistance à l'aide de la fonction "plot_decision_boundary", qui trace avec succès une limite de décision pour l'ensemble d'apprentissage.
  
  
• 10:55:00 Dans cette section de la vidéo, le présentateur discute des limites d'un modèle linéaire dans la séparation des données circulaires avec des lignes droites, comme le montre une visualisation de la limite de décision du modèle. La solution pour améliorer la précision du modèle est d'ajouter plus de couches, c'est-à-dire d'augmenter la profondeur du réseau de neurones, ce qui offre plus de chances d'en savoir plus sur les modèles dans les données. D'autres moyens d'améliorer les performances d'un modèle incluent l'augmentation de la quantité de données d'apprentissage et l'ajustement d'hyperparamètres tels que le taux d'apprentissage et la taille des lots. L'importation et l'utilisation de fonctions d'assistance à partir de scripts Python externes sont également mentionnées comme une pratique courante.

Partie 12

• 11:00:00 Dans cette section, l'instructeur discute des moyens d'améliorer un modèle : ajouter plus d'unités cachées, ajuster plus longtemps, modifier les fonctions d'activation, ajuster le taux d'apprentissage et modifier la fonction de perte. L'instructeur souligne que l'augmentation du nombre de paramètres dans un modèle peut potentiellement aider à mieux représenter les données, mais trop de paramètres peuvent rendre le modèle trop complexe pour un jeu de données simple. L'instructeur illustre également comment l'expérimentation peut aider à améliorer le modèle en modifiant sa structure et ses hyperparamètres. Enfin, l'instructeur montre des exemples graphiques de la façon dont l'ajout de couches, l'augmentation du nombre d'unités cachées, l'ajout de fonctions d'activation et la modification de la fonction d'optimisation peuvent potentiellement améliorer le modèle.
  
  
• 11:05:00 Dans cette section, l'instructeur explique comment améliorer un modèle du point de vue du modèle. Il explique le concept d'hyperparamètres, qui sont des valeurs que les ingénieurs en apprentissage automatique et les scientifiques des données peuvent modifier pour améliorer les résultats du modèle. L'instructeur montre comment modifier les hyperparamètres d'un modèle, tels que le nombre d'unités masquées, le nombre de couches et le nombre d'époques. Il souligne également l'importance de tester ces changements un par un pour identifier celui qui offre l'amélioration ou la dégradation. Enfin, il explique la différence entre les paramètres et les hyper paramètres et pourquoi il est important de faire cette distinction.
  
  
• 11:10:00 Dans cette section, l'instructeur crée un modèle à trois couches avec plus d'unités cachées pour voir si l'entraînement de ce modèle plus longtemps donne de meilleurs résultats. La méthode directe est remplacée pour transmettre les données à travers chaque couche, avec une unité cachée supplémentaire et une couche supplémentaire globale. La méthode qui tire parti des accélérations est également démontrée pour effectuer toutes les opérations à la fois. Une instance du modèle à trois couches est créée et envoyée au dispositif cible, suivie des créations d'une fonction de perte et d'un optimiseur, et d'une boucle d'entraînement et d'évaluation pour le modèle un.
  
  
• 11:15:00 Dans cette section, la vidéo continue à partir de la précédente dans laquelle le nn.module a été sous-classé pour créer un nouveau modèle, Circle Model V1, avec plus d'unités cachées et une couche supplémentaire. Maintenant, la prochaine étape du flux de travail consiste à sélectionner une fonction de perte, et la vidéo utilise nn.BCEWithLogitsLoss() comme avant, avec le même optimiseur, torch.optin.SGD(). La vidéo définit le taux d'apprentissage sur 0,1, le nombre d'époques sur 1000 et place les données sur l'appareil cible (CPU ou GPU). La vidéo montre également une boucle à travers les époques et transmet les données de formation à travers le modèle avec la nouvelle architecture, calcule la perte et met à jour les paramètres à l'aide de l'autograd de la torche.
  
  
• 11:20:00 Dans cette section de la vidéo, l'instructeur passe en revue les étapes d'évaluation de la précision et de la perte du modèle. La fonction de perte prend en compte les valeurs d'étiquettes prévues et les compare aux valeurs d'étiquettes réelles. La fonction de précision est utilisée pour déterminer la précision des prédictions du modèle. L'optimiseur est utilisé pour ajuster les paramètres du modèle afin de créer une meilleure représentation des données. Le test est effectué en appelant la méthode eval() du modèle et en activant le mode d'inférence. Les logits sont créés en transmettant les données d'entrée au modèle, puis les fonctions torch.round() et torch.sigmoid() sont utilisées pour les convertir en prédictions. La perte et la précision sont calculées pour les données de test et imprimées toutes les 100 époques pendant l'apprentissage du modèle.
  
  
• 11:25:00 Dans cette section du cours PyTorch for Deep Learning & Machine Learning, l'instructeur discute des techniques de dépannage lorsqu'un modèle ne fonctionne pas, comme tester un problème plus petit pour voir si le modèle peut apprendre quoi que ce soit. Il suggère de reproduire l'ensemble de données d'une section précédente où un modèle linéaire a pu s'adapter à une ligne droite et de l'utiliser pour voir si le modèle actuel peut apprendre quelque chose, car il ne fait actuellement que deviner et est incapable de tracer une ligne droite pour séparer le données circulaires. L'instructeur mentionne également que certaines méthodes pour améliorer un modèle incluent la modification des hyperparamètres, tels que le nombre de couches et d'unités cachées, et la modification des fonctions d'activation et de perte.
  
  
• 11:30:00 Dans cette section, l'instructeur crée un ensemble de données à l'aide d'une formule de régression linéaire pour voir si le modèle fonctionne sur n'importe quel type de problème. L'ensemble de données est appelé régression x et contient 100 échantillons d'une valeur x par valeur y. L'instructeur crée ensuite des fractionnements d'entraînement et de test pour les données et vérifie leur longueur. Enfin, la fonction de prédictions de tracé du fichier de fonctions d'assistance est utilisée pour inspecter visuellement les données.
  
  
• 11:35:00 Dans cette section, le présentateur discute d'un projet parallèle pour voir si son modèle peut s'adapter à un ensemble de données en ligne droite avant d'essayer d'ajuster un ensemble de données non en ligne droite. Ils ajustent le modèle 1 pour s'adapter au nouvel ensemble de données en modifiant le nombre d'entités en entrée de deux à un pour correspondre aux données, tout en maintenant les entités en sortie à 10 pour donner au modèle autant de paramètres que possible. Ils créent également le modèle 2 à l'aide de la séquence de points NN, qui transmet les données à travers les couches, et configurent une fonction de perte et d'optimisation.
  
  
• 11:40:00 Dans cette section, l'instructeur présente la fonction de perte L1 pour optimiser un problème de régression et utilise l'optimiseur SGD avec un taux d'apprentissage de 0,1 pour optimiser les paramètres du modèle. Après avoir chargé l'ensemble de données et l'avoir placé sur l'appareil cible, le modèle est entraîné pendant mille époques avec une boucle. À chaque époque, la passe avant est effectuée, la perte est calculée et les paramètres sont mis à jour à l'aide des fonctions arrière et pas à pas. La progression de l'entraînement est imprimée avec l'époque, la perte et la perte de test toutes les 100 époques. La perte diminue à mesure que le modèle est optimisé.
  
  
• 11:45:00 Dans cette section de la vidéo, l'instructeur récapitule la section précédente où il a créé un ensemble de données en ligne droite et formé un modèle pour l'adapter. Ils confirment que le modèle apprend quelque chose et suggèrent que les apprenants jouent avec différentes valeurs du taux d'apprentissage pour expérimenter des modèles d'apprentissage automatique. L'instructeur explique ensuite comment activer le mode d'évaluation et faire des prédictions, également appelées inférence. Ils enseignent également comment utiliser la fonction de prédiction de tracé et rencontrent une erreur due au fait que les données ne se trouvent pas sur le même appareil que le modèle, qu'ils résolvent en appelant le processeur de points sur leurs entrées de tenseur.
  
  
• 11:50:00 Dans cette section, l'instructeur présente l'importance de la non-linéarité dans les modèles d'apprentissage automatique et d'apprentissage en profondeur. Les fonctions linéaires seules ne peuvent pas capturer les modèles complexes dans les données qui nécessitent des fonctions non linéaires comme les courbes pour les représenter avec précision. Les réseaux de neurones sont construits en combinant des fonctions linéaires avec des fonctions non linéaires, ou activations, pour modéliser des modèles de données complexes. L'instructeur fait allusion aux vidéos à venir qui couvriront les activations non linéaires et leur rôle dans les modèles d'apprentissage en profondeur.
  
  
• 11:55:00 Dans cette section, l'instructeur discute de la puissance de la non-linéarité dans l'apprentissage automatique et les réseaux de neurones. La non-linéarité est essentielle dans l'apprentissage automatique car les données ne sont pas toujours constituées de lignes droites. L'instructeur montre ensuite comment créer et tracer des données non linéaires à l'aide de la fonction de création de cercles, et convertir les données en temps et former et tester des fractionnements à l'aide de PyTorch et de la fonction de fractionnement de test de formation de sklearn.

Partie 13

• 12:00:00 Dans cette section, l'instructeur d'un cours PyTorch for Deep Learning & Machine Learning introduit la non-linéarité, qui est un élément crucial de la construction d'un modèle. L'instructeur met le spectateur au défi de trouver une fonction non linéaire spécifique dans le module TorchNN, qui peut inclure des couches de regroupement, des couches de remplissage et des fonctions d'activation pour effectuer une opération mathématique sur une entrée. Des exemples d'activations non linéaires telles que sigmoïde à n points et relu à n points sont fournis. L'instructeur montre ensuite comment créer un modèle de classification en utilisant la non-linéarité avec PyTorch. La non-linéarité signifie que le graphique n'est pas une ligne droite, alors que linéaire signifie le contraire.
  
  
• 12:05:00 Dans cette section du cours PyTorch for Deep Learning & Machine Learning, l'instructeur présente le concept de données non linéaires et comment les réseaux de neurones et les modèles d'apprentissage automatique peuvent fonctionner avec des nombres dans des centaines de dimensions, ce qui leur permet de traiter des données non linéaires. Un nouveau réseau de neurones, le modèle de cercle V2, est créé à l'aide de classes avec un constructeur et plusieurs couches qui effectuent des opérations linéaires avec l'ajout d'une fonction d'activation non linéaire appelée "relu". Cette fonction transforme les entrées négatives du modèle à zéro tout en laissant les positifs tels quels. Le nouveau modèle est ensuite passé à travers la fonction sigmoïde pour déterminer la sortie.
  
  
• 12:10:00 Dans cette section, l'instructeur met les téléspectateurs au défi de recréer un modèle de réseau neuronal dans le TensorFlow Playground avec deux couches cachées et cinq neurones, en utilisant la fonction d'activation Rectified Linear Unit (ReLU) au lieu de la fonction d'activation linéaire, qu'ils 'ai utilisé. L'instructeur explique que la fonction d'activation ReLU est une fonction d'activation non linéaire populaire et efficace nécessaire pour modéliser des données non linéaires, ce que les réseaux de neurones sont conçus pour faire. L'instructeur démontre l'effet de la modification du taux d'apprentissage sur la perte d'apprentissage et encourage les téléspectateurs à expérimenter différents taux d'apprentissage pour observer l'effet sur la courbe de perte.
  
  
• 12:15:00 Dans cette section, l'instructeur aborde la création d'un optimiseur et d'une fonction de perte pour un problème de classification binaire à l'aide de PyTorch. Ils définissent la fonction d'activation non linéaire du modèle sur ReLU et créent des graines aléatoires pour CUDA. Ils parcourent ensuite 1000 époques pour former le modèle et calculent la perte et la précision à l'aide du BCE avec une fonction de perte logit et une fonction de précision respectivement. L'instructeur encourage à réfléchir à la façon de fonctionnaliser le code de formation et suggère que cette section vise à développer l'expérience et l'élan nécessaires pour travailler sur des projets PyTorch réels.
  
  
• 12:20:00 Dans cette section, l'instructeur explique le processus d'optimisation du modèle avec la méthode de rétropropagation dans PyTorch. Avant d'effectuer la rétropropagation, les gradients de l'optimiseur sont mis à zéro afin qu'il puisse repartir de zéro. Après avoir exécuté loss.backward(), la méthode step de l'optimiseur est appelée pour effectuer une descente de gradient sur les paramètres du modèle. L'instructeur montre également comment déboguer les paramètres du modèle et explique que la fonction d'activation ReLU n'a aucun paramètre, ce qui la rend efficace. Enfin, l'instructeur imprime la formation et teste la perte, la précision et l'époque pour suivre la progression de l'apprentissage du modèle.
  
  
• 12:25:00 Dans cette section, l'instructeur résout un problème de forme dans le code PyTorch et le corrige en utilisant la fonction squeeze pour supprimer une dimension supplémentaire dans la forme du point logits de test. Ils discutent ensuite de la puissance de la non-linéarité et de la façon dont l'ajout de couches relu a amélioré les performances du modèle, lui permettant potentiellement de tracer une ligne pour séparer les cercles dans l'ensemble de données. L'instructeur insiste également sur l'importance de la visualisation dans l'évaluation du modèle et la réalisation de prédictions, et invite les spectateurs à tracer les limites de décision.
  
  
• 12:30:00 Dans cette section, l'instructeur montre comment utiliser la fonction de limite de décision de tracé pour visualiser les performances d'un modèle non linéaire par rapport à un modèle linéaire. Il est démontré que le modèle non linéaire a une meilleure précision que le modèle linéaire, mais l'instructeur met le spectateur au défi d'améliorer encore plus la précision. L'instructeur passe ensuite à la discussion sur la façon dont les réseaux de neurones utilisent les fonctions linéaires et non linéaires comme outils pour découvrir des modèles dans les données, menant à une démonstration de la façon de créer des tenseurs et d'utiliser des fonctions d'activation non linéaires dans PyTorch.
  
  
• 12:35:00 Dans cette section, l'instructeur explique comment créer des fonctions d'activation personnalisées dans PyTorch en reproduisant les fonctions populaires ReLU et Sigmoid. L'instructeur définit d'abord un type de données de flotteur de torche 32 et visualise une ligne droite tracée en utilisant les valeurs négatives de 10 à 10 sur l'axe des x. La fonction ReLU est ensuite créée à l'aide des fonctions torch.relu et nn.relu en prenant un tenseur d'entrée et en renvoyant le maximum de zéro et x. De même, la fonction sigmoïde est créée en prenant un tenseur d'entrée et en renvoyant un divisé par un plus l'exponentielle de moins x. L'instructeur démontre l'efficacité des fonctions personnalisées ReLU et Sigmoid en les traçant et en les comparant aux fonctions intégrées de PyTorch.
  
  
• 12:40:00 Dans cette section du cours PyTorch, l'instructeur explique l'importance de combiner des fonctions linéaires et non linéaires pour trouver des modèles dans les données afin d'ajuster un ensemble de données. L'idée derrière les réseaux de neurones est d'empiler des couches de ces fonctions pour créer un modèle. Bien qu'il soit possible de créer ces couches à partir de zéro, Pytorch propose des couches pré-construites qui ont été testées en cas d'erreur et qui calculent aussi rapidement que possible dans les coulisses tout en permettant l'utilisation de GPU. L'instructeur discute également de la différence entre la classification binaire, qui implique deux résultats possibles, et la classification multi-classes, qui implique plus de deux résultats possibles. Enfin, la section se termine en réitérant l'importance de la non-linéarité dans les réseaux de neurones et l'instructeur lance un défi pour améliorer son modèle de classification binaire précédent.
  
  
• 12:45:00 Dans cette section, l'instructeur du cours présente la classification multiclasse et les différences entre celle-ci et la classification binaire. La fonction d'activation softmax est utilisée à la place de l'entropie sigmoïde et croisée au lieu de l'entropie croisée binaire. L'instructeur procède ensuite à la création d'un ensemble de données multi-classes 20 à l'aide de la fonction make blobs de scikit-learn.datasets pour générer quatre classes avec deux fonctionnalités chacune. L'écart type central est ajusté pour donner aux clusters un certain caractère aléatoire et les secouer un peu, ce qui rend la tâche un peu plus difficile pour le modèle.
  
  
• 12:50:00 Dans cette section, l'extrait de transcription explique comment préparer les données pour un modèle de classification multi-classes à l'aide de PyTorch. Ils transforment les données en tenseurs et utilisent la fonction train test split de scikit-learn pour diviser les données en ensembles d'apprentissage et de test. Ils visualisent également les données à l'aide de plot.figure et définissent la graine aléatoire pour assurer la reproductibilité. Après avoir créé l'ensemble de données de classification multi-classes, ils déterminent si la non-linéarité est nécessaire pour séparer les données, puis procèdent à la création d'un modèle pour les données.
  
  
• 12:55:00 Dans cette section, l'instructeur explique comment configurer un modèle de classification multiclasse à l'aide de PyTorch. Il explique le processus étape par étape, en commençant par définir la forme de la couche d'entrée et en déterminant le nombre de neurones par couche cachée. L'instructeur explique ensuite comment définir la forme de la couche de sortie, qui nécessite une entité de sortie par classe. Pour créer le modèle, l'instructeur crée une classe appelée "modèle blob" qui hérite de nn.module et définit certains paramètres pour le modèle. Enfin, l'instructeur montre comment initialiser le modèle de classification multiclasse avec des entités d'entrée et des entités de sortie.

Partie 14

• 13:00:00 Dans cette section, l'instructeur aborde la création d'un modèle d'empilement de couches linéaire à l'aide de la méthode nn.Sequential de PyTorch. Pour instancier le modèle, le nombre d'entités en entrée et le nombre de classes en sortie sont accessibles pour déterminer la configuration des couches cachées. L'instructeur configure une pile séquentielle de couches pour transmettre les données à travers chaque couche une par une. Ils fournissent également des instructions sur l'ajout de non-linéarité à l'ensemble de données, puis créent une méthode directe pour permettre à l'entrée de parcourir les couches spécifiées de manière séquentielle. Enfin, une instance du modèle blob est créée avec le nombre approprié d'entités d'entrée et de sortie.
  
  
• 13:05:00 Dans cette section de la vidéo, l'instructeur crée un modèle de classification multiclasse en sous-classant un nn.Module et configure les paramètres pour que le constructeur de classe personnalise les fonctionnalités d'entrée et de sortie. Ils expliquent également que le paramètre des caractéristiques de sortie correspond au nombre de classes dans les données. Pour créer une fonction de perte pour un modèle de classification multi-classes, l'instructeur recherche et trouve la perte d'entropie croisée dans le module torch.nn, qui calcule la perte entre l'entrée et la cible et est utile lors de la formation d'un problème de classification avec des classes C. L'instructeur explique également que le paramètre de poids est utile lorsqu'il s'agit d'un ensemble d'entraînement déséquilibré.
  
  
• 13:10:00 Dans cette section, l'instructeur aborde la création d'une fonction de perte et d'un optimiseur pour la classification multiclasse. Il recommande deux optimiseurs courants, SGD et Adam, mais choisit d'utiliser SGD pour cet exemple. Il met ensuite les téléspectateurs au défi de faire une passe en avant avec le modèle créé dans la vidéo précédente et de considérer quelles sont les sorties brutes d'un modèle. L'instructeur rappelle également aux téléspectateurs de prêter attention aux paramètres de l'appareil, car une erreur d'exécution peut se produire si les tenseurs ne se trouvent pas sur le même appareil. Enfin, il transforme le modèle en mode eval et fait quelques prédictions.
  
  
• 13:15:00 Dans cette section, l'instructeur explique comment convertir les logits de sortie d'un modèle en probabilités de prédiction et en étiquettes de prédiction pour les problèmes de classification à plusieurs classes. Pour ce faire, la fonction softmax est utilisée pour convertir les logits en probabilités de prédiction, puis la prédiction avec la probabilité la plus élevée est considérée comme l'étiquette prédite. L'instructeur démontre ce processus à l'aide du code PyTorch et note également que la somme des probabilités pour chaque échantillon sera toujours une en raison de la nature de la fonction softmax.
  
  
• 13:20:00 Dans cette section, l'instructeur explique comment passer de la sortie brute d'un modèle PyTorch pour un problème de classification multi-classes aux probabilités de prédiction à l'aide de la fonction d'activation softmax, puis aux étiquettes de prédiction en prenant l'argmax du probabilités de prédiction. Ce processus implique la conversion de la sortie brute du modèle en logits, l'utilisation de la fonction softmax pour obtenir les probabilités de prédiction et la prise de l'argmax de ces probabilités pour obtenir les étiquettes de prédiction. L'instructeur note que bien que les prédictions actuelles soient aléatoires car le modèle n'a pas encore été formé, ces étapes seront utilisées dans une boucle de formation pour former et évaluer le modèle.
  
  
• 13:25:00 Dans cette section, l'instructeur commence à créer une boucle d'entraînement et de test pour un modèle à plusieurs classes. Tout d'abord, ils ont configuré des graines manuelles pour tenter d'obtenir le même résultat à chaque fois, mais notez que cela n'est pas garanti. Ils fixent ensuite le nombre d'époques à 100 et placent les données sur l'appareil cible. La boucle à travers les données commence et pour chaque époque, le modèle est formé avec une passe en avant et des logits créés à partir de x blob train. La sortie de la fonction Torch softmax est utilisée pour calculer la perte avec la perte d'entropie croisée et la précision. L'optimiseur est ensuite mis à zéro et la rétro-propagation est effectuée avant que l'optimiseur ne soit échelonné. Le code de test ou d'inférence est également présenté, ce qui implique de mettre le modèle en mode d'évaluation.
  
  
• 13:30:00 Dans cette section, l'instructeur discute des couches d'abandon, de la désactivation de la norme de correspondance et du mode d'inférence de la torche pour effectuer des prédictions plus rapidement. Ils expliquent que pendant l'entraînement, les couches d'abandon abandonnent au hasard certains des neurones pour éviter le surajustement. L'instructeur montre également comment calculer les logits de test et la précision des tests en transmettant la perte de test et les étiquettes de test dans les coulisses. Ils discutent ensuite d'un problème de type de données embêtant qui a provoqué une erreur d'exécution et comment ils l'ont résolu. L'instructeur souligne que le code de dépannage est une partie essentielle de l'apprentissage automatique et qu'il faut du temps pour identifier et résoudre les erreurs.
  
  
• 13:35:00 Dans cette section, le narrateur rencontre divers défis de dépannage lors de la création d'un modèle de classification multi-classes. Tout d'abord, il comprend que l'erreur dans son code est due à l'un des tenseurs ayant le mauvais type de données. Grâce à quelques recherches et expérimentations, il change le tenseur en un « tenseur torch.long », qui optimise le calcul de la perte d'entropie croisée. Plus tard, il rencontre une autre erreur due aux différentes tailles de ses données d'entraînement et de test. En déboguant le code à la volée, il identifie le problème et réaffecte les données. Malgré ces défis, la précision et la perte du modèle fonctionnent comme prévu, ce qui indique que le modèle fonctionne pour un ensemble de données de classification multi-classes.
  
  
• 13:40:00 Dans cette section, l'instructeur explique comment évaluer le modèle de classification multiclasse formé en faisant des prédictions et en les évaluant. L'instructeur explique que les prédictions sont faites après avoir mis le modèle en mode d'évaluation, passé les données de test et obtenu les logits bruts en conséquence. L'étape suivante consiste à convertir les logits en probabilités de prédiction en appelant torch.softmax sur les logits. Ensuite, les étiquettes de prédictions sont obtenues en appelant torch.argmax sur les probabilités de prédiction. L'instructeur insiste sur l'importance de visualiser les prédictions en les traçant et en les comparant aux données réelles.
  
  
• 13:45:00 Dans cette section, l'instructeur évalue visuellement le modèle de classification multiclasse et explore les fonctions linéaires et non linéaires utilisées pour séparer les données. L'instructeur mentionne également que la plupart des données nécessitent des fonctions linéaires et non linéaires pour la classification, et PyTorch facilite l'ajout de ces fonctions aux modèles. En outre, la section couvre l'importance de l'évaluation des modèles et présente la précision et le rappel en tant que métriques importantes lorsqu'il s'agit de classes avec différentes quantités de valeurs.
  
  
• 13:50:00 Dans cette section, l'instructeur aborde diverses méthodes d'évaluation de la classification, notamment l'exactitude, la précision, le rappel, le score F1, la matrice de confusion et le rapport de classification. L'instructeur explique que si la précision est la mesure par défaut pour les problèmes de classification, elle n'est peut-être pas la meilleure pour les ensembles de données déséquilibrés. Pour les ensembles de données déséquilibrés, la précision et le rappel doivent être utilisés. La précision est déterminée par le vrai positif sur le vrai positif plus le faux positif, tandis que le rappel est déterminé par le vrai positif sur le vrai positif plus le faux négatif. L'instructeur note également le compromis entre la précision et le rappel, où l'augmentation d'une métrique réduirait l'autre. L'utilisation des bibliothèques torchmetrics et scikit-learn pour les métriques de classification est également abordée.
  
  
• 13:55:00 Dans cette section, l'instructeur montre comment importer et utiliser des fonctions de métriques prédéfinies dans PyTorch à l'aide du package torchmetrics. Ils montrent comment installer torchmetrics, importer la métrique de précision et l'utiliser pour calculer la précision d'un modèle multi-classes. Cependant, ils avertissent également que lors de l'utilisation de torchmetrics, les métriques doivent être sur le même appareil que les données, en utilisant un code indépendant de l'appareil. L'instructeur fournit un lien vers le module torchmetrics et des articles parascolaires pour une exploration plus approfondie. Ils présentent également des exercices et des solutions pour pratiquer le code couvert dans les sections précédentes.

[MetaQuotes]

PyTorch pour Deep Learning & Machine Learning - Cours complet (description des parties 15-19)

PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique - Cours complet

Partie 15

• 14:00:00 Dans cette section, l'instructeur indique aux spectateurs où obtenir de l'aide pour le code de vision par ordinateur PyTorch, notamment en suivant le code, en utilisant la fonction de chaîne de documentation de Google Colab, en recherchant du code sur Stack Overflow ou dans la documentation PyTorch, et poser des questions sur l'onglet Discussions du référentiel d'apprentissage en profondeur PyTorch. La section couvre également des exemples de problèmes de vision par ordinateur, tels que les problèmes de classification binaire ou multi-classes, où un modèle d'apprentissage automatique apprend des modèles à partir de différents exemples d'images pour déterminer si une image est un steak ou une pizza, ou pour classer les images en plusieurs catégories. .
  
  
• 14:05:00 Dans cette section, le conférencier aborde différentes applications de la vision par ordinateur utilisant l'apprentissage automatique, telles que la classification multi-classes pour les problèmes d'image, la détection d'objets et la segmentation d'images. Le conférencier donne un exemple de Nutrify, qui utilise l'apprentissage automatique pour classer jusqu'à 100 aliments différents à partir d'une image téléchargée. L'orateur explique également comment Tesla utilise la vision par ordinateur pour planifier les mouvements de ses voitures autonomes à l'aide de l'espace vectoriel tridimensionnel et de l'apprentissage automatique. L'orateur note que Tesla utilise PyTorch, qui est le même code qui est enseigné dans le cours.
  
  
• 14:10:00 Dans cette section de la vidéo, l'instructeur explique comment utiliser PyTorch pour créer un modèle de vision par ordinateur pour la classification d'images multi-classes. En utilisant l'exemple de Nutrify, une technologie de reconnaissance de photos pour les aliments, l'instructeur explique les entrées et les sorties typiques d'un problème de vision par ordinateur. Les entrées incluent un tenseur représentant la hauteur, la largeur et les canaux de couleur d'une image. L'instructeur mentionne également que des algorithmes existants peuvent déjà exister pour les problèmes de vision par ordinateur populaires, mais qu'un peut être construit si nécessaire. La sortie souhaitée pour l'exemple Nutrify est de trois sorties, une pour chaque classe d'aliments.
  
  
• 14:15:00 Dans cette section, la vidéo explique comment les modèles d'apprentissage automatique peuvent être utilisés pour la classification des images, en utilisant PyTorch et les réseaux de neurones convolutifs (CNN) pour représenter les informations numériquement et entraîner le modèle à reconnaître les modèles dans les données. L'exemple donné consiste à prédire les types d'aliments dans une image, tels que les sushis, les steaks et les pizzas, en utilisant PyTorch pour coder les informations et les CNN pour reconnaître les modèles dans les images. La vidéo souligne que les formes d'entrée et de sortie varient en fonction du problème à résoudre et que les CNN sont généralement le meilleur choix pour les données d'image, bien que d'autres modèles puissent être utilisés. Enfin, la vidéo présente un problème impliquant des images en niveaux de gris d'articles de mode qui seront utilisés pour démontrer davantage les mêmes principes appris dans cette section.
  
  
• 14:20:00 Dans cette section, l'instructeur aborde la représentation des données d'image dans PyTorch et d'autres bibliothèques d'apprentissage en profondeur. Ces bibliothèques attendent souvent les canaux de couleur en dernier, mais PyTorch représente par défaut les données d'image avec des canaux de couleur en premier. La vidéo explique l'importance d'aligner les formes d'entrée et de sortie d'un modèle pour un problème donné. L'instructeur fournit un aperçu du flux de travail PyTorch pour la création de modèles, y compris la préparation des données à l'aide de transformations et de chargeurs de données, la création ou la sélection d'un modèle pré-formé, la sélection d'un optimiseur et d'une fonction de perte, l'évaluation du modèle à l'aide de métriques et l'expérimentation pour améliorer le modèle. La section suivante traite de l'architecture d'un réseau de neurones convolutifs (CNN).
  
  
• 14:25:00 Dans cette section, l'instructeur discute de l'architecture d'un réseau neuronal convolutif (CNN) typique. Les données d'entrée passent par différentes couches, y compris les couches de convolution, d'activation et de regroupement, jusqu'à ce qu'elles soient converties en une forme de sortie pouvant être convertie en noms de classe. L'instructeur souligne qu'il existe des façons presque illimitées d'empiler un CNN et montre une façon de le faire à travers des diapositives. Cependant, la meilleure façon d'apprendre est de le coder, et l'instructeur dirige les utilisateurs vers un bloc-notes Google Colab où ils peuvent s'entraîner à créer un CNN à l'aide de PyTorch et de la bibliothèque TorchVision. L'instructeur fournit également des ressources supplémentaires, notamment un bloc-notes de référence et une section de vision par ordinateur PyTorch dans LearnPyTorch.io.
  
  
• 14:30:00 Dans cette section de la vidéo, l'instructeur présente les différentes bibliothèques PyTorch pour différents domaines, soulignant la force de PyTorch en vision par ordinateur. La bibliothèque principale pour la vision par ordinateur est la vision torche, qui contient des ensembles de données, des modèles pré-formés pour la vision par ordinateur et se transforme pour manipuler les données de vision en nombres utilisables par les modèles d'apprentissage automatique. L'instructeur montre comment importer PyTorch, NN et la vision torche, et parcourt le module de transformations, qui contient des transformations d'image courantes et peut être formé ensemble à l'aide de la composition. La fonction to_tensor est introduite en tant que transformation principale pour transformer les données d'image en format tenseur.
  
  
• 14:35:00 Dans cette section du cours PyTorch for Deep Learning & Machine Learning, l'instructeur couvre les bibliothèques de vision par ordinateur fondamentales de PyTorch, y compris TorchVision, les modules issus de TorchVision et TorchUtils.data.dataset, qui est l'ensemble de données de base classe pour PyTorch. L'instructeur discute également de l'importance d'utiliser Matplotlib pour la visualisation et de la nécessité de convertir des images en tenseurs à utiliser avec des modèles. L'instructeur présente ensuite l'ensemble de données FashionMNIST, qui est une version de la base de données MNIST originale, avec des images en niveaux de gris de vêtements. Cet ensemble de données sera utilisé pour démontrer les techniques de vision par ordinateur. L'instructeur explique que si les chercheurs sérieux en apprentissage automatique considèrent que MNIST est surutilisé et non représentatif des tâches de vision par ordinateur modernes, FashionMNIST est un ensemble de données utile pour commencer.
  
  
• 14:40:00 Dans cette section, l'instructeur explique comment télécharger et utiliser des ensembles de données à partir de la bibliothèque TorchVision. Ils mentionnent divers ensembles de données de classification d'images tels que Caltech101, CIFAR-100 et CIFAR-10, et comment les télécharger à l'aide du module torchvision.datasets. L'instructeur poursuit ensuite en expliquant comment télécharger et utiliser l'ensemble de données Fashion-MNIST, en expliquant les différents paramètres et transformations qui peuvent être appliqués à l'ensemble de données. Ils fournissent également un exemple de code pour télécharger les ensembles de données d'entraînement et de test.
  
  
• 14:45:00 Dans cette section, l'instructeur explique comment utiliser les ensembles de données torchvision.dataset de PyTorch pour télécharger des exemples d'ensembles de données de vision par ordinateur, en particulier l'ensemble de données FashionMNIST. Nous pouvons stocker les données dans une variable appelée "data" et utiliser torchvision.transforms pour convertir les données d'image en tenseurs. L'instructeur montre également comment vérifier la longueur des ensembles de données de formation et de test, afficher l'image et l'étiquette d'un exemple de formation et obtenir plus d'informations sur les noms de classe grâce à l'utilisation d'attributs tels que ".classes" et ".class_to_idx". Enfin, ils expliquent qu'une étiquette n'a pas de forme car ce n'est qu'un entier.
  
  
• 14:50:00 Dans cette section, l'instructeur décrit les formes d'entrée et de sortie de l'ensemble de données Fashion MNIST, qui comprend des images en niveaux de gris de différents types de vêtements. La forme d'entrée des images est au format NCHW, où la taille du lot est définie sur "aucune" et la forme de sortie est 10. Pour mieux comprendre les données, l'instructeur utilise Matplotlib pour visualiser une image et sa forme, mais rencontre un erreur car le format des données ne correspond pas au format attendu. Cette section met l'accent sur l'importance de comprendre les formes et le formatage des entrées et des sorties lorsque vous travaillez avec des modèles d'apprentissage automatique.
  
  
• 14:55:00 Dans cette section, la vidéo explore comment tracer et visualiser des données d'image à l'aide de PyTorch et Matplotlib. L'instructeur montre comment tracer une seule image et supprimer les dimensions supplémentaires à l'aide de image.squeeze(). Ensuite, ils tracent un ensemble de 16 images aléatoires à partir de l'ensemble de données en utilisant une graine aléatoire fixe et la fonction de sous-parcelle de Matplotlib. L'instructeur montre également comment utiliser la propriété ou le paramètre cmap pour modifier la palette de couleurs du tracé en niveaux de gris. Ils discutent ensuite de l'importance d'explorer visuellement un ensemble de données pour mieux comprendre les données et identifier les problèmes potentiels, tels que les similitudes entre les pulls et les chemises dans l'ensemble de données.

Partie 16

• 15:00:00 Dans cette section, l'instructeur explique l'importance de la préparation des données pour un modèle de vision par ordinateur et comment le faire à l'aide des ensembles de données PyTorch et des chargeurs de données. Il discute également du besoin potentiel de non-linéarité dans la modélisation des 60 000 images de vêtements à classer en 10 classes différentes et de la manière dont la décomposition de l'ensemble de données en lots plus petits peut améliorer l'efficacité des calculs. L'objectif de cette préparation est de créer un itérable Python qui peut être utilisé par le modèle pour identifier des modèles dans les données.
  
  
• 15:05:00 Dans cette section, l'instructeur explique le concept de mini-lots et pourquoi il est couramment utilisé dans l'apprentissage en profondeur, en commençant par décomposer un ensemble de données de 60 000 images en lots de 32. Les deux principales raisons d'utiliser les mini-lots sont de rendre le réseau de neurones plus efficace en termes de calcul en évitant les limitations de mémoire GPU et en donnant au réseau plus de chances de mettre à jour ses gradients par époque. Les données sont regroupées à l'aide du chargeur de données de torch.utils.data en lui transmettant un ensemble de données, en définissant la taille du lot et en définissant shuffle sur true pour éviter que le réseau ne mémorise l'ordre des données. L'instructeur fournit le code pour créer des chargeurs de données d'entraînement et de test, qui seront utilisés dans la boucle de formation.
  
  
• 15:10:00 Dans cette section, l'importance des mini-lots dans les problèmes d'apprentissage en profondeur est soulignée, et le processus de création de chargeurs de données d'entraînement et de test est expliqué à l'aide de PyTorch. L'hyperparamètre de taille de lot est défini sur 32 et les ensembles de données sont transformés en itérables. Les ensembles de données d'entraînement et de test sont chargés à l'aide de DataLoader, avec la taille de lot définie sur 32 pour les données d'entraînement et les données de test, et le shuffle défini sur True pour les données d'entraînement et False pour les données de test. Les attributs du chargeur de données de train, tels que la taille du lot et l'ensemble de données, sont explorés. La longueur des chargeurs de données de train et de test est imprimée pour déterminer le nombre de lots dans chacun.
  
  
• 15:15:00 Dans cette section, l'instructeur explique comment visualiser des lots d'images à l'aide de PyTorch. L'extrait de transcription montre comment la longueur du chargeur de données de train est déterminée, en fonction de la taille du lot et du nombre d'échantillons d'apprentissage. Ensuite, l'instructeur montre comment visualiser une seule image d'un lot en utilisant le caractère aléatoire et vérifie la taille de l'image et l'étiquette associée à cet échantillon. L'instructeur souligne que ces formes d'entrée et de sortie varient en fonction du problème spécifique, mais le principe de base reste le même : les données sont transformées en lots pour les transmettre à un modèle.
  
  
• 15:20:00 Dans cette section, l'instructeur vidéo explique comment visualiser des images dans un lot et transformer les données en chargeurs de données. Ils ont également introduit le concept d'un modèle de base, qui est utilisé comme point de départ et est un modèle simple qui peut être amélioré ultérieurement par l'expérimentation. L'instructeur introduit ensuite un nouveau calque, "aplatir", qui aplatit une plage continue de dims dans un tenseur à utiliser avec séquentiel, et montre comment l'utiliser comme modèle autonome.
  
  
• 15:25:00 Dans cette section, nous découvrons l'aplatissement et comment il est utilisé pour transformer des données multidimensionnelles en un seul vecteur. Après avoir imprimé les formes avant et après l'aplatissement, nous voyons que la sortie est maintenant un vecteur unidimensionnel d'une longueur de 1784. Nous voyons également que ce processus est similaire à l'encodage des informations dans les caméras de Tesla pour une utilisation dans les modèles d'apprentissage en profondeur. Nous voyons ensuite comment les données aplaties seront utilisées dans la couche linéaire de notre modèle PyTorch. Le modèle est défini à l'aide de nn.Sequential et comprend une couche aplatie et deux couches linéaires. Les formes d'entrée et de sortie sont définies, et nous voyons que les caractéristiques de sortie de la première couche linéaire correspondent aux caractéristiques d'entrée de la deuxième couche linéaire.
  
  
• 15:30:00 Dans cette section, l'instructeur explique comment créer un modèle de réseau neuronal simple à l'aide de PyTorch. Le modèle se compose d'une couche aplatie suivie de deux couches linéaires, sans non-linéarités. La méthode directe du modèle est définie, qui prend une entrée, la fait passer à travers la couche d'aplatissement, puis à travers les deux couches linéaires, et renvoie la sortie. L'instructeur configure ensuite une instance du modèle et effectue une passe avant factice pour s'assurer que le modèle fonctionne comme prévu. De plus, ils expliquent également la forme d'entrée et de sortie de chaque couche et comment elles sont disposées pour obtenir la forme de sortie souhaitée. Enfin, ils démontrent l'importance d'utiliser la couche aplatie et pourquoi il est nécessaire de combiner la sortie de la couche précédente en un seul vecteur.
  
  
• 15:35:00 Dans cette section, l'instructeur passe en revue la vidéo précédente où il a créé le modèle zéro pour un problème de vision par ordinateur et a réitéré l'importance de s'assurer que les formes d'entrée et de sortie s'alignent sur l'endroit où elles doivent être. Ils expliquent également que les poids et les matrices de biais représentent différentes caractéristiques dans les images, que le modèle apprendra grâce à l'apprentissage en profondeur et à l'apprentissage automatique. À l'avenir, ils discutent de la sélection d'une fonction de perte, d'un optimiseur et d'une métrique d'évaluation pour le modèle, en choisissant respectivement la perte d'entropie croisée, l'optimiseur de descente de gradient stochastique et la métrique d'évaluation de la précision. Ils fournissent également une référence à une ressource PyTorch en ligne pour les métriques d'évaluation de la classification.
  
  
• 15:40:00 Dans cette section, l'instructeur vidéo aborde le concept d'utilisation des fonctions d'assistance dans les projets d'apprentissage automatique Python. Il fournit un exemple de code pour importer un script Python contenant des fonctions courantes, y compris une fonction d'assistance appelée précision. La fonction de précision calcule la métrique de précision et l'instructeur démontre qu'elle peut être importée avec succès en recherchant une chaîne de documentation. Il explique également que l'utilisation de fonctions d'assistance dans les projets Python peut économiser beaucoup de temps et d'efforts, en particulier lorsqu'il s'agit de fonctionnalités courantes qui n'ont pas besoin d'être réécrites à chaque fois. Enfin, il configure une fonction de perte égale à la perte d'entropie croisée de nn points et un optimiseur pour entraîner le modèle.
  
  
• 15:45:00 Dans cette section, l'instructeur configure l'optimiseur pour la descente de gradient stochastique et définit un taux d'apprentissage relativement élevé de 0,1 pour l'ensemble de données simple d'images 28x28. Ils discutent ensuite de l'importance de suivre les performances d'un modèle ainsi que sa durée d'exécution, car il y a souvent un compromis entre les deux. Ils montrent ensuite comment créer une fonction pour chronométrer l'entraînement du modèle à l'aide du module de temps en Python et en transmettant torch.device pour comparer la vitesse d'exécution du modèle sur différents appareils.
  
  
• 15:50:00 Dans cette section, l'instructeur discute de l'importance des fonctions de synchronisation pour mesurer la durée d'entraînement d'un modèle. Il montre comment créer une minuterie à l'aide du module Python "timer" et montre comment l'intégrer dans le processus de formation. L'instructeur explique également comment utiliser la fonctionnalité de reconnexion de Google Colab et fournit un rappel sur l'utilisation des chargeurs de données pour diviser les données en lots pour la formation. Il décrit ensuite les étapes impliquées dans la création d'une boucle de formation et la formation d'un modèle sur des lots de données, en insistant sur la nécessité de parcourir les époques et les lots, d'effectuer des étapes de formation et de calculer la perte de train par lot. Enfin, il mentionne que le modèle sera évalué à la même étape que la formation.
  
  
• 15:55:00 Dans cette section, l'instructeur commence la phase de test en important TQDM pour une barre de progression qui indiquera le nombre d'époques parcourues par la boucle de formation. TQDM est une barre de progression Python qui a une faible surcharge et est un logiciel open source. Étant donné que TQDM est si populaire, il est intégré à Google CoLab. L'instructeur définit la graine et démarre la minuterie avant de définir le nombre d'époques à trois pour un temps de formation plus rapide pour exécuter plus d'expériences. Ils créent une boucle d'entraînement et de test, instancient la perte de train et calculent la perte d'entraînement par époque. Les données sont regroupées et une boucle est ajoutée pour parcourir les données du lot d'apprentissage.

Partie 17

• 16:00:00 Dans cette section, l'instructeur configure la boucle de formation pour le réseau de neurones. Le modèle est mis en mode apprentissage et la passe avant est effectuée pour calculer la perte. Les valeurs de perte d'entraînement sont accumulées à chaque lot et l'optimiseur est mis à jour une fois par lot plutôt qu'une fois par époque. L'instructeur imprime également les échantillons examinés et la perte d'entraînement moyenne par lot et par époque à des fins de surveillance. Cette boucle se poursuivra jusqu'à ce que tous les lots aient été traités dans le chargeur de données de train.
  
  
• 16:05:00 Dans cette section, l'instructeur parcourt le code de la boucle de test dans PyTorch, qui implique la configuration d'une variable de perte de test et l'utilisation d'une passe avant pour évaluer les modèles appris sur les données de formation. La précision des tests est également calculée à l'aide de la fonction de précision téléchargée, et les valeurs de perte de test et de précision des tests sont accumulées par lot, puis divisées par le nombre de lots pour trouver la moyenne par époque. Ces valeurs sont ensuite imprimées pour suivre la progression du modèle.
  
  
• 16:10:00 Dans cette section, l'instructeur décrit les étapes finales de la configuration de la boucle de formation, qui comprend l'impression de la perte de train, de la perte de test et de la précision du test, ainsi que le calcul du temps de formation. Ils fournissent également des conseils de dépannage pour les erreurs potentielles pouvant survenir lors du codage dans PyTorch. Ils concluent en démontrant comment exécuter le code et montrent la barre de progression de la boucle de formation.
  
  
• 16:15:00 Dans cette section, l'instructeur discute des résultats de la boucle d'entraînement et introduit l'idée de précision de base et de temps d'entraînement. Il souligne que les chiffres peuvent varier légèrement en raison du caractère aléatoire inhérent à l'apprentissage automatique et au matériel utilisé. L'instructeur passe ensuite à l'évaluation du modèle en créant une fonction pour créer plusieurs modèles et comparer les résultats ultérieurement. La fonction prend un modèle, un chargeur de données, une fonction de perte et une fonction de précision et renvoie un dictionnaire contenant les résultats du modèle prédisant sur le chargeur de données. Il explique que la fonction est similaire à la boucle de test mais est fonctionnalisée pour être utilisée avec plusieurs modèles et chargeurs de données. L'instructeur mentionne également que les sections suivantes couvriront la réalisation de prédictions et l'évaluation du modèle sur le GPU et le réseau neuronal convolutif.
  
  
• 16:20:00 Dans cette section, le créateur de la vidéo montre comment rendre la fonction de perte et de précision généralisable afin qu'elle puisse être utilisée avec n'importe quel modèle et chargeur de données. Ils montrent comment accumuler les valeurs de perte et de précision par lot, les mettre à l'échelle pour trouver la perte/précision moyenne par lot et renvoyer les résultats sous forme de dictionnaire. Ils montrent également comment créer une nouvelle fonction pour calculer les résultats du modèle sur le jeu de données de test, en utilisant les fonctions définies précédemment. Enfin, ils utilisent une barre de progression pour suivre les performances du modèle sur le jeu de données de test.
  
  
• 16:25:00 Dans cette section du cours PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique, l'instructeur explique comment configurer un code indépendant de l'appareil pour former des modèles sur les CPU et les GPU. Ils démontrent la vérification de la disponibilité de CUDA et le passage au GPU pour tirer parti de sa puissance de traitement. L'instructeur recommande également de commencer avec des ensembles de données et des modèles plus petits avant d'augmenter la complexité et la taille. Enfin, ils proposent de construire un nouveau modèle pour l'ensemble de données et de tester ses performances avec et sans non-linéarités lors de l'exécution sur le GPU.
  
  
• 16:30:00 Dans cette section, l'instructeur présente le concept de non-linéarité dans les réseaux de neurones et encourage les spectateurs à expérimenter la création d'un modèle avec des fonctions non linéaires. Les avantages de la non-linéarité pour la modélisation de données non linéaires sont discutés et l'instructeur explique comment mettre en œuvre un réseau de neurones avec des couches linéaires et non linéaires à l'aide de PyTorch. Ils parcourent le code étape par étape et soulignent l'importance de l'expérimentation pour trouver le meilleur modèle pour un ensemble de données donné.
  
  
• 16:35:00 Dans cette section, l'instructeur décrit la personnalisation des réseaux de neurones avec des fonctions linéaires et non linéaires, et montre comment ajouter deux fonctions d'activation ReLU à un réseau précédemment défini. La méthode directe est ensuite remplacée pour permettre à l'entrée de traverser la pile de couches, et le modèle est instancié sur l'appareil. La vidéo passe ensuite à la création d'une fonction de perte, d'un optimiseur et de métriques d'évaluation pour le nouveau modèle, qui a ajouté des couches non linéaires, soulignant l'importance de mener des expériences pour comprendre comment différentes fonctions peuvent influencer les réseaux de neurones.
  
  
• 16:40:00 Dans cette section, l'intervenant discute de la création de fonctions d'assistance et de la fonctionnalisation des boucles d'entraînement et d'évaluation dans PyTorch. Ils mentionnent l'importation de la fonction de précision et la mise en place d'une fonction de perte ainsi que l'optimiseur. L'étape suivante consiste à construire des boucles d'entraînement et d'évaluation en tant que fonctions afin qu'elles puissent être appelées à plusieurs reprises sans risque d'erreurs. L'orateur parcourt le processus de création d'une fonction d'étape de train, qui nécessite un modèle, un chargeur de données, une fonction de perte, un optimiseur et, éventuellement, une fonction de précision et un périphérique cible comme entrées. La fonction train step parcourt un chargeur de données, effectue une passe avant, calcule la perte, rétropropage et met à jour les paramètres du modèle avec l'optimiseur.
  
  
• 16:45:00 Dans cette section, le présentateur explique comment effectuer une étape de formation dans PyTorch. Ils commencent par définir les entrées de la fonction, y compris un modèle, un chargeur de données, une fonction de perte, un optimiseur et un appareil. Ensuite, ils parcourent chaque ligne de la fonction, en commençant par une boucle dans le chargeur de données et en plaçant les données sur l'appareil cible. Ils ajoutent également une fonction de précision pour accumuler le score de précision par lot. Enfin, à la fin de l'étape de formation, ils calculent la perte moyenne et la précision par lot, et impriment les résultats. Dans l'ensemble, cette section fournit une explication claire et concise de l'utilisation de PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique.
  
  
• 16:50:00 Dans cette section, le formateur fonctionnalise la boucle de test en créant une fonction d'étape de test qui prend en entrée un modèle, un chargeur de données, une fonction de perte, une fonction de précision et un appareil. Le formateur montre comment configurer un test de perte et de précision et mettre le modèle en mode eval avant de parcourir le chargeur de données et d'effectuer une passe avant. Le formateur explique également l'importance d'utiliser le gestionnaire de contexte du mode d'inférence et de créer un code indépendant de l'appareil. Le test pred est calculé en passant dans X, et la perte de test et la précision sont cumulées par lot à l'aide des fonctions respectives. Enfin, l'entraîneur convertit les logits de sortie en étiquettes de prédiction en prenant l'argmax.
  
  
• 16:55:00 Dans cette section du cours complet PyTorch, l'instructeur montre comment créer une fonction d'étape de test et une boucle d'optimisation et d'évaluation à l'aide des fonctions d'étape d'entraînement et d'étape de test. Les nouvelles fonctions sont utilisées pour former un modèle et évaluer sa précision pour trois époques. L'instructeur montre également comment mesurer le temps nécessaire au modèle pour s'exécuter sur le GPU par rapport au CPU.

Partie 18

• 17:00:00 Dans cette section, l'instructeur nous explique comment configurer l'étape de test de notre modèle d'apprentissage en profondeur et créer une minuterie pour mesurer le temps de formation. Le code est simple et efficace car il est conçu pour être réutilisable dans de futurs projets. De plus, nous exécutons la deuxième expérience de modélisation et comparons les résultats avec le premier modèle, qui utilisait des couches non linéaires. Bien que le deuxième modèle ait été légèrement plus rapide en termes de temps de formation, il n'a pas produit de meilleurs résultats que le précédent, ce qui signifie que vos chiffres pourraient ne pas être les mêmes que ceux de l'instructeur mais devraient être assez similaires en direction. Enfin, l'instructeur explique que notre modèle n'est pas trop complexe et que notre ensemble de données n'est pas très volumineux, ce qui pourrait expliquer pourquoi les temps d'entraînement CPU et GPU ne sont pas radicalement différents.
  
  
• 17:05:00 Dans cette section, l'instructeur explique que parfois un modèle s'entraîne plus rapidement sur un CPU que sur un GPU. Les deux principales raisons à cela sont que la surcharge de copie de données/modèle vers et depuis le GPU l'emporte sur les avantages de calcul offerts par le GPU et que le matériel utilisé a un meilleur CPU en termes de capacité de calcul que le GPU. Cependant, l'instructeur note que cela est moins courant et qu'en général, un GPU moderne calcule plus rapidement les algorithmes d'apprentissage en profondeur qu'un processeur général. Ensuite, l'instructeur partage une ressource qui explique comment accélérer l'apprentissage en profondeur en optimisant la bande passante et les frais généraux, entre autres. Enfin, l'instructeur crée un dictionnaire de résultats pour le modèle 1 afin de comparer ultérieurement les résultats de la modélisation.
  
  
• 17:10:00 Dans cette section, l'instructeur traite d'une erreur courante qui peut se produire dans les modèles d'apprentissage en profondeur concernant les incompatibilités d'appareils entre les données et le modèle. Il explique que l'erreur s'est produite parce que les données et le modèle se trouvaient sur des appareils différents et suggère un correctif en rendant le code indépendant de l'appareil. Il avertit également qu'il est toujours préférable de créer un code indépendant de l'appareil. Enfin, l'instructeur présente l'expérience de modélisation suivante, qui consiste à construire un réseau neuronal convolutif (CNN) et explique l'architecture d'un CNN typique.
  
  
• 17:15:00 Dans cette section, l'instructeur explique les différents types de couches dans un réseau neuronal convolutionnel simple (CNN). Le CNN commence par une entrée, prétraitée en un tenseur en rouge, vert et bleu pour une image. L'entrée passe ensuite par une combinaison de couches convolutionnelles, de couches relu et de couches de regroupement. Le modèle d'apprentissage en profondeur peut avoir plus de couches ajoutées pour trouver plus de modèles dans les données, chaque couche effectuant une combinaison différente d'opérations mathématiques sur les données. L'instructeur présente le CNN à l'aide du site Web explicatif CNN, où l'entrée de différentes images passe par différentes couches, la sortie finale étant la classe avec la valeur la plus élevée.
  
  
• 17:20:00 Dans cette section, l'instructeur explique le fonctionnement des réseaux de neurones convolutifs et la beauté de l'apprentissage en profondeur. Chaque couche du réseau est conçue pour apprendre différentes caractéristiques des données, le réseau lui-même trouvant la meilleure façon d'apprendre ces caractéristiques. L'instructeur présente ensuite le site Web explicatif de CNN comme une ressource pour en savoir plus sur les réseaux de neurones convolutifs, mais encourage également
  apprenants à se joindre à la réplication du réseau de neurones dans le code PyTorch. L'instructeur procède ensuite à la construction d'un minuscule réseau de neurones convolutifs VGG dans PyTorch et explique que les auteurs d'articles de recherche peuvent nommer de nouvelles architectures de modèles pour faciliter les références futures. Le code est initialisé avec la forme d'entrée, les unités cachées et la forme de sortie, qui sont des paramètres typiques dans la construction d'un modèle PyTorch.
  
  
• 17:25:00 Dans cette section, l'instructeur explique comment créer un réseau de neurones à l'aide de blocs dans PyTorch, souvent appelés blocs convolutionnels. Ces blocs sont composés de plusieurs couches et une architecture globale est composée de plusieurs blocs. L'instructeur montre comment créer des blocs convolutifs en écrivant deux exemples de couches avec des hyperparamètres tels que les canaux d'entrée et de sortie, la taille du noyau, la foulée et le rembourrage. L'instructeur fournit également des ressources interactives aux apprenants pour comprendre les bases des hyperparamètres et les encourage à les parcourir.
  
  
• 17:30:00 Dans cette section, l'instructeur parcourt le code pour créer un modèle d'apprentissage en profondeur à l'aide de PyTorch, en se concentrant spécifiquement sur les couches de blocs convolutionnels. Le modèle prend des données d'image 2D et les couches sont utilisées pour apprendre une représentation compressée des données d'entrée, avec un regroupement maximal utilisé pour prendre la valeur maximale des données d'entrée. Le code est décomposé en deux blocs, puis une couche de sortie est ajoutée. Les entrées de la couche finale sont aplaties avant d'être passées à travers la dernière couche linéaire pour créer la sortie finale.
  
  
• 17:35:00 Dans cette section, l'instructeur construit la couche de classification pour un réseau neuronal convolutif (CNN) appelé minuscule VGG, qui comporte deux couches qui agissent comme des extracteurs de caractéristiques et une couche finale qui classe ces caractéristiques en classes cibles. L'instructeur code la couche de classificateur en séquentiel et passe dans une couche d'aplatissement pour aplatir la sortie des deux couches précédentes en un seul vecteur de caractéristiques. Le vecteur de caractéristiques est ensuite transmis à une couche nn.linear, qui calcule les caractéristiques d'entrée en fonction du nombre d'unités cachées et les caractéristiques de sortie en fonction de la longueur des classes. Enfin, l'instructeur configure la méthode avant et imprime la forme du point X pour suivre les changements de forme de chaque calque. L'instructeur établit la forme d'entrée pour le modèle CNN, qui n'a qu'un seul canal de couleur pour les images en noir et blanc, définit la valeur des unités cachées pour chaque couche et termine en instanciant le modèle.
  
  
• 17:40:00 Dans cette section de la vidéo, l'instructeur passe en revue le code qu'il a écrit dans la section précédente pour créer un réseau neuronal convolutif à l'aide de PyTorch. Ils identifient et corrigent certaines fautes de frappe dans le code et expliquent que la couche maxpool2d n'a aucun paramètre apprenable. Ils présentent ensuite la couche conv2d et expliquent que son tenseur de poids et sa valeur de biais manipulent l'entrée pour produire la sortie. Ils montrent comment reproduire la première couche du site Web explicatif CNN à l'aide d'une entrée factice dans PyTorch et fournissent un lien vers la documentation PyTorch pour une lecture plus approfondie. Ils montrent également comment créer des images par lots en utilisant le style PyTorch avec des canaux de couleur en premier.
  
  
• 17:45:00 Dans cette section, le didacticiel vidéo explore la composition d'un modèle PyTorch et le fonctionnement pratique des convolutions. L'instructeur explique comment le modèle, composé de nombres aléatoires, ajuste ces couches pour représenter au mieux les données à l'aide de couches comp2d. Après avoir passé des données aléatoires à travers l'une de ces couches, le tutoriel plonge dans la taille du noyau et comment il détermine l'opération effectuée par la convolution. L'instructeur explique le but d'une couche convolutive, qui est de s'assurer que ce noyau est capable d'effectuer correctement l'opération pour fournir la bonne sortie.
  
  
• 17:50:00 Dans cette section, l'instructeur explique les effets de la modification des valeurs de foulée et de rembourrage dans une couche convolutive dans PyTorch. Une valeur de pas de 1 signifie que la convolution saute sur un pixel à la fois, tandis qu'une valeur de pas de 2 sauts sur deux pixels à la fois, ce qui entraîne une diminution de la taille de sortie. Pendant ce temps, l'ajout d'un rembourrage aux bords de l'image permet au noyau d'agir sur les informations d'image sur les bords. L'instructeur note également que lorsqu'il n'est pas sûr des valeurs à définir pour les différents paramètres, il est courant de copier les valeurs existantes et de les ajuster si nécessaire. La section se termine par une démonstration de la façon d'ajouter une dimension de lot à une image de test et de la faire passer à travers une couche convolutive dans PyTorch.
  
  
• 17:55:00 Dans cette section, la vidéo couvre les couches de mise en commun convolutive et maximale dans PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique. La vidéo montre comment utiliser PyTorch pour créer des couches convolutives en faisant passer une image de test à travers une couche convolutive pour produire une sortie. En jouant avec les valeurs de taille du noyau, de foulée et de rembourrage, les utilisateurs peuvent observer comment la taille de sortie change. La vidéo couvre également la couche de mise en commun maximale et montre comment créer un exemple de couche de mise en commun maximale avec une taille de noyau de deux.

Partie 19

• 18:00:00 Dans cette section, l'instructeur montre comment transmettre des données via une couche convolutive et une couche de pool maximum dans PyTorch. Ils commencent par passer d'abord l'image de test à travers la couche de conversion, puis impriment la forme. Ils passent ensuite la sortie de la couche conv à travers la couche max pool et impriment à nouveau la forme résultante. L'instructeur explique que la couche max pool prend le maximum d'une certaine plage de tenseur interne et réduit la taille de sortie de la couche convolutive. Ils montrent également comment les formes changeront si les valeurs des couches et des paramètres sont modifiées.
  
  
• 18:05:00 Dans cette section, l'instructeur explique le concept de Max Pooling dans les réseaux de neurones convolutifs (CNN). L'objectif est de compresser les données d'entrée dans un vecteur de caractéristiques plus petit qui peut être utilisé pour les prédictions futures. La mise en commun maximale consiste à prendre la valeur maximale d'une certaine section de données d'entrée pour déterminer la caractéristique la plus importante dans cette région. L'instructeur démontre les effets de la variation de la taille du noyau pour le pooling maximal et comment cela affecte l'espace de fonctionnalités. Ils fournissent également un exemple visuel utilisant un tenseur aléatoire plus petit pour montrer le processus de regroupement maximal. Dans l'ensemble, la mise en commun maximale est une technique utile pour réduire la dimensionnalité des données tout en conservant des fonctionnalités importantes pour les prédictions.
  
  
• 18:10:00 Dans cette section du cours, l'instructeur discute de l'objectif de la couche max pool dans un réseau neuronal convolutif, qui est de compresser les caractéristiques apprises de la couche convolutive dans un espace plus petit, conduisant finalement à une représentation compressée des données d'entrée qui peuvent être utilisées pour faire des prédictions. L'instructeur met également les téléspectateurs au défi de créer un tenseur factice et de le faire passer à travers le minuscule réseau VGG qu'ils ont construit dans les vidéos précédentes pour voir ce qui arrive à la forme du tenseur factice lorsqu'il se déplace à travers les blocs convolutionnels. Enfin, l'instructeur explique que le but de répliquer un modèle à partir d'un autre endroit et de lui transmettre des données est une pratique courante dans l'apprentissage en profondeur.
  
  
• 18:15:00 Dans cette section, l'instructeur fournit un exemple de passage vers l'avant dans PyTorch et montre comment traiter les erreurs d'incompatibilité de forme. Ils utilisent une image précédemment créée à partir du jeu de données Fashion MNIST et créent un tenseur de la même forme que l'image. Cependant, ils obtiennent une erreur en raison du tenseur ayant une dimension supplémentaire pour la taille du lot. Pour résoudre ce problème, ils desserrent le tenseur à la dimension zéro pour ajouter la dimension du lot. Ils s'assurent également que le tenseur se trouve sur le même appareil que le modèle et montrent comment dépanner et trouver les formes nécessaires pour les différentes couches du modèle. La section se termine avec l'instructeur recréant le modèle en utilisant les informations recueillies sur les formes.
  
  
• 18:20:00 Dans cette section de la vidéo, l'instructeur montre une astuce pour déboguer les formes des couches dans un modèle de réseau neuronal. En transmettant des données factices à travers le modèle et en imprimant les formes de la sortie à chaque couche, l'instructeur est en mesure de déterminer où se produisent les incompatibilités de forme et d'identifier les problèmes avec la couche de classificateur. L'instructeur montre ensuite comment calculer manuellement les formes d'entrée et de sortie des couches convolutionnelles, mais affirme également les avantages de l'utilisation du code pour effectuer ces calculs. Enfin, l'instructeur utilise l'astuce pour s'assurer que le modèle est compatible avec les règles de multiplication matricielle et pour confirmer que le modèle peut traiter les données avec la forme souhaitée.
  
  
• 18:25:00 Dans cette section, l'instructeur décrit les formes d'entrée et de sortie de chaque couche du modèle qu'il a créé. Ils passent un tenseur aléatoire à travers le modèle et obtiennent une forme de sortie de un et dix, car ils ont dix classes dans leur ensemble de données. Ils passent ensuite à la configuration d'une fonction de perte et d'un optimiseur pour leur deuxième modèle et expliquent comment ils vont former leur premier réseau de neurones convolutionnels (CNN). Ils importent une fonction de précision, configurent une fonction de perte d'entropie croisée et conservent l'optimiseur comme avant, torch.opt dans SGD. Ils montrent ensuite comment utiliser leurs fonctions d'étape d'entraînement et d'étape de test pour entraîner le modèle 2, qu'ils aborderont en détail dans la vidéo suivante. Enfin, ils ont configuré la fonctionnalité de formation et de test en effectuant l'étape de formation avec le modèle et en essayant d'apprendre sur un chargeur de données.
  
  
• 18:30:00 Dans cette section, la vidéo se concentre sur la formation d'un réseau de neurones convolutifs et mesure le temps qu'il faut pour le former à l'aide de TQDM pour mesurer les progrès. Ils ont configuré la fonction de précision, la fonction de perte, l'optimiseur, le chargeur de données d'entraînement et le chargeur de données de test. Ils mesurent également l'heure de fin pour savoir combien de temps le code a mis à s'exécuter. Ils ont eu un problème de code avec une impression, mais l'ont corrigé et ont formé avec succès leur premier CNN, atteignant une précision de test de 88,5 % en environ 42 secondes. La vidéo conseille d'être conscient qu'un modèle plus performant prend généralement plus de temps à s'entraîner.
  
  
• 18:35:00 Dans cette section, l'instructeur explique l'importance de comparer les résultats et le temps de formation entre différents modèles dans les expériences d'apprentissage automatique. Ils introduisent trois dictionnaires de résultats de modèles et créent une base de données à l'aide de pandas pour comparer la précision, la perte et le temps d'apprentissage de chaque modèle. Ils constatent que le réseau neuronal convolutif (modèle 2) a surpassé les autres modèles avec une précision de 88 % et encourage les téléspectateurs à expérimenter différentes architectures de modèles, hyperparamètres et temps de formation pour de meilleurs résultats. L'instructeur insiste sur l'importance de considérer le compromis entre la performance du modèle et la vitesse dans les applications pratiques.
  
  
• 18:40:00 Dans cette section, l'instructeur discute de la comparaison des résultats des trois expériences menées dans la section précédente à l'aide d'un cadre de données et d'un graphique. Le temps de formation et la précision sont comparés pour chaque modèle, et l'instructeur note que le temps de formation variera en fonction du matériel utilisé. Le modèle le plus performant était le réseau de neurones convolutifs, mais il avait le temps de formation le plus long. L'instructeur suggère d'essayer de faire des prédictions sur des échantillons aléatoires à partir de l'ensemble de données de test en utilisant le modèle le plus performant.
  
  
• 18:45:00 Dans cette section, l'instructeur explique comment créer une fonction appelée "faire des prédictions" pour évaluer un modèle d'apprentissage automatique formé. La fonction prend en compte un modèle de type torche et module d'extrémité, certaines données et un type d'appareil. L'objectif est de prélever des échantillons aléatoires dans l'ensemble de données de test, de faire des prédictions à leur sujet à l'aide du modèle et de visualiser les prédictions. La fonction prépare l'échantillon en le desserrant et en le transmettant à l'appareil cible. Ensuite, il effectue une passe en avant sur le modèle pour obtenir les logits bruts et applique la fonction d'activation softmax pour obtenir la probabilité de prédiction. Enfin, les probabilités de prédiction sont transformées en étiquettes de prédiction, et la liste des probabilités de prédiction relatives à des échantillons particuliers est empilée pour transformer la liste en un tenseur. La section se termine par une démonstration de la fonction en action à l'aide d'échantillons de test.
  
  
• 18:50:00 Dans cette section, l'instructeur explique comment échantillonner de manière aléatoire des données de test et créer des étiquettes de test pour évaluer les prédictions du modèle. Les données de test ne sont pas encore converties en un chargeur de données et le code échantillonne neuf échantillons de données de test aléatoires. L'instructeur insiste sur l'importance de faire des prédictions sur des échantillons de données de test aléatoires même après avoir formé le modèle pour comprendre comment le modèle fonctionne. L'instructeur explique également comment convertir les probabilités de prédiction en étiquettes de prédiction à l'aide d'argmax pour prendre l'indice de la valeur la plus élevée dans les probabilités.
  
  
• 18:55:00 Dans cette section, l'instructeur écrit du code pour tracer les prédictions et les images pour des échantillons aléatoires. Le code crée une figure Matplotlib avec trois lignes et trois colonnes, et énumère chaque échantillon dans les échantillons de test. Pour chaque échantillon, une sous-parcelle est créée et l'image cible est tracée. L'étiquette de prédiction et l'étiquette de vérité sont également trouvées et converties sous forme de texte à l'aide des noms de classe et des index des classes pred et des étiquettes de test. Enfin, un titre est créé pour le tracé et la couleur du texte du titre est changée en vert si l'étiquette de prédiction est égale à l'étiquette de vérité, et en rouge si elles ne sont pas égales.

[Automated-Trading]

PyTorch pour Deep Learning & Machine Learning - Cours complet (description des parties 20-24)

PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique - Cours complet

Partie 20

• 19:00:00 Dans cette section, le présentateur discute de l'importance de visualiser les prédictions du modèle d'apprentissage automatique et montre comment tracer les prédictions d'un réseau neuronal convolutif (CNN) formé sur des échantillons sélectionnés au hasard à partir d'un ensemble de données de test. Le présentateur montre comment tracer des images avec leurs étiquettes prédites et vraies et changer la couleur du texte du titre selon que la prédiction est correcte ou non. En analysant les prédictions, le présentateur montre les confusions potentielles entre les classes d'étiquettes et suggère que la visualisation des prédictions peut fournir des informations sur l'amélioration des étiquettes ou du modèle lui-même. Le présentateur introduit ensuite le concept de matrice de confusion comme une autre façon d'évaluer les performances du modèle en comparant les étiquettes prédites et vraies d'un grand ensemble d'échantillons de test.
  
  
• 19:05:00 Dans cette section, l'instructeur explique comment évaluer un modèle de classification multiclasse à l'aide d'une matrice de confusion dans PyTorch. La matrice de confusion est une représentation visuelle qui montre les performances du modèle sur différentes classes. L'instructeur explique comment utiliser les métriques de la torche pour les métriques d'évaluation et montre comment accéder aux métriques d'évaluation de la matrice de confusion. De plus, ML extend est utilisé pour tracer la matrice de confusion. Il est important de noter que l'instructeur explique que Google Colab ne dispose pas de la version requise de ML extend et que la version 0.19.0 est nécessaire pour garantir la bonne installation du package. Enfin, la vidéo montre comment faire des prédictions sur l'ensemble de données de test et comment définir le modèle en mode d'évaluation avec le mode d'inférence torche comme gestionnaire de contexte.
  
  
• 19:10:00 Dans cette section, l'instructeur montre comment parcourir le chargeur de données de test pour faire des prédictions à l'aide de PyTorch. Les prédictions sont ajoutées à une liste, puis concaténées dans un tenseur à l'aide de torch.cat. Le tenseur résultant a une prédiction par échantillon de test. L'instructeur installe également les métriques de la torche et montre comment utiliser une boucle d'essai et d'acceptation pour l'importer. Enfin, la version requise de ML extend est vérifiée à l'aide d'une instruction assert à utiliser dans la fonction de matrice de confusion de tracé.
  
  
• 19:15:00 Dans cette section, l'instructeur explique comment installer et mettre à niveau des packages dans Google Colab en utilisant l'exemple d'installation de métriques de torche et de mise à niveau de ML extend vers la version 0.19.0 ou supérieure. L'instructeur parcourt le code et explique comment vérifier si l'installation s'est bien déroulée et que faire si des erreurs surviennent pendant le processus, y compris comment redémarrer l'exécution si nécessaire. Une fois l'installation terminée, l'instructeur explique comment créer une matrice de confusion avec les prédictions qui ont été faites sur l'ensemble des données de test dans la vidéo précédente.
  
  
• 19:20:00 Dans cette section, l'instructeur explique comment créer et tracer une matrice de confusion pour évaluer les performances d'un modèle d'apprentissage en profondeur. Tout d'abord, la classe de matrice de confusion des métriques de torche et la fonction de matrice de confusion de tracé de ML extend sont importées. Ensuite, une instance de matrice de confusion est configurée en passant le nombre de classes comme longueur de la liste des noms de classe. Le tenseur de matrice de confusion est créé en transmettant des prédictions et des cibles sur l'ensemble de données de test. Enfin, la matrice de confusion est tracée à l'aide de la fonction de matrice de confusion de tracé en transmettant le tenseur de la matrice de confusion et la liste des noms de classe, créant une diagonale visuellement agréable montrant les prédictions correctes et les zones potentielles où le modèle fait des erreurs.
  
  
• 19:25:00 Dans cette section, l'instructeur explique l'importance d'utiliser une matrice de confusion pour évaluer visuellement les prédictions d'un modèle de classification, en particulier lorsque les erreurs commises par le modèle sont importantes, comme confondre deux classes de données d'apparence similaire comme des chemises et manteaux. L'utilisation d'une matrice de confusion est un moyen puissant d'évaluer les performances d'un modèle et peut aider à identifier tout problème avec les étiquettes existantes. Il parle également de l'importance d'enregistrer et de charger un modèle entraîné, en particulier lorsque les performances du modèle sont satisfaisantes. En enregistrant le modèle dans un fichier, il peut être utilisé ailleurs ou rechargé pour s'assurer qu'il a été enregistré correctement. L'instructeur explique comment créer un chemin de répertoire de modèle et un chemin d'enregistrement de modèle, puis montre comment enregistrer le dict d'état du modèle à l'aide de la méthode torch.save.
  
  
• 19:30:00 Dans cette section, l'instructeur montre comment enregistrer et charger un modèle PyTorch. Le dictionnaire d'état est enregistré, ce qui représente tous les paramètres appris du modèle après qu'il a été formé. Pour charger le modèle enregistré, une nouvelle instance est créée avec les mêmes paramètres que celle d'origine. Il est important de configurer le modèle chargé avec les mêmes paramètres que l'original pour éviter une erreur d'incompatibilité de forme. Le modèle chargé est ensuite évalué pour s'assurer qu'il produit des résultats similaires à ceux du modèle d'origine. L'instructeur insiste sur l'importance d'évaluer un modèle après l'avoir enregistré et chargé pour s'assurer qu'il a été enregistré correctement.
  
  
• 19:35:00 Dans cette section, nous voyons que le modèle chargé produit les mêmes résultats que le modèle précédemment formé avant d'être enregistré, et nous pouvons utiliser torch.is_close pour vérifier par programmation si les résultats du modèle sont proches les uns des autres. Le niveau de tolérance absolu peut être ajusté pour s'assurer que les résultats sont suffisamment similaires, et s'il y a des écarts, il est recommandé de vérifier si le modèle enregistre correctement et si des graines aléatoires sont configurées. Le flux de travail pour un problème de vision par ordinateur est également discuté, de l'utilisation de matériaux de référence et de bibliothèques comme torchvision à l'évaluation du modèle et à l'expérimentation de modèles de réseau neuronal non linéaire et convolutif pour trouver le meilleur.
  
  
• 19:40:00 Dans cette section de "PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique", l'instructeur encourage les téléspectateurs à mettre en pratique ce qu'ils ont appris jusqu'à présent en se rendant sur le site Web learn pytorch.io et en effectuant les exercices fournis. Les exercices se concentrent sur la pratique du code et des concepts abordés dans les sections précédentes, et un programme supplémentaire est également disponible pour ceux qui souhaitent approfondir la vision par ordinateur. En outre, la section couvre le sujet des ensembles de données personnalisés pytorch et propose des ressources pour obtenir de l'aide si nécessaire, telles que la documentation pytorch et le débordement de pile.
  
  
• 19:45:00 Dans cette section du cours PyTorch, il est expliqué comment travailler avec des ensembles de données personnalisés, ainsi que les différentes bibliothèques de domaine telles que la vision de la torche, le texte de la torche, l'audio de la torche et l'enregistrement de la torche. Les bibliothèques de domaines contiennent des fonctions de chargement de données pour différentes sources de données et sont fournies avec des ensembles de données intégrés tels que des ensembles de données de vision de torche pour des ensembles de données de vision prédéfinis comme Fashion MNIST et des ensembles personnalisés. Chaque bibliothèque de domaine dispose également d'un module "ensembles de données" qui aide les utilisateurs à travailler avec différents ensembles de données dans différents domaines, et selon le domaine dans lequel vous travaillez, comme la vision, le texte, l'audio, la recommandation, il est recommandé de consulter sa bibliothèque personnalisée dans PyTorch.
  
  
• 19:50:00 Dans cette section, l'instructeur explique comment charger des ensembles de données personnalisés dans PyTorch pour les utiliser dans la création d'un modèle de vision par ordinateur. Le modèle qu'ils construiront s'appelle food vision mini, qui classifiera les images de pizza, de sushi et de steak. L'instructeur couvre les différentes étapes impliquées dans la formation d'un modèle, telles que la sélection d'une fonction de perte et d'un optimiseur, la construction d'une boucle de formation et l'évaluation du modèle. Ils expliquent également comment transformer des données à utiliser avec un modèle et comparer des modèles avec et sans augmentation de données. Enfin, ils montrent comment faire des prédictions sur des données personnalisées et fournissent une ressource pour accéder au bloc-notes vidéo dans le référentiel d'apprentissage en profondeur PyTorch.
  
  
• 19:55:00 Dans cette section, l'instructeur explique le processus d'obtention de vos propres données dans PyTorch via des ensembles de données personnalisés. Ils soulignent l'importance d'utiliser des bibliothèques de domaine pour les fonctions de chargement de données et les fonctions de chargement de données personnalisables et donnent des exemples de ces bibliothèques pour diverses catégories telles que la vision, le texte, l'audio et la recommandation. L'instructeur montre également comment importer les bibliothèques nécessaires et configurer un code indépendant de l'appareil pour les meilleures pratiques avec PyTorch. Ils montrent comment vérifier les périphériques CUDA disponibles et comment modifier le type d'exécution pour utiliser les GPU pour un traitement plus rapide. Enfin, l'instructeur fait allusion à l'obtention de données avec lesquelles travailler dans la vidéo suivante.

Partie 21

• 20:00:00 Dans cette section du cours, l'instructeur présente l'ensemble de données Food 101, qui comprend 101 catégories d'aliments différentes avec 101 000 images. Cependant, pour pratiquer l'utilisation de PyTorch, l'instructeur a créé un sous-ensemble plus petit de cet ensemble de données qui comprend trois catégories d'aliments et seulement 10 % des images. Ce jeu de données plus petit contient 750 images d'entraînement, 250 images de test et environ 75 images d'entraînement et 25 images de test par classe. En commençant par cet ensemble de données plus petit, l'objectif est d'accélérer l'expérimentation et de réduire le temps nécessaire à l'apprentissage des modèles. L'instructeur fournit un bloc-notes sur la façon de créer cet ensemble de données personnalisé et encourage les étudiants à commencer petit et à mettre à niveau si nécessaire.
  
  
• 20:05:00 Dans cette section, l'instructeur explique le processus de téléchargement et de préparation d'un ensemble de données d'images pour PyTorch. L'ensemble de données comprend des images de pizza, de steak et de sushi, qui sont stockées dans un dossier appelé data. L'instructeur utilise la bibliothèque de requêtes Python pour télécharger les données, puis les décompresse dans le dossier de données. Le but de cette section est de montrer comment charger des données d'image dans PyTorch, qui peuvent être appliquées à tout projet similaire. L'instructeur insiste sur l'importance d'avoir un répertoire séparé pour les données, qui peut être situé sur un ordinateur local ou dans le cloud.
  
  
• 20:10:00 Dans cette section, l'instructeur explique comment utiliser la bibliothèque Python, zipfile, pour extraire des données d'un fichier zip. Ils utilisent l'exemple de l'extraction d'un fichier zip contenant des images de pizza, de steak et de sushi pour un problème de vision par ordinateur d'apprentissage automatique. L'instructeur montre comment extraire le contenu du fichier zip vers un chemin de fichier spécifique à l'aide de la méthode zipfile.extractall(). Ils corrigent également une erreur dans le code résultant de la copie de la mauvaise adresse de lien à partir de GitHub, soulignant l'importance de s'assurer que le bon lien est utilisé pour télécharger les ensembles de données. Dans l'ensemble, le processus illustré peut être utilisé pour télécharger et extraire n'importe quel ensemble de données personnalisé à utiliser dans PyTorch. La prochaine vidéo explorera les données plus en détail.
  
  
• 20:15:00 Dans cette section, l'instructeur discute de l'importance de ne faire qu'un avec les données grâce à la préparation et à l'exploration des données. Il partage une citation inventée de la fonction de perte d'Abraham, soulignant la nécessité de passer suffisamment de temps à préparer l'ensemble de données. L'instructeur parcourt ensuite chaque répertoire des exemples de données téléchargés, qui sont dans un format de classification d'image standard. Il utilise la fonction de marche par points du système d'exploitation pour générer une arborescence de répertoires pour chaque répertoire, affichant des informations sur les répertoires et les images présentes dans chacun d'eux. Enfin, l'instructeur configure les parties de formation et de test et montre la configuration standard de la classification d'images pour eux.
  
  
• 20:20:00 Dans cette section, l'instructeur explique la structure de données de classification d'image standard dans laquelle un dossier d'ensemble de données global contient des dossiers de formation et de test avec des sous-répertoires nommés par classe qui contiennent des images respectives. L'instructeur note qu'il existe des méthodes normalisées de stockage de types de données spécifiques comme référence pour les formats de données. Pour préparer les données d'image à utiliser avec PyTorch, un code est écrit pour convertir les données en tenseurs. L'instructeur met en évidence le format de données nécessaire pour classer les images de chiens et de chats, où les répertoires d'images d'entraînement et de test contiennent des dossiers de classe respectifs. L'instructeur mentionne également des plans pour visualiser une image et un code pour y parvenir, ce qui implique d'obtenir tous les chemins d'image, de choisir un chemin d'image aléatoire, d'obtenir le nom de la classe d'image à l'aide du module Pathlib.
  
  
• 20:25:00 Dans cette section, l'instructeur explique comment ouvrir et manipuler des images à l'aide de la bibliothèque d'images Python appelée Pillow. Tout d'abord, ils génèrent une liste de tous les chemins d'image dans un dossier spécifique et utilisent la bibliothèque aléatoire de Python pour sélectionner au hasard une image dans cette liste. Ils ouvrent et affichent ensuite l'image tout en extrayant les métadonnées la concernant. De plus, l'instructeur donne un aperçu des capacités de la bibliothèque Torch Vision, y compris les méthodes de chargement et de traitement des images.
  
  
• 20:30:00 Dans cette section, l'instructeur montre comment travailler avec des images à l'aide de la bibliothèque PIL et comment ouvrir et analyser des métadonnées d'image. La classe d'image est le nom du répertoire dans lequel les données d'image sont stockées et les métadonnées sont obtenues à l'aide de la fonction d'impression. L'instructeur montre ensuite des images d'aliments aléatoires à partir de l'ensemble de données, notamment des pizzas, des sushis et des steaks, et explique l'importance de visualiser des images au hasard pour se familiariser avec l'ensemble de données. L'instructeur propose un petit défi aux téléspectateurs, qui consiste à visualiser une image à l'aide de Matplotlib pour la section suivante.
  
  
• 20:35:00 Dans cette section, l'instructeur montre comment tracer des images et des données avec matplotlib et transformer des images en tableaux à l'aide de la méthode NumPy NP. L'importance de comprendre la forme des données est soulignée pour éviter les problèmes d'incompatibilité de forme. Le format par défaut pour la bibliothèque de pilules et matplotlib est le dernier format des canaux de couleur, mais PyTorch utilise par défaut le premier format des canaux de couleur. L'instructeur montre également comment visualiser différentes images et se familiariser avec les données, et comment transformer les données en les convertissant en tenseurs PyTorch à utiliser avec PyTorch.
  
  
• 20:40:00 Dans cette section, l'instructeur décrit le processus de transformation des données cibles en tenseurs PyTorch et de création d'ensembles de données PyTorch et de chargeurs de données. À l'aide de la documentation PyTorch, l'instructeur montre comment créer des ensembles de données avec le module de dossier d'images et présente le paramètre de transformation qui permet l'application de transformations spécifiques sur les données. L'instructeur montre ensuite comment créer une transformation pour les données d'image qui redimensionne les images à 64x64 et les retourne de manière aléatoire sur le plan horizontal pour augmenter artificiellement la diversité de l'ensemble de données. Ceci est fait en utilisant la méthode transforms.compose qui prend une liste de transformations comme argument.
  
  
• 20:45:00 Dans cette section, l'instructeur explique comment transformer une image en tenseur de torche à l'aide du module de transformation de PyTorch. Cela se fait avec la fonction "transforms.ToTensor()", qui convertit une image PIL ou un tableau NumPy de hauteur avec des canaux de couleur dans la plage de 0 à 255 en un tenseur flottant de la forme des canaux de couleur de forme largeur de hauteur dans la plage de 0 à 1. L'instructeur suggère d'essayer de transmettre des données via cette transformation et montre comment modifier la forme de l'image à l'aide de la fonction "transforms.Resize()". La section se termine par une discussion sur les différentes transformations disponibles dans la bibliothèque torchvision, y compris les transformations d'augmentation de données, et un aperçu du code de visualisation à venir pour explorer les images transformées.
  
  
• 20:50:00 Dans cette section, l'instructeur montre comment échantillonner au hasard des images à partir d'un chemin, les charger et les transformer, puis comparer les versions originales et transformées à l'aide de PyTorch. Le code utilise la fonction de graine aléatoire pour définir la graine de la fonction aléatoire et échantillonne de manière aléatoire k images à partir de la liste des chemins d'image. L'instructeur utilise ensuite la bibliothèque matplotlib pour créer une sous-parcelle avec une ligne et n colonnes pour tracer côte à côte les images originales et transformées. L'image transformée doit avoir sa forme modifiée pour s'adapter en dernier au format de canaux de couleur préféré de la bibliothèque matplotlib. Enfin, le code définit le titre des images originales et transformées et définit le super titre sur le nom de classe de l'image.
  
  
• 20:55:00 Dans cette section de la vidéo, l'instructeur montre comment utiliser des transformations pour manipuler des données d'image pour des modèles d'apprentissage en profondeur à l'aide de PyTorch. L'instructeur définit la transformation pour qu'elle soit égale à la transformation des données, ce qui signifie que l'image sera redimensionnée, retournée horizontalement de manière aléatoire et convertie en tenseur. Ils montrent également comment utiliser la fonction permuter pour réorganiser la forme des données en inversant l'ordre des axes. Les images sont ensuite tracées pour afficher les versions originales et transformées côte à côte, avec les images transformées au format tenseur, ce qui est idéal pour une utilisation avec des modèles d'apprentissage en profondeur. L'instructeur indique que la taille de l'image est un hyper paramètre qui peut être ajusté et encourage les spectateurs à explorer le large éventail de transformations disponibles dans PyTorch.

Partie 22

• 21:00:00 Dans cette section, l'instructeur explique comment charger des données d'image à l'aide de l'option de dossier d'images. Ils utilisent le module d'ensembles de données de vision de la torche pour montrer comment charger des données dans le format de classification d'image générique. La fonction d'ensembles de données prédéfinis, dossier d'images, est démontrée et peut ensuite être utilisée pour charger toutes les images personnalisées dans des tenseurs à l'aide de transformations. L'instructeur montre ensuite comment transformer l'ensemble de données de formation et créer un ensemble de données de test, qui sera également transformé de la même manière que l'ensemble de données de formation. Enfin, ils impriment les ensembles de données créés.
  
  
• 21:05:00 Dans cette section, l'instructeur explique comment utiliser la fonction de dossier d'images dans PyTorch pour charger des images dans des tenseurs et les transformer à l'aide d'un pipeline, qui peut ensuite être utilisé avec un modèle PyTorch. Ils montrent comment accéder et utiliser divers attributs fournis avec le chargeur de données prédéfini, tels que l'obtention de noms de classe sous forme de liste ou de dictionnaire et la vérification de la longueur de l'ensemble de données. En outre, ils montrent comment visualiser des échantillons et des étiquettes à partir de l'ensemble de données d'apprentissage à l'aide de l'indexation.
  
  
• 21:10:00 Dans cette section du cours, l'instructeur montre comment convertir un jeu de données d'image au format tenseur, qui est le format de données par défaut pour PyTorch. Ils utilisent un exemple d'image de pizza et montrent comment obtenir son étiquette associée et la convertir au format numérique. Ils impriment ensuite des informations importantes sur les données du tenseur, comme son type de données et sa forme, qui seront utiles pour le dépannage ultérieur. Enfin, ils tracent l'image à l'aide de matplotlib et définissent le titre sur le nom de la classe, qui dans ce cas est pizza. Ils encouragent les élèves à essayer cela avec différentes images et à explorer différentes transformations.
  
  
• 21:15:00 Dans cette section de la vidéo, l'instructeur explique le processus de conversion des images chargées en chargeurs de données dans PyTorch. Un chargeur de données peut aider à transformer des ensembles de données en itérables, permettant aux utilisateurs de personnaliser la taille du lot et d'afficher un nombre spécifique d'images à la fois. Ceci est important car si toutes les images étaient chargées en même temps, il y a un risque de manquer de mémoire. Par conséquent, la mise en lots des images aide à tirer parti de toute la mémoire disponible. L'instructeur poursuit en fournissant un guide étape par étape pour créer un chargeur de données de train et introduit également le concept du nombre de paramètres de travail, qui décide du nombre de cœurs de processeur utilisés pour charger les données.
  
  
• 21:20:00 Dans cette section, l'instructeur explique comment créer et personnaliser des chargeurs de données pour former et tester des données dans PyTorch. Il montre comment initialiser les ensembles de données et personnaliser les hyperparamètres pour les chargeurs de données, tels que la taille du lot et le nombre de travailleurs. L'instructeur montre également comment parcourir les chargeurs et obtenir des informations sur la forme des images et des étiquettes. La section se termine par un résumé du processus de chargement et une recommandation pour construire un réseau de neurones convolutionnels pour identifier les modèles dans les tenseurs d'image.
  
  
• 21:25:00 Dans cette section, l'instructeur décrit le processus de création d'une classe de chargement de données personnalisée pour charger des données d'image au format Tensor. L'objectif est de répliquer la fonctionnalité du dossier d'image via cette classe personnalisée, car il s'agit d'une bonne pratique et peut être nécessaire dans les cas où une fonction prédéfinie n'existe pas. L'instructeur répertorie les étapes requises pour que la classe personnalisée charge des images, obtienne les noms de classe sous forme de liste et obtienne les classes sous forme de dictionnaire à partir de l'ensemble de données. Les avantages et les inconvénients de la création d'un ensemble de données personnalisé sont également abordés, y compris la flexibilité de créer un ensemble de données à partir de presque n'importe quoi, mais aussi le potentiel d'erreurs et de problèmes de performances. L'instructeur importe ensuite les modules nécessaires pour créer la classe personnalisée, y compris le système d'exploitation et la bibliothèque de chemin pour travailler avec le système de fichiers.
  
  
• 21:30:00 Dans cette section, nous apprenons à créer un ensemble de données personnalisé dans PyTorch et nous nous concentrons sur l'écriture d'une fonction pour obtenir les noms de classe à partir du répertoire cible. L'ensemble de données personnalisé sera utilisé pour charger des images à partir d'un fichier, obtenir des noms de classe à partir de l'ensemble de données et obtenir des classes sous forme de dictionnaire à partir de l'ensemble de données. La fonction utilisera le scanner du système d'exploitation pour parcourir le répertoire cible et obtenir les noms de classe et générer une erreur si les noms de classe ne sont pas trouvés, indiquant un problème avec la structure du répertoire. Nous sous-classerons plus tard le torch.utils.data.Dataset pour créer un jeu de données personnalisé.
  
  
• 21:35:00 Dans cette section de la vidéo, l'instructeur montre comment créer une fonction appelée "find_classes" qui prend un répertoire sous forme de chaîne et renvoie une liste de noms de classe et un dictionnaire qui associe les noms de classe à des nombres entiers. La fonction utilise le scanner du système d'exploitation pour analyser le répertoire cible et obtenir les noms de classe. L'instructeur montre également comment générer une erreur si les noms de classe sont introuvables. La fonction peut être utilisée pour n'importe quel répertoire donné, et elle réplique la fonctionnalité effectuée auparavant pour le répertoire de formation.
  
  
• 21:40:00 Dans cette section de la vidéo, l'instructeur explique comment créer un ensemble de données personnalisé en sous-classant torch.utils.data.dataset. L'ensemble de données doit représenter une carte des clés aux échantillons de données, où les clés font référence à des cibles ou des étiquettes, et les échantillons de données dans ce cas sont des images d'aliments. La sous-classe doit remplacer la méthode get item , qui récupère un échantillon de données pour une clé donnée et éventuellement remplacer la méthode len pour renvoyer la taille de l'ensemble de données. L'instructeur parcourt les étapes de création de l'ensemble de données personnalisé et explique comment utiliser la fonction d'assistance que nous avons créée dans la section précédente pour mapper les noms de classe sur des nombres entiers.
  
  
• 21:45:00 Dans cette section, l'instructeur explique comment créer un ensemble de données personnalisé dans PyTorch. Pour ce faire, nous devons sous-classer la classe torch.utils.data.Dataset et initialiser notre ensemble de données personnalisé en passant le répertoire cible (où résident les données) et transformer (pour effectuer toutes les transformations de données). De plus, nous devons créer plusieurs attributs tels que des chemins, des transformations, des classes et des classes pour l'ID X. De plus, nous devons créer une fonction pour charger des images, remplacer la méthode LAN pour renvoyer la longueur de notre ensemble de données, et le get méthode d'élément pour retourner un échantillon donné lorsqu'un index est passé. Enfin, nous écrivons un ensemble de données personnalisé en implémentant pathlib et en passant des répertoires cibles comme les répertoires test ou train.
  
  
• 21:50:00 Dans cette section, l'instructeur explique les différentes étapes impliquées dans la création d'une classe d'ensemble de données PyTorch personnalisée. La première étape consiste à obtenir tous les chemins d'accès aux images qui suivent la convention de nom de fichier correcte. L'étape suivante consiste à créer un ensemble de transformations d'image, qui peuvent être facultatives. Une fonction de chargement d'images est également créée, qui prend un index et renvoie une image. L'instructeur montre ensuite comment remplacer la méthode "len" pour renvoyer le nombre total d'échantillons dans l'ensemble de données, ce qui est facultatif. Enfin, la méthode "get item" est écrasée afin qu'elle renvoie un échantillon particulier si un index est passé.
  
  
• 21:55:00 Dans cette section, nous apprenons à sous-classer torch.utils.data.Dataset pour personnaliser la façon dont les données sont chargées dans PyTorch. La classe est initialisée avec un répertoire racine et un dictionnaire mappant les noms de classe aux index. La méthode __len__ renvoie la longueur de l'ensemble de données tandis que __getitem__ permet l'indexation dans l'ensemble de données pour renvoyer un tuple d'une image de tenseur de torche et l'étiquette entière correspondante. La classe a également un paramètre de transformation facultatif pour appliquer des transformations sur l'image avant de renvoyer le tuple. Les avantages de sous-classer torch.utils.data.Dataset sont les capacités de personnalisation qu'il offre, mais cela nécessite d'écrire des quantités importantes de code qui peuvent être sujettes à des erreurs.

Partie 23

• 22:00:00 Dans cette section, l'instructeur montre comment créer un jeu de données personnalisé dans PyTorch à l'aide du module Torchvision. Ils créent une transformation pour convertir les images JPEG brutes en tenseurs et configurent la composition des transformations d'entraînement et de test. Ils testent ensuite la classe de dossiers d'images personnalisées et voient si cela fonctionne sur leur propre jeu de données personnalisé. Ils vérifient les attributs de longueur et de classe pour s'assurer que cela fonctionne correctement. Enfin, ils inspectent les données de train personnalisées et testent les données personnalisées pour vérifier que tout fonctionne comme prévu.
  
  
• 22:05:00 Dans cette section du cours complet PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique, l'instructeur montre comment vérifier l'égalité entre l'ensemble de données du dossier d'image d'origine et l'ensemble de données personnalisé qu'il a créé dans la section précédente en comparant la classe à l'ID X des deux ensembles de données. Il affirme que nous pouvons répliquer la fonctionnalité principale de la classe d'ensemble de données de dossier d'image en créant notre propre fonction de chargement d'ensemble de données personnalisée, et les points à retenir sont que PyTorch fournit une classe d'ensemble de données de base dont hériter, et tant que nous remplaçons la terre et obtenir des méthodes d'élément et renvoyer une sorte de valeurs, nous pouvons créer notre propre fonction de chargement d'ensemble de données. L'instructeur explique ensuite comment créer une fonction pour afficher des images aléatoires à partir de la classe personnalisée de données formées afin de visualiser nos données.
  
  
• 22:10:00 Dans cette section, l'instructeur parcourt les étapes de création d'une fonction appelée "afficher des images aléatoires" qui prend un "ensemble de données", des "classes" et "n" comme paramètres. La fonction affiche un nombre n d'images sélectionnées au hasard dans l'ensemble de données et imprime sa forme si la "forme d'affichage" est définie sur vrai. L'instructeur passe également en revue les détails de mise en œuvre tels que le réglage de l'affichage si n est supérieur à 10 et la définition de la graine aléatoire pour la reproductibilité. De plus, la fonction parcourt les exemples d'images ou d'index aléatoires et les trace avec Matplotlib.
  
  
• 22:15:00 Dans cette section, l'instructeur continue à construire son modèle d'apprentissage en profondeur dans PyTorch en configurant l'intrigue et en s'assurant que les dimensions de ses images sont alignées avec matplotlib. Ils ajustent leurs dimensions de tenseur pour le traçage, ajoutent une sous-parcelle à leur tracé matplotlib et ajustent le titre du tracé en fonction de la variable classes, une liste de classes. Ils créent ensuite une fonction pour afficher des images aléatoires à partir du dossier d'images, à la fois pour le dossier d'images pytorch intégré et pour l'ensemble de données personnalisé créé par l'instructeur. Enfin, ils ajustent la graine et tracent les images pour voir comment leur code d'ajustement de l'intrigue a du sens.
  
  
• 22:20:00 Dans cette section de la transcription, l'instructeur montre comment transformer un ensemble de données d'image chargé personnalisé en chargeurs de données, ce qui est une étape nécessaire pour grouper les images et les utiliser avec un modèle. À l'aide de torchvision.datasets.ImageFolder et torchvision.transforms, l'ensemble de données personnalisé est transformé en un format tenseur. L'étape suivante consiste à transformer l'ensemble de données en chargeur de données à l'aide de torch.utils.data.DataLoader. L'instructeur définit la taille du lot sur 32 et le nombre de travailleurs sur 0 pour le chargeur de données de train personnalisé et le chargeur de données de test personnalisé. La différence entre eux est que les données de train seront mélangées alors que les données de test ne seront pas mélangées.
  
  
• 22:25:00 Dans cette section, la vidéo couvre les chargeurs de données personnalisés et la transformation des données dans PyTorch. L'instructeur réinitialise d'abord le nombre de processeurs OOS et définit les travailleurs insensibles à zéro pour garantir le bon déroulement de la formation. Après avoir configuré le chargeur de données personnalisé, il utilise la fonction d'impression pour vérifier la forme de l'image et la taille du lot, qui ont été définies sur 32 par la transformation précédemment configurée. L'instructeur explique également comment l'augmentation des données peut augmenter artificiellement la diversité de l'ensemble de données de formation et montre les différentes façons dont les données peuvent être transformées à l'aide du module de transformation de la vision de la torche, y compris le redimensionnement, le recadrage central, les niveaux de gris, les transformations aléatoires et l'augmentation aléatoire. .
  
  
• 22:30:00 a appris l'augmentation des données, qui consiste à ajouter artificiellement de la diversité à vos données d'entraînement en appliquant diverses transformations d'image. Cela permet de rendre le modèle plus généralisable à des données invisibles. Il existe de nombreux types d'augmentation de données tels que le recadrage, le remplacement, le cisaillement, etc. PyTorch dispose d'un package de vision torche qui comprend des primitives ou des fonctions qui peuvent aider à entraîner les modèles à bien fonctionner. En utilisant l'augmentation des données et d'autres améliorations, PyTorch a été en mesure de former des modèles de pointe avec une grande précision, tels que le modèle ResNet 50.
  
  
• 22:35:00 Dans cette section, l'instructeur discute des moyens d'améliorer la précision du modèle, tels que l'optimisation du taux d'apprentissage, la formation plus longue et l'utilisation de différentes techniques d'augmentation. L'instructeur se concentre sur la technique d'augmentation triviale, qui exploite la puissance du caractère aléatoire pour modifier les images de différentes manières à l'aide d'un certain nombre de cases de magnitude. L'instructeur montre comment mettre en œuvre une augmentation triviale à l'aide de la bibliothèque de transformations de la vision de la torche PyTorch et fournit un lien vers l'article pour ceux qui souhaitent en savoir plus à ce sujet. De plus, l'instructeur conseille d'essayer différentes techniques et expériences d'augmentation pour voir ce qui fonctionne le mieux pour les problèmes individuels. Enfin, l'instructeur montre comment tester le pipeline d'augmentation en obtenant tous les chemins d'accès aux images et en englobant tous les fichiers et dossiers correspondant à un modèle spécifique.
  
  
• 22:40:00 Dans cette section, la vidéo montre l'utilisation de l'augmentation triviale, une technique d'augmentation de données, dans la transformation d'images pour ajouter artificiellement de la diversité à un ensemble de données d'apprentissage. Le pouvoir du hasard est exploité en sélectionnant parmi différents types d'augmentation et en les appliquant avec différents niveaux d'intensité. Cette section montre comment l'augmentation triviale est appliquée aux images transformées de manière aléatoire, et les résultats sont affichés. L'objectif est de permettre au modèle d'apprentissage automatique d'apprendre les motifs des images manipulées et de pouvoir les identifier en conséquence. La section suivante se concentre sur la construction du premier modèle de vision par ordinateur sans augmentation de données à l'aide de la minuscule architecture VGG.
  
  
• 22:45:00 Dans cette section, le présentateur passe par le processus de création de transformations et de chargement de données pour un modèle PyTorch. L'objectif est de charger des images à partir du dossier de données, dans ce cas, une pizza, un steak et des sushis, et de les transformer en tenseurs. Les transformations incluent le redimensionnement des images en 64x64 et leur conversion en tenseurs afin que les valeurs soient comprises entre 0 et 1. Le présentateur explique également comment créer des chargeurs de données et ajuster la taille du lot et le nombre de cœurs de processeur dédiés au chargement des données. La taille de lot utilisée dans cet exemple est 32.
  
  
• 22:50:00 Dans cette section, l'instructeur explique comment charger et transformer des données à l'aide de DataLoader de PyTorch. Le processus implique la création d'une transformation, puis le chargement et la transformation des données en même temps à l'aide de la fonction DataLoader. L'instructeur fournit également un code simple pour créer l'architecture Tiny VGG à partir de zéro, ce qui inclut la création du premier bloc COM composé de couches telles que COM, ReLU, MaxPool et ComToD. Le modèle est initialisé avec la forme d'entrée, les unités masquées et les paramètres de forme de sortie. L'instructeur encourage les apprenants à expérimenter différentes valeurs pour les hyperparamètres tels que la taille du noyau et la foulée.
  
  
• 22:55:00 Dans cette section, nous voyons la création d'un réseau neuronal convolutif à l'aide de PyTorch. Nous commençons par définir les blocs convolutifs et les couches de pooling maximales pour le réseau. Ensuite, nous reproduisons le même bloc pour en créer un autre et modifions la forme d'entrée pour qu'elle corresponde à la forme de sortie. Ensuite, nous créons une couche de classificateur pour transformer la sortie des blocs convolutifs en un vecteur de caractéristiques et la faire passer à travers une couche linéaire pour produire dix classes. Enfin, nous redéfinissons la méthode directe pour faire passer les données à travers les blocs convolutifs et imprimer sa forme à chaque étape. La méthode directe pourrait également être réécrite pour inclure la fusion d'opérateurs, ce qui accélère le calcul GPU.

Partie 24

• 23:00:00 Dans cette section, l'instructeur aborde le concept de fusion d'opérateurs, qui est l'optimisation la plus importante dans les compilateurs d'apprentissage en profondeur. Ils créent également un modèle utilisant la minuscule architecture VGG pour les images couleur RVB et vérifient ses formes d'entrée et de sortie. L'instructeur souligne l'importance d'utiliser la fusion d'opérateurs pour accélérer le calcul de grands réseaux de neurones en évitant le transport entre la mémoire et le calcul. Ils suggèrent également de transmettre des données factices à travers le modèle pour le dépanner et s'assurer que la méthode directe fonctionne correctement. Enfin, un message d'erreur s'affiche lorsque vous essayez de transmettre le lot d'images au modèle en raison d'une incompatibilité dans les types d'entrée.
  
  
• 23:05:00 Dans cette section, l'instructeur résout une erreur de forme pour le modèle. Ils expliquent que les règles de multiplication matricielle doivent être satisfaites lors du passage des tenseurs à travers des couches linéaires. L'instructeur examine les formes de la matrice et détermine que 10, qui représente le nombre d'unités masquées, pose un problème lorsqu'il est multiplié par 2 560. Il utilise la forme de sortie du calque précédent pour déterminer que 10 doit être multiplié par 16 x 16 pour obtenir 2 560. Après correction cela et en vérifiant que les formes du modèle s'alignent sur la sortie de l'explicateur CNN, ils passent à un dépannage plus approfondi et découvrent finalement que la suppression du rembourrage des couches convolutives alignera les formes avec la sortie de l'explicateur CNN.
  
  
• 23:10:00 Dans cette section, l'instructeur présente Torch Info, un package qui permet aux utilisateurs d'imprimer un résumé de leurs modèles PyTorch. Tout d'abord, l'instructeur commente les instructions d'impression de la méthode directe et installe Torch Info dans Google CoLab à l'aide de la commande pip install. L'instructeur importe ensuite le résumé de Torch Info et l'utilise pour transmettre le modèle et une taille d'entrée pour obtenir les formes des données circulant dans le modèle. L'instructeur montre comment Torch Info imprime un résumé du modèle, y compris les calques et leurs formes correspondantes.
  
  
• 23:15:00 Dans cette section, l'orateur discute du package d'informations de la torche, qui est utilisé pour donner une idée des formes d'entrée et de sortie de chaque couche dans un modèle PyTorch. Ils expliquent que le package fournit également des informations sur le nombre de paramètres dans chaque couche, ce qui peut être utile pour déterminer la taille du modèle et les contraintes de stockage pour les applications futures. L'orateur note qu'à mesure qu'un modèle s'agrandit et comporte plus de couches, il aura plus de paramètres, ce qui se traduira par une taille d'entrée plus grande et une taille totale estimée. Dans la section suivante, l'orateur s'oriente vers la formation d'un ensemble de données personnalisé et crée deux fonctions - étape d'entraînement et étape de test - qui sont génériques et peuvent être utilisées avec presque tous les modèles et chargeurs de données. La fonction train step prend en charge un modèle, un chargeur de données, une fonction de perte et un optimiseur, et met le modèle en mode train tout en configurant les métriques d'évaluation.
  
  
• 23:20:00 Dans cette section, le conférencier discute de la configuration des valeurs de perte de train et de précision du train pour une fonction de boucle de train dans PyTorch. Les données sont parcourues en boucle à l'aide du chargeur de données, et pour chaque lot, la passe avant est effectuée pour faire des prédictions et calculer la perte. L'optimiseur est ensuite utilisé pour effectuer une rétropropagation et franchir une étape. Une fois la boucle de train terminée, la précision est calculée en obtenant la classe prédite et en la comparant aux étiquettes correctes. Cela se fait en dehors de la boucle de lot, où la perte de train et la précision du train sont ajustées pour obtenir la moyenne par époque sur tous les lots. L'orateur défie ensuite les téléspectateurs d'écrire une fonction de boucle de test.
  
  
• 23:25:00 Dans cette section, l'instructeur passe par le processus de création d'une étape de test pour évaluer les performances d'un modèle d'apprentissage en profondeur PyTorch sur un ensemble de données. L'étape consiste à configurer le modèle en mode d'évaluation, à parcourir les lots de l'ensemble de données, à envoyer les données à l'appareil cible, à effectuer une passe avant, à calculer la perte et la précision par lot, à accumuler la perte et la précision et à ajuster les mesures. pour obtenir les valeurs moyennes. L'instructeur propose alors de créer une fonction d'entraînement pour fonctionnaliser le processus d'entraînement du modèle, qui sera traité dans la section suivante.
  
  
• 23:30:00 Dans cette section, l'instructeur parcourt le processus de création d'une fonction d'entraînement qui combine les fonctions d'étape d'entraînement et d'étape de test. L'idée est de créer une fonction pour appeler ces deux fonctions pour former et évaluer un modèle avec un seul appel de fonction. La fonction d'entraînement prend en compte une gamme de paramètres de modèle, notamment l'optimiseur, les chargeurs de données, la fonction de perte, etc. L'instructeur crée ensuite un dictionnaire vide pour aider à suivre les performances du modèle pendant l'entraînement, y compris la perte et la précision de l'entraînement et du test. Ils parcourent ensuite les époques, appelant TQDM pour obtenir une barre de progression pendant que le modèle s'entraîne. La fonction d'entraînement est un outil utile pour ne pas avoir à réécrire le code lors de la formation de plusieurs modèles et de l'exploitation du code existant.
  
  
• 23:35:00 Dans cette section, l'instructeur explique la fonction d'entraînement qui assure le suivi de la formation et des tests en utilisant respectivement les fonctions d'entraînement et d'étape de test. La fonction fonctionnera pendant un nombre spécifié d'époques, et pour chaque époque, elle imprimera le train et testera la perte et la précision à l'aide d'une instruction d'impression sophistiquée. Les résultats seront stockés dans le dictionnaire de résultats pour être utilisés ultérieurement pour l'analyse. La fonction d'entraînement tirera parti de la fonction d'étape d'entraînement et de la fonction d'étape de test pour mettre à jour le modèle et le tester respectivement. La fonction renverra les résultats de l'époque.
  
  
• 23:40:00 Dans cette section, l'instructeur passe en revue les progrès réalisés dans le flux de travail PyTorch, qui comprend la préparation des données, la construction et la sélection d'un modèle, la construction d'une boucle de formation, et maintenant le défi de créer une fonction de perte et un optimiseur. Passant à la section 7.7, l'instructeur explique comment former et évaluer le modèle zéro, le modèle de référence, sur son ensemble de données personnalisé. Ils ont défini les graines aléatoires pour la reproductibilité, instancié le petit modèle VGG avec une forme d'entrée de trois pour les images couleur, défini le nombre d'unités cachées et la forme de sortie pour correspondre au nombre de classes dans leur ensemble de données d'apprentissage. Ils sélectionnent également la fonction de perte d'entropie croisée pour la classification multiclasse et essaient l'optimiseur Adam avec un taux d'apprentissage de 0,001.
  
  
• 23:45:00 Dans cette section, l'instructeur montre comment chronométrer le processus de formation d'un modèle d'apprentissage en profondeur. Ils importent d'abord la classe de minuterie par défaut à partir de l'heure, puis démarrent la minuterie avant d'entraîner le modèle zéro à l'aide de la fonction d'entraînement d'une vidéo précédente. Ils ont ensuite défini les données d'entraînement pour entraîner le chargeur de données simple et les données de test pour tester le chargeur de données simple, ainsi que l'optimiseur sur FriendlyAtomOptimizer et la fonction de perte sur la perte d'entropie croisée n. Le modèle est entraîné pendant cinq époques et le chronomètre s'arrête pour afficher le temps d'entraînement total. L'instructeur montre ensuite les résultats de précision du modèle sur les ensembles d'entraînement et de test, qui sont respectivement d'environ 40 % et 50 %. Ils suggèrent d'essayer différentes méthodes pour améliorer le modèle, telles que l'ajout de couches ou d'unités cachées, l'ajustement plus long, la modification des fonctions d'activation et l'ajustement du taux d'apprentissage.
  
  
• 23:50:00 Dans cette section, l'instructeur explique comment tracer des courbes de perte pour suivre la progression du modèle au fil du temps. Une courbe de perte est un moyen de suivre la progression d'un modèle dans le temps en visualisant la valeur de perte sur la gauche et les étapes sur l'axe inférieur. En traçant les valeurs de perte et de précision d'entraînement et de test de notre dictionnaire de résultats à l'aide de matplotlib, nous pouvons voir comment notre modèle fonctionne et l'évaluer. L'instructeur écrit une fonction appelée "def plot loss curves" qui prend dans un dictionnaire de résultats contenant les valeurs de perte et de précision sous forme de chaîne et une liste de flottants.
  
  
• 23:55:00 Dans cette section, l'instructeur montre comment créer des courbes de perte pour les données d'entraînement et de test en utilisant des époques comme mesure du temps. L'intrigue se compose de deux sous-intrigues, une pour la perte et une autre pour la précision, avec des étiquettes et des titres pour chacune d'elles. La tendance idéale pour une courbe de perte est que la perte diminue avec le temps et que la précision augmente. L'instructeur encourage le spectateur à expérimenter des époques supplémentaires pour voir si la perte atteint la valeur optimale. La vidéo suivante couvrira différentes formes de courbes de perte, et l'instructeur recommande un guide sur l'interprétation des courbes de perte.

[MetaQuotes]

PyTorch pour Deep Learning & Machine Learning - Cours complet (description des parties 25-26)

PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique - Cours complet

Partie 25

• 24:00:00 Dans cette section du cours PyTorch pour Deep Learning & Machine Learning, l'instructeur discute des courbes de perte et de leur importance dans l'évaluation des performances d'un modèle au fil du temps. Une courbe de perte doit montrer une tendance à la diminution de la perte au fil du temps et à l'augmentation de la précision. Il existe différentes formes de courbes de perte, et une courbe de perte idéale montre que la perte d'entraînement et de test diminue à un rythme similaire. Le sous-ajustement se produit lorsque la perte du modèle pourrait être inférieure, tandis que le surajustement se produit lorsque le modèle apprend trop bien les données d'apprentissage, ce qui entraîne une perte d'apprentissage inférieure à la perte de test. L'instructeur fournit un programme supplémentaire à partir du guide de la courbe de perte de Google et discute des méthodes pour traiter le surajustement, telles que les techniques de régularisation et la réduction de la complexité du modèle.
  
  
• 24:05:00 quelques façons de réduire le surajustement dans votre modèle d'apprentissage en profondeur qui ont été abordées dans cette section. Obtenir plus de données grâce à l'augmentation des données ou à une meilleure qualité des données peut aider votre modèle à apprendre des modèles plus généralisables. L'utilisation de l'apprentissage par transfert en prenant des modèles appris à partir de modèles pré-formés et en les appliquant à votre propre ensemble de données peut également être efficace. Simplifier votre modèle en réduisant le nombre de calques ou d'unités masquées peut également vous aider. La décroissance du taux d'apprentissage peut aider en diminuant le taux d'apprentissage au fil du temps, et un arrêt précoce peut arrêter le processus d'entraînement avant que le surapprentissage ne se produise.
  
  
• 24:10:00 Dans cette section, le concept d'arrêt précoce est abordé en tant que méthode de gestion du surajustement dans l'apprentissage automatique. Avant que l'erreur de test ne commence à augmenter, l'erreur de test du modèle est suivie et le modèle est arrêté de s'entraîner ou les poids/modèles sont enregistrés là où la perte du modèle était la plus faible. Différentes méthodes pour gérer le sous-ajustement sont également explorées, telles que l'ajout de couches/unités supplémentaires au modèle, l'ajustement du taux d'apprentissage, la formation plus longue et l'utilisation de l'apprentissage par transfert. L'équilibre entre le surajustement et le sous-ajustement est souligné, et l'importance d'évaluer les performances d'un modèle dans le temps à l'aide de courbes de perte est soulignée. Enfin, les moyens d'éviter de trop régulariser le modèle et de se retrouver avec un sous-ajustement sont discutés, et l'objectif d'atteindre un juste équilibre entre le sous-ajustement et le surajustement est souligné.
  
  
• 24:15:00 Dans cette section de la vidéo sur PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique, l'instructeur aborde le concept de sur-ajustement et de sous-ajustement dans les modèles, ainsi que les moyens de les gérer. L'augmentation des données est l'une des méthodes introduites pour faire face au surajustement, où les images sont manipulées pour augmenter la diversité de l'ensemble de données d'apprentissage. L'instructeur poursuit ensuite en expliquant comment créer une transformation avec augmentation des données et charger des données à l'aide de ces transformations pour créer des ensembles de données d'entraînement et de test et des chargeurs de données. La vidéo souligne l'importance d'essayer différents modèles avec divers ajustements et transformations pour trouver le meilleur ajustement à un problème particulier.
  
  
• 24:20:00 Dans cette section de la vidéo, l'instructeur décrit le processus de création d'un ensemble de données et d'un chargeur de données à l'aide des transformations PyTorch et de la classe ImageFolder. Ils fournissent des exemples de code et encouragent les téléspectateurs à le tester par eux-mêmes s'ils le souhaitent. L'ensemble de données est créé à partir d'images de pizza, de steak et de sushi pour les dossiers de formation et de test. L'instructeur explique également l'importance d'être clair avec les noms de variables lorsque vous travaillez avec des noms similaires dans le bloc-notes. Ils ont configuré les chargeurs de données pour les ensembles de données d'entraînement et de test, l'ensemble de données d'entraînement étant augmenté avec la fonction étendue d'augmentation triviale. L'instructeur suggère ensuite aux téléspectateurs de construire et d'entraîner le modèle 1 à l'aide de la minuscule classe VGG et de la fonction d'entraînement.
  
  
• 24:25:00 Dans cette section du cours complet PyTorch, l'instructeur guide le spectateur à travers le processus de création et de formation d'un nouveau modèle utilisant la même architecture qu'auparavant, mais avec des données de formation augmentées. L'objectif est de comparer les performances de ce modèle au modèle de référence sans augmentation des données. L'instructeur utilise la classe précédemment créée pour le petit modèle VGG et définit une graine manuelle pour la reproductibilité. Ils définissent ensuite la fonction de perte et l'optimiseur, définissent les hyperparamètres et démarrent la minuterie. Enfin, l'instructeur entraîne le modèle en appelant la fonction d'entraînement créée précédemment, en transmettant le modèle et les chargeurs de données, et en évaluant les résultats.
  
  
• 24:30:00 Dans cette section, l'instructeur continue la formation du deuxième modèle avec augmentation des données et montre qu'il n'a pas fonctionné aussi bien que le premier modèle sans augmentation des données en raison du fait que la perte diminuait déjà et là n'était pas trop en forme. L'instructeur introduit ensuite une fonction pour tracer les courbes de perte et l'utilise pour évaluer les performances du second modèle. La courbe de perte montre que le modèle est sous-ajusté et peut-être surajusté, indiqué par la perte de test plus élevée par rapport à la perte d'entraînement. L'instructeur pose ensuite la question de savoir ce qui peut être fait pour remédier à la fois au sous-ajustement et au surajustement dans le modèle, suggérant des options telles que l'obtention de plus de données, la simplification du modèle, l'utilisation de l'apprentissage par transfert ou l'ajout de couches supplémentaires.
  
  
• 24:35:00 Dans cette section, l'instructeur explique l'importance de comparer les résultats du modèle et fournit des outils, tels que PyTorch plus TensorBoard et des poids et biais, pour suivre différentes expériences. Cependant, il souligne que ce cours se concentrera uniquement sur PyTorch pur pour le moment. L'instructeur configure ensuite un graphique pour comparer les résultats du modèle côte à côte, en utilisant des blocs de données pour chacun des résultats du modèle. Il suggère également d'essayer une expérience pour entraîner le modèle zéro pendant une durée plus longue pour voir s'il s'améliore. En fin de compte, la comparaison visuelle de différentes expériences et de leurs métriques est cruciale pour améliorer les modèles.
  
  
• 24:40:00 Dans cette section, l'instructeur utilise des sous-parcelles pour comparer différentes métriques sur deux modèles qu'il a expérimentés. Ils commencent par créer une plage pour le nombre d'époques, puis créent un tracé pour la perte de train en utilisant PLT.subplot() et PLT.plot(). Ils font de même pour la perte de test et la précision des données de formation et de test. L'instructeur souligne que le modèle 1, qui a mis en œuvre l'augmentation des données, semble être surajusté à ce stade, tandis que le modèle 0 est plus performant en termes de perte. L'instructeur suggère que s'ils avaient plus de modèles à comparer, ils pourraient potentiellement en faire une fonction, mais note également que des outils tels que TensorBoard, les pondérations et les biais, et MLflow peuvent aider à donner un sens à ces graphiques lorsque de nombreuses expériences sont menées.
  
  
• 24:45:00 Dans cette section, l'orateur discute de l'importance d'évaluer les modèles en fonction de leurs performances sur l'ensemble de données de test plutôt que sur l'ensemble de données d'apprentissage. Ils suggèrent que même si les métriques sur l'ensemble de données d'entraînement sont bonnes, l'objectif ultime est que le modèle fonctionne bien sur des données invisibles. L'orateur recommande de former les modèles plus longtemps et éventuellement d'ajouter plus d'unités cachées à chaque couche pour obtenir de meilleurs résultats. Ils passent ensuite à la démonstration de la manière de faire des prédictions sur des images personnalisées qui ne figurent pas dans l'ensemble de données d'entraînement ou de test, en utilisant une application de reconnaissance alimentaire comme exemple. Ils expliquent le flux de travail pour télécharger une image personnalisée et faire une prédiction à l'aide d'un modèle PyTorch formé, mais avertissent que le modèle actuel peut ne pas avoir de grandes performances.
  
  
• 24:50:00 Dans cette section, l'instructeur montre comment télécharger une image personnalisée d'une pizza et la préparer pour la prédiction à l'aide du modèle qu'il a formé. L'image est téléchargée à l'aide d'une URL GitHub brute et enregistrée dans le dossier de données. L'instructeur note que l'image personnalisée doit être au même format que les données qui ont été utilisées pour former le modèle, en particulier la forme Tensor avec le type de données torch float 32 et une forme de 64 par 64 par trois. Ils montrent comment charger l'image dans PyTorch à l'aide du package de vision de la torche et de la fonction read_image, qui lit un JPEG ou un PNG dans un tenseur tridimensionnel RVB ou en niveaux de gris.
  
  
• 24:55:00 Dans cette section, l'instructeur montre comment lire une image personnalisée dans PyTorch à l'aide de torch vision.io et la convertir en tenseur. Il montre également comment obtenir des métadonnées sur l'image, telles que sa forme et son type de données. L'instructeur note qu'avant de passer l'image à travers un modèle, il peut être nécessaire de la redimensionner, de la convertir en float32 et de la placer sur le bon appareil. Dans la section suivante, il prévoit de montrer comment faire une prédiction sur l'image personnalisée à l'aide d'un modèle PyTorch.

Partie 26

• 25:00:00 Dans cette section, l'instructeur explique l'importance des types et des formes de données dans l'apprentissage en profondeur et comment corriger les erreurs qui y sont liées. L'instructeur tente de faire une prédiction sur une image mais rencontre des erreurs car les données personnalisées ne sont pas du même type de données que celui sur lequel le modèle a été formé à l'origine. Ils montrent comment corriger l'erreur en recréant le tenseur d'image personnalisé et en le convertissant en flotteur de torche 32. L'instructeur est ensuite confronté à un autre problème avec la forme de l'image personnalisée et montre comment le résoudre en créant un pipeline de transformation pour redimensionner l'image à la même taille que celle sur laquelle le modèle a été formé.
  
  
• 25:05:00 Dans cette section, l'instructeur montre comment utiliser le package de transformations de PyTorch pour transformer une image d'entrée et la préparer pour une utilisation par un modèle d'apprentissage en profondeur. Ils montrent comment appliquer un pipeline de transformation à une image personnalisée, ce qui entraîne la compression et la pixellisation de l'image. L'instructeur note que cela pourrait avoir un impact sur la précision du modèle et recommande d'expérimenter avec des tailles d'image plus grandes pour améliorer les performances. Ils discutent également de l'importance de s'assurer que les dimensions du tenseur correspondent aux exigences du modèle, y compris l'ajout d'une dimension de lot à une image personnalisée avant de la transmettre au modèle pour l'inférence.
  
  
• 25:10:00 Dans cette section de la vidéo, le présentateur montre comment faire des prédictions sur des données d'image personnalisées à l'aide d'un modèle PyTorch. Ils soulignent l'importance de formater correctement les données et de s'assurer qu'elles ont le même type de données, la même forme et le même appareil que celui sur lequel le modèle a été formé pour éviter les erreurs. Le présentateur montre également comment convertir les sorties brutes du modèle, ou logits, en probabilités de prédiction à l'aide de la fonction softmax. Bien que le modèle utilisé dans l'exemple ne fonctionne pas bien, le processus de prédiction sur des données personnalisées est illustré.
  
  
• 25:15:00 Dans cette section de la vidéo, l'instructeur montre comment fonctionnaliser le processus de prédiction d'image personnalisée. Cette fonction prend un modèle PyTorch, un chemin d'image, une liste de noms de classe, une transformation et un périphérique comme entrées. Il charge l'image à l'aide de TorchVision, la formate, obtient les étiquettes de prédiction et trace l'image avec sa prédiction comme titre. L'instructeur met les téléspectateurs au défi d'essayer de créer cette fonction par eux-mêmes, puis passe en revue une implémentation possible dans la vidéo. La fonction n'est pas entièrement implémentée dans cette section et sera poursuivie dans la vidéo suivante.
  
  
• 25:20:00 Dans cette section, nous voyons comment faire une prédiction sur des données personnalisées à l'aide de PyTorch. Tout d'abord, nous devons mettre à l'échelle les données d'image entre 0 et 1 afin que notre modèle puisse les traiter correctement. Ensuite, nous vérifions si des transformations sont nécessaires et passons l'image à travers elles si elles le sont. Ensuite, nous nous assurons que le modèle est sur le bon appareil et le mettons en mode inférence. Nous ajoutons également une dimension supplémentaire à l'image pour refléter la taille de lot de 1 sur laquelle notre modèle prédira. Ensuite, nous faisons une prédiction, convertissons les logits bruts en probabilités de prédiction à l'aide de softmax, puis les convertissons en étiquettes de prédiction à l'aide de argmax. Enfin, nous créons un tracé de l'image avec sa prédiction et sa probabilité de prédiction. Si une liste de noms de classe est fournie, la fonction répliquera les noms de classe pour chaque prédiction dans le tracé.
  
  
• 25:25:00 Dans cette section, l'instructeur explique comment créer une fonction capable de prendre des images et d'afficher leur classe prévue à l'aide d'un modèle PyTorch pré-entraîné. La fonction peut prendre une liste de noms de classe pour l'étiquetage et affiche également la probabilité de prédiction. L'instructeur démontre ensuite l'utilisation de cette fonction sur des images personnalisées et un modèle pré-formé, expliquant l'importance de mettre le résultat sur le CPU pour la compatibilité avec matplotlib. Malgré les mauvaises performances du modèle, l'instructeur insiste sur la puissance de la visualisation des résultats.
  
  
• 25:30:00 Dans cette section, l'instructeur résume les principaux points à retenir de la section précédente, qui couvrait comment prédire sur des données personnalisées avec PyTorch. Les principaux points à retenir sont que les données doivent être prétraitées pour correspondre au format attendu du modèle, y compris le type de données correct, le périphérique correct et la forme correcte. PyTorch possède de nombreuses fonctions intégrées pour gérer différents types de données, et les utilisateurs peuvent écrire leurs propres classes d'ensemble de données personnalisées si nécessaire. De plus, l'instructeur souligne l'importance d'équilibrer le surajustement et le sous-ajustement lors de la formation de modèles et mentionne plusieurs ressources pour un apprentissage et une pratique supplémentaires, y compris des exercices et du matériel parascolaire.
  
  
• 25:35:00 Dans cette section, l'instructeur encourage les apprenants à parcourir d'abord le modèle d'exercices d'ensembles de données personnalisés PyTorch et à essayer de remplir tout le code par eux-mêmes. En cas de blocage, ils peuvent se référer aux exemples de solutions fournis par l'instructeur. Les solutions proposées ne sont qu'une façon de faire, et les utilisateurs sont libres de les référencer et de comparer avec leur mise en œuvre. Les solutions et les erreurs rencontrées au cours du processus peuvent également être consultées dans les procédures pas à pas en direct disponibles sur YouTube. L'instructeur rappelle aux utilisateurs qu'ils ont couvert de nombreux exercices et peuvent consulter les exercices et solutions supplémentaires dans le dépôt d'apprentissage en profondeur PyTorch. L'instructeur conclut en mentionnant qu'il y a cinq autres chapitres disponibles sur learnpytorch.io, que les apprenants peuvent explorer pour en savoir plus sur l'apprentissage par transfert, le suivi des expériences de modèle pytorch, la réplication de papier pytorch et le déploiement du modèle pytorch.

[MetaQuotes]

Cours d'apprentissage automatique sans boîte noire - Apprenez sans bibliothèques

Cours d'apprentissage automatique sans boîte noire - Apprenez sans bibliothèques

00:00:00 - 01:00:00 Dans cette vidéo YouTube, l'instructeur présente un cours d'apprentissage automatique sans boîte noire qui enseigne comment coder en apprentissage automatique sans s'appuyer sur des bibliothèques. Le cours couvre des sujets liés à la création d'une application Web qui reconnaît les dessins, y compris la collecte de données, l'extraction et la visualisation de caractéristiques, et la mise en œuvre de classificateurs tels que le voisin le plus proche et le voisin le plus proche K. L'instructeur souligne l'importance de comprendre les données dans l'apprentissage automatique et suggère des ressources pour ceux qui ont besoin de parfaire leur expérience en mathématiques et en programmation au secondaire. La vidéo montre le processus de création d'une page Web qui agit comme un créateur de données à l'aide de JavaScript sans aucune bibliothèque externe. Le présentateur comprend également des instructions sur la façon de créer un bouton d'annulation et un champ de saisie de nom, de stocker des dessins dans un objet de données et d'enregistrer les chemins sur l'ordinateur de l'utilisateur. Enfin, la vidéo montre comment créer un générateur de jeu de données dans node.js et générer des données associées à chaque échantillon à l'aide de JavaScript.

01:00:00 - 02:00:00 Dans cette vidéo YouTube, l'instructeur enseigne aux spectateurs comment créer un ensemble de données d'apprentissage automatique et extraire des fonctionnalités sans utiliser de bibliothèques. Ils montrent comment stocker l'ensemble de données dans un dossier qui peut communiquer entre les scripts de nœud et les applications Web et créer une application de visualisation de données. L'instructeur montre également comment visualiser les données collectées à l'aide des graphiques Google et comment identifier et mettre en évidence les éléments sélectionnés dans le graphique et la liste. Dans l'ensemble, la vidéo fournit un guide complet permettant aux apprenants de créer des ensembles de données d'apprentissage automatique et d'extraire des fonctionnalités en utilisant uniquement JavaScript. 02:00:00 - 03:00:00 La vidéo "No Black Box Machine Learning Course - Learn Without Libraries" montre comment classer les dessins en fonction de leurs caractéristiques sans utiliser de bibliothèques d'apprentissage automatique. Le créateur de la vidéo insiste sur l'importance d'avoir un système rapide et réactif pour inspecter les données afin d'éviter les erreurs manuelles. Ils montrent comment ajouter des fonctionnalités au graphique, comment masquer l'arrière-plan et comment afficher les étiquettes prédites à l'écran à l'aide de conteneurs dynamiques avec HTML et CSS. La vidéo couvre également les techniques de mise à l'échelle des données telles que la normalisation et la standardisation. Enfin, la vidéo montre comment implémenter le classificateur K plus proches voisins et compter le nombre de chaque étiquette dans les K plus proches voisins.

03:00:00 - 03:50:00 La vidéo YouTube "No Black Box Machine Learning Course - Learn Without Libraries" couvre divers sujets liés à la classification du voisin le plus proche K sans utiliser de bibliothèques d'apprentissage automatique telles que JavaScript et Python. La vidéo explique comment diviser les ensembles de données en ensembles d'apprentissage et de test, gérer les échantillons d'apprentissage et de test séparément et normaliser les données. L'instructeur aborde également l'importance des limites de décision pour comprendre le fonctionnement d'un classificateur, montre comment implémenter un classificateur K-plus proche voisin (KNN) en JavaScript et génère un tracé basé sur des pixels sans utiliser de bibliothèques d'apprentissage automatique. Enfin, la vidéo se termine par un appel aux spectateurs pour qu'ils explorent les fonctionnalités supplémentaires de Python et réfléchissent à ce qu'ils ont appris jusqu'à présent.

Partie 1

• 00:00:00 Dans cette section, l'orateur présente le cours d'apprentissage automatique sans boîte noire qui se concentre sur le codage sans s'appuyer sur des bibliothèques. Le cours couvre divers sujets pour la création d'une application Web qui reconnaît les dessins, y compris la collecte de données, l'extraction et la visualisation de caractéristiques, et la mise en œuvre de classificateurs tels que le voisin le plus proche et K le plus proche voisin. L'orateur souligne l'importance de comprendre les données dans l'apprentissage automatique et offre une courte pause aux élèves pour qu'ils se concentrent sur leurs devoirs tout en suggérant des ressources pour approfondir leur expérience en mathématiques et en programmation au secondaire. Le cours passe ensuite à la phase deux où des méthodes plus avancées telles que les réseaux de neurones seront couvertes. Un exemple de création d'une application de dessin pour la collecte de données est également illustré avec les fonctionnalités d'annulation et d'enregistrement.
  
  
• 00:05:00 Dans cette section de la vidéo, l'instructeur décrit le processus de création d'une page Web qui sera utilisée comme créateur de données pour un ensemble de données. Ils commencent par créer un nouveau dossier nommé web et à l'intérieur de ce dossier, ils créent le premier fichier, une page Web appelée Creator.html. La page comprend du code HTML de base, une section de titre et une feuille de style externe appelée Styles.css. Ils ajoutent également des styles de base pour la page, y compris la famille de polices et la couleur d'arrière-plan. L'instructeur passe ensuite à l'implémentation du carnet de croquis à l'aide d'un fichier JavaScript externe appelé sketchpad.js et définit le constructeur de classe du carnet de croquis pour contenir l'élément canvas.
  
  
• 00:10:00 Dans cette section, l'instructeur configure un canevas à l'aide de JavaScript et ajoute un écouteur d'événement « onmousedown » pour détecter les actions de la souris. Ils obtiennent les coordonnées de la souris en obtenant le rectangle de la zone de délimitation du canevas et en soustrayant respectivement les côtés gauche et supérieur. Après avoir arrondi les coordonnées à des nombres entiers, l'instructeur crée un tableau de chemin qui contient les coordonnées de la souris lorsque le canevas est cliqué. Ils définissent également "drawing" sur false et "path" sur vide. Un autre écouteur d'événement est ajouté pour "onmousemove" pour continuer à ajouter plus de points au tableau de chemin lorsque la souris est déplacée.
  
  
• 00:15:00 Dans cette section, l'orateur explique comment implémenter des événements de souris pour dessiner sur un canevas à l'aide de JavaScript, sans utiliser de bibliothèques. En utilisant des écouteurs d'événements pour "onMouseMove" et "onMouseUp", le code suit les mouvements de la souris et ajoute l'emplacement à un chemin si l'utilisateur dessine. De plus, une nouvelle fonction "obtenir la souris" est créée pour ajouter l'emplacement au canevas. Enfin, l'orateur montre comment créer un objet utilitaire "dessiner" pour dégager et dessiner le chemin sur le canevas.
  
  
• 00:20:00 Dans cette section, l'instructeur vidéo continue de créer un programme de dessin sans aucune bibliothèque externe en résolvant certains problèmes avec les lignes dessinées, telles que l'apparence des coins et les fins de lignes droites. Ils procèdent ensuite à la création d'une fonction pour dessiner plusieurs chemins et l'intègrent dans le programme. L'instructeur rencontre des problèmes lors de l'exécution du programme sur un appareil mobile en raison de la fenêtre d'affichage, et il les résout en utilisant une balise méta dans la section d'en-tête du fichier HTML.
  
  
• 00:25:00 Dans cette section, le didacticiel se concentre sur l'adaptation du canevas à des écrans plus petits comme ceux des appareils mobiles en ajoutant des commandes spécifiques à la balise méta de la fenêtre dans le code HTML. Cependant, les écouteurs d'événements pour le toucher sont différents de ceux de la souris, ce qui nécessite une modification du carnet de croquis avec des écouteurs d'événements pour le toucher. Pour améliorer davantage le canevas, un bouton d'annulation est créé, mais uniquement lorsqu'il existe des chemins à annuler. Le bouton est désactivé lorsque le canevas est vide.
  
  
• 00:30:00 Dans cette section, la vidéo explique comment améliorer l'apparence du bouton en changeant le style dans le fichier CSS. Le narrateur ajoute un effet de survol et définit les styles pour l'état désactivé. Ensuite, nous apprenons à créer un champ de saisie permettant aux utilisateurs d'entrer leur nom et un bouton pour passer au dessin suivant. La vidéo explique également comment collecter des données à partir de ces champs et les stocker dans un objet à trois champs : étudiant, session et dessins. Enfin, le narrateur commence à mettre en œuvre la fonction de démarrage qui sera utilisée pour lancer le processus de dessin.
  
  
• 00:35:00 Dans cette section de la vidéo, le présentateur montre comment implémenter une application de dessin à l'aide de JavaScript sans utiliser de bibliothèques. Ils commencent par définir un index pour les étiquettes des choses qu'ils veulent dessiner, comme une voiture, un poisson, une maison, etc. Ils ajoutent également un champ pour les instructions et modifient le bouton de démarrage pour passer à "suivant" après le premier dessin . Ils implémentent ensuite une fonction pour le bouton "suivant", qui augmente l'index, obtient l'étiquette suivante et met à jour les instructions. Ils stockent également les dessins dans un objet de données pour l'étiquette spécifique et ajoutent une méthode publique pour réinitialiser le carnet de croquis. Le présentateur teste l'application et montre que l'objet de données collecte les dessins.
  
  
• 00:40:00 Dans cette section, l'instructeur explique comment enregistrer les chemins tracés par les utilisateurs localement sur leur ordinateur. Ils créent un élément "a" avec l'attribut href défini sur "données en texte brut" et codent le composant URI à l'aide de la version sous forme de chaîne des données. Les données collectées sont enregistrées sous forme de chaîne JSON dans un fichier avec un nom unique généré à partir d'un horodatage. Enfin, l'action de téléchargement est déclenchée pour télécharger le fichier. L'instructeur ajoute également des instructions sur ce qu'il faut faire avec le fichier téléchargé et déclare que cela aura plus de sens après la prochaine session.
  
  
• 00:45:00 Dans cette section, l'instructeur montre comment résoudre un problème potentiel avec le carnet de croquis en ajoutant un écouteur d'événement sur le document au lieu du canevas. Il demande également aux téléspectateurs d'aider à tester le système sur différents appareils et de signaler tout problème ou de proposer des solutions. L'instructeur explique ensuite comment traiter les données collectées sous une forme plus gérable à l'aide de node.js et montre comment accéder au répertoire du projet et créer un nouveau dossier pour stocker les données. Enfin, il crée un dossier "brut" où il colle toutes les données collectées à partir de près de 500 soumissions d'étudiants, chacune contenant huit dessins différents, et explique comment il traitera ces fichiers pour créer un ensemble de données où chaque échantillon est un dessin.
  
  
• 00:50:00 +Alt+M et le fichier Json sera bien formaté. Dans cette section, l'instructeur explique comment créer un générateur d'ensemble de données dans nodejs pour traiter les échantillons et les visualiser à l'aide de deux dossiers distincts : l'un pour les représentations Json et l'autre pour les images. Le script lira les noms de fichiers à partir du répertoire de données brutes, en extraira le contenu et stockera des informations sur chaque échantillon, telles que leur ID, leur étiquette, le nom de l'étudiant et l'ID de l'étudiant, la session et le dessin. Enfin, la section montre brièvement comment exécuter et tester le code, ce qui entraîne la création d'un exemple de fichier Json dans le répertoire désigné.
  
  
• 00:55:00 Dans cette section, le conférencier explique comment générer des données associées à chaque échantillon à l'aide de JavaScript. Cela implique d'écrire des fichiers dans un répertoire Json et de chaîner le dessin de chaque étiquette spécifique. L'orateur montre ensuite comment générer une représentation d'image de chaque dessin à l'aide d'un canevas et de la fonction « tracer des chemins » à partir d'un répertoire commun. Pour ce faire, le locuteur exporte l'objet 'draw' du fichier 'draw.js' à utiliser dans le générateur d'ensemble de données, et installe la bibliothèque de canevas à l'aide du gestionnaire de packages de nœuds.

Partie 2

• 01:00:00 Dans cette section, l'instructeur montre comment créer un canevas et l'utiliser pour dessiner des chemins sur le canevas, puis le stocker en tant qu'image. Ils nettoient également la toile avant de tracer de nouveaux chemins. Après avoir généré les fichiers image, l'instructeur corrige un problème dans l'application de dessin causé par le fait que le module n'est pas défini dans draw JS. Ils utilisent une structure qui sera utilisée tout au long du cours, séparant les constantes d'un autre fichier et l'exigeant. L'instructeur ajoute un indicateur de progression dans un nouveau fichier appelé utils en créant l'objet utils et en ajoutant la fonction appelée progression de l'impression. Ils utilisent le processus STD out pour obtenir la sortie standard, calculent le pourcentage à l'aide de la fonction de formatage d'un pourcentage et l'écrivent sur la sortie standard pour afficher l'indicateur de progression.
  
  
• 01:05:00 Dans cette section, le créateur de la vidéo explique comment stocker l'ensemble de données généré de manière à ce que le navigateur puisse le lire. Il crée un dossier appelé "JS_objects" qui contiendra des fichiers pouvant communiquer entre les scripts de nœud et les applications Web. Un fichier JavaScript "samples" est créé qui initialisera un objet JavaScript dans le dossier JS_objects. Le créateur de la vidéo mentionne également qu'il créera une application de visualisation pour l'ensemble de données et créera un fichier HTML appelé "viewer.html" avec un code HTML de base. La section d'en-tête du fichier comprend une balise META pour la prise en charge des caractères UTF et un titre pour la page. La section body comprend une balise H1 avec le titre "Data Viewer" et une div avec un ID de "container" pour contenir l'ensemble de données. Le fichier JavaScript "samples" est inclus dans le fichier HTML.
  
  
• 01:10:00 Dans cette section, l'instructeur travaille à la création d'un tableau avec des échantillons regroupés par identifiant d'étudiant. Pour ce faire, ils implémentent une fonction "group by" dans le fichier utils.js, qui regroupe un tableau par une clé donnée. Ensuite, ils enregistrent les groupes sur la console pour vérifier si cela fonctionne. Ensuite, ils créent une fonction appelée "create row" dans un fichier display.js séparé, qui prend un conteneur, un nom d'élève et des échantillons comme paramètres et crée une ligne avec le nom à gauche et les échantillons à droite. Ils créent une boucle pour parcourir chaque identifiant d'étudiant, appellent la fonction "créer une ligne" et transmettent les paramètres nécessaires pour afficher les données sous forme de tableau.
  
  
• 01:15:00 Dans cette section, l'instructeur montre comment créer dynamiquement une ligne d'images avec des étiquettes et les aligner correctement avec CSS. Ils commencent par parcourir un ensemble d'échantillons d'image, en créant un élément d'image et en attribuant les attributs de source et de style. Les images sont ensuite ajoutées à une ligne tandis qu'un div d'étiquette est créé et ajouté à un conteneur d'échantillons. Le conteneur d'échantillons est ensuite enveloppé d'un div, qui reçoit un ID et une classe. L'instructeur affine ensuite le CSS pour centrer les étiquettes et les images et ajouter des points de suspension aux noms plus longs. Enfin, ils ajoutent un arrière-plan blanc aux exemples de dessins en créant un div et en l'ajoutant après l'étiquette.
  
  
• 01:20:00 Dans cette section, le créateur de la vidéo modifie l'affichage des échantillons d'images collectés dans l'application Web. La modification implique la création d'un exemple de conteneur avec un arrière-plan blanc, un texte aligné au centre, un coin arrondi et une marge d'un pixel. La vignette est définie sur 100 et l'étiquette de ligne a une propriété qui occupe 20 % de l'espace, les huit échantillons restants occupant chacun 10 % de l'espace. La structure d'affichage qui en résulte est soignée, mais certaines images ne correspondent pas parfaitement, ce qui n'est pas grave car il est destiné aux applications de bureau. De plus, le créateur ajoute un filtre de flou à certains dessins réalisés par des utilisateurs signalés à l'aide de leurs identifiants. Certains des dessins collectés sont impressionnants, tandis que d'autres contiennent des interprétations erronées qui rendent les données plus difficiles.
  
  
• 01:25:00 Dans cette section, le YouTuber examine certains dessins de l'ensemble de données et commente leur qualité, notant que certains sont très détaillés et ont dû prendre beaucoup de temps à créer. Ils mentionnent également que leur ensemble de données est différent de l'ensemble de données Quick Draw, car ils ont un bouton d'annulation et aucune limite de temps, ce qui signifie que leurs dessins devraient être de meilleure qualité en moyenne. Enfin, ils font un commentaire désinvolte sur l'organisation et le style de la page.
  
  
• 01:30:00 Dans cette section, l'instructeur explique comment extraire des fonctionnalités à partir d'échantillons sans utiliser de bibliothèques. Les fonctions d'extraction du nombre de chemins et du nombre de points sont implémentées dans un fichier nommé features.js et ajoutées à un objet appelé features. Ensuite, dans le fichier feature extractor.js, les échantillons sont lus et les fonctionnalités sont extraites en parcourant tous les échantillons et en obtenant le nombre de chemins et le nombre de points pour chacun d'eux. Ces valeurs de caractéristiques sont ensuite combinées dans un tableau et écrites dans un nouveau fichier. Enfin, les noms de fonctionnalités et les exemples sont combinés dans un autre fichier nommé features.json. Lors de l'exécution du script d'extraction de fonctionnalités, le journal indique "extraction de fonctionnalités" et à la fin, "terminé". Les entités résultantes dans le répertoire de jeux de données peuvent ensuite être examinées.
  
  
• 01:35:00 Dans cette section, le créateur de la vidéo explique comment utiliser un objet JavaScript pour contenir des données supplémentaires qui ne sont pas déjà contenues dans un fichier de fonctionnalité. L'objet peut être enregistré dans un fichier JavaScript séparé et utilisé pour extraire toutes les données nécessaires à une application Web. Le créateur montre également comment visualiser les données à l'aide de graphiques Google, où des options telles que la largeur, la hauteur, les titres d'axe et le package de graphique de base peuvent être définies dans un objet. Une table de données est créée avec deux colonnes pour les valeurs de caractéristiques et leurs noms correspondants.
  
  
• 01:40:00 Dans cette section, la vidéo montre comment créer un nuage de points avec Google Visualization, permettant aux utilisateurs d'étudier de plus près différentes fonctionnalités des données en utilisant les actions de l'explorateur pour effectuer un zoom avant et arrière. La vidéo montre également comment utiliser différentes couleurs pour chaque classe et implémenter la transparence pour une meilleure visualisation de la densité dans différentes parties à l'aide d'une version différente de la bibliothèque de graphiques Google appelée tableaux de matériaux.
  
  
• 01:45:00 Dans cette section, le créateur de la vidéo montre comment créer un nuage de points à l'aide des graphiques Google, puis créer un nouveau graphique avec son propre code JavaScript. Le créateur simplifie les options du graphique et modifie le jeu de couleurs pour utiliser des emojis à la place, ce qui permet une reconnaissance plus facile des points de données sans avoir besoin d'étiquettes ou de légendes. La transparence du graphique est également ajustée pour permettre une meilleure visibilité des données densément tracées.
  
  
• 01:50:00 Dans cette section, l'instructeur ajoute une fonction de rappel au tableau pour identifier tout élément sélectionné dans le tableau ci-dessous. La nouvelle fonction s'appelle "handle click", qui ajoute une classe "emphase" à l'élément sélectionné et utilise "scroll into view" et "block center" pour s'assurer qu'il défile automatiquement au centre de la page. L'instructeur modifie ensuite la mise en page de sorte que le graphique se trouve sur le côté droit de la page, avec l'autre contenu sur le côté gauche. Le graphique est également fixé en position afin qu'il ne bouge pas lorsque l'utilisateur fait défiler.
  
  
• 01:55:00 Dans cette section de la vidéo, le présentateur montre comment sélectionner des éléments du graphique et de la liste, et comment les désélectionner également. Ils spécifient un paramètre pour définir si le défilement doit se produire et ajoutent du code pour gérer l'erreur qui se produit lorsque vous essayez de ne rien sélectionner. De plus, le présentateur ajoute la possibilité de mettre en évidence un élément via une classe, en supprimant la classe si elle est déjà mise en évidence. Enfin, ils testent la fonctionnalité du graphique et ajustent la taille du graphique.

Partie 3

• 02:00:00 Dans cette section, l'orateur démontre l'utilisation d'un carnet de croquis comme entrée pour dessiner quelque chose à classer. Ils lui préparent un conteneur, y ajoutent des styles et fixent sa position à une certaine distance de la droite et du haut de l'écran. Ils lui donnent également une marge pour une visibilité claire et un bouton d'annulation au centre. Ils ajoutent ensuite un panneau de contrôle et un bouton pour basculer l'entrée visible ou non qui fonctionne avec succès lors des tests. Le conférencier souligne l'importance d'avoir un système rapide et réactif lors de l'inspection des données pour éviter les erreurs manuelles qui peuvent conduire à des erreurs.
  
  
• 02:05:00 Dans cette section, l'instructeur vidéo montre comment ajouter un panneau de contrôle au graphique et comment masquer l'arrière-plan lorsque l'entrée est présente. Ils présentent une solution pour masquer l'arrière-plan dans le code HTML de la visionneuse en rendant transparent le contour du canevas du carnet de croquis. Ils montrent également comment afficher les entités sur le graphique immédiatement lorsque quelque chose est dessiné sur le carnet de croquis en ajoutant une fonction de rappel de mise à jour qui extrait les entités de la même manière que l'extracteur d'entités. L'instructeur rencontre un problème avec des objets en conflit appelés fonctions, mais le résout en les renommant partout en fonctions de fonction.
  
  
• 02:10:00 Dans cette section, l'orateur montre un point dynamique qui peut être ajouté au graphique, qui se déplace au fur et à mesure du dessin. Ceci est réalisé en définissant un attribut sur une valeur et en le redessinant. Le point dynamique est ajouté à la classe de graphique et se dessine avant l'affichage des axes. En faisant glisser, le point se déplace vers différentes zones, et lorsqu'il est dessiné avec un point blanc transparent sur un fond noir, il est beaucoup plus visible. La valeur doit être grande, car le graphique peut être agrandi et le point reste visible sans dépasser les bords.
  
  
• 02:15:00 Dans cette section, l'instructeur montre comment déclencher une méthode de mise à jour dans sketchpad.js, qui fonctionne en masquant l'entrée dynamique et en affichant les données lorsque l'entrée bascule est enfoncée. Avec la méthode de mise à jour du déclencheur, l'instructeur applique les fonctions d'obtention d'entités de largeur et de hauteur dans Fonctions d'entités communes pour calculer la largeur et la hauteur du dessin, qui sont utilisées pour extraire de nouvelles entités dans l'extracteur d'entités de nœud. L'instructeur suggère qu'ils doivent restructurer le HTML afin que la même ressource soit utilisée pour extraire et afficher les données.
  
  
• 02:20:00 Dans cette section, le créateur de la vidéo montre comment supprimer le code inutile et le remplacer par de nouvelles fonctionnalités, ce qui se traduit par un processus de création de points plus généralisé et multidimensionnel. Après avoir régénéré les entités et mis à jour les noms des entités, quelques points d'échantillonnage problématiques sont observés, ce qui est un problème courant lors de l'utilisation de données. Le créateur note que des valeurs aberrantes et des incohérences sont à prévoir dans les données et invite les téléspectateurs à aider à identifier la cause du problème.
  
  
• 02:25:00 Dans cette section, l'instructeur explique comment classer un dessin en fonction de ses caractéristiques sans utiliser de bibliothèques d'apprentissage automatique. Ils extraient les entités de l'entrée et examinent les points proches pour classer l'entrée. Pour trouver le point le plus proche, l'instructeur copie la fonction obtenir le plus proche du graphique math.js et la colle dans son code. Ils appellent ensuite la fonction pour identifier l'étiquette du dessin et consigner le résultat.
  
  
• 02:30:00 Dans cette section, le créateur de la vidéo ajoute la fonctionnalité permettant d'afficher l'étiquette prédite à l'écran à l'aide de conteneurs dynamiques avec HTML et CSS. L'étiquette prédite est affichée dans un conteneur blanc avec un texte concaténé indiquant si l'objet est une voiture ou non. Le créateur expérimente le dessin de différents objets tels que des horloges et des crayons pour tester les capacités prédictives du programme. Le créateur de la vidéo met ensuite à jour le graphique à l'aide de points dynamiques avec des étiquettes et des images et trace des lignes reliant les échantillons les plus proches.
  
  
• 02:35:00 Dans cette section, l'orateur discute de l'importance de ne pas écraser ou étirer les données dans les graphiques lorsque vous travaillez sur des projets d'apprentissage automatique. Ils démontrent comment le rapport d'aspect d'un graphique peut affecter la façon dont les données sont interprétées, entraînant confusion et erreurs. Pour résoudre ce problème, l'orateur calcule un delta pour les valeurs maximales de x et y et ajuste le graphique en conséquence. Bien que cela crée un espace vide, cela permet une visualisation correcte des données et des résultats d'apprentissage automatique précis.
  
  
• 02:40:00 Dans cette section de la transcription, le créateur de la vidéo souligne l'importance de la mise à l'échelle des données dans l'apprentissage automatique pour garantir que toutes les fonctionnalités ont la même signification dans la classification. Le créateur montre comment les données peuvent être écrasées et étirées lors de l'extraction des caractéristiques, ce qui entraîne un traitement inégal de certaines caractéristiques. Pour uniformiser les règles du jeu, le créateur introduit la normalisation, une technique courante pour remapper les valeurs des caractéristiques dans une plage comprise entre 0 et 1. La vidéo décrit la mise en œuvre d'une nouvelle fonction appelée "normaliser les points" dans la section "utils" pour y parvenir. remappage.
  
  
• 02:45:00 Dans cette section, le didacticiel vidéo montre comment normaliser les données en changeant les valeurs entre 0 et 1. La fonction est initialisée pour être suffisamment générale, et les valeurs minimales et maximales pour chaque caractéristique sont calculées. Les points sont modifiés pour être compris entre 0 et 1 en soustrayant la valeur minimale et en divisant par la différence. La fonction lerp inverse est utilisée pour convertir la valeur donnée en pourcentage afin de normaliser les caractéristiques extraites du dessin. Les valeurs min-max sont renvoyées par la fonction et écrites dans l'un des fichiers objet JavaScript pour communiquer avec l'interface. Enfin, les données sont générées et les valeurs min-max sont incluses dans les fichiers d'objet JavaScript.
  
  
• 02:50:00 Dans cette section, le présentateur explique comment normaliser les points avant d'essayer de les classer à l'aide de la fonction Utils normalize points. Pour ce faire, les données d'entité brutes sont chargées et transmises en entrée à la fonction. De plus, une valeur min-max peut être transmise pour prendre en charge la normalisation sans avoir à les calculer. Il est également démontré comment la normalisation est sensible aux points aberrants et comment les traiter, par exemple en les détectant et en les supprimant automatiquement ou en utilisant la normalisation comme mise à l'échelle différente des données.
  
  
• 02:55:00 Dans cette section, l'instructeur aborde la technique de standardisation, qui consiste à calculer la moyenne et l'écart type de chaque caractéristique et à les remapper en soustrayant la moyenne et en divisant par l'écart type. Cette technique est moins sensible aux valeurs aberrantes et peut mieux fonctionner dans certains cas. L'instructeur présente également le classificateur des K voisins les plus proches, où la classe est déterminée en fonction de la majorité des K voisins les plus proches. Le code est mis à jour pour permettre la recherche de K voisins les plus proches, et l'instructeur montre comment compter le nombre de chaque étiquette dans les K voisins les plus proches.

Partie 4

• 03:00:00 Dans cette section, l'instructeur explique le processus de détermination de la majorité d'un ensemble d'échantillons en fonction de leurs étiquettes. Cela implique de compter les occurrences de chaque étiquette dans les échantillons et de définir l'étiquette majoritaire comme celle avec le nombre le plus élevé. L'instructeur met à jour le code pour renvoyer tous les échantillons les plus proches et tracer des lignes vers eux dans le tableau, plutôt que simplement le plus proche. Ils démontrent ensuite le fonctionnement du classificateur sur divers ensembles de données et encouragent les téléspectateurs à partager leurs propres implémentations d'autres variantes des classificateurs voisins les plus proches. Enfin, l'instructeur insiste sur la nécessité de diviser les données en ensembles d'entraînement et de test pour évaluer objectivement les performances du classifieur.
  
  
• 03:05:00 Dans cette section, la vidéo montre comment diviser un ensemble de données en ensembles d'apprentissage et de test, les écrire dans des fichiers et définir des constantes pour ces divisions dans le code à l'aide de JavaScript. L'ensemble d'apprentissage est défini sur 50 % du nombre d'échantillons, et la vidéo met en garde contre l'erreur de test sur les données d'apprentissage. Afin de tester, le code parcourt tous les échantillons de test et stocke la valeur de l'étiquette dans un attribut appelé Vérité tout en faisant semblant de ne pas connaître l'étiquette à des fins de test.
  
  
• 03:10:00 Dans cette section, la vidéo explique comment gérer séparément les échantillons d'entraînement et de test et comment normaliser correctement les données. L'orateur explique qu'il est important de normaliser les données avec uniquement l'ensemble d'apprentissage puisque nous n'avons aucune idée de ce que sera l'ensemble de test. Ils expliquent également comment classer correctement en utilisant uniquement les informations des données de formation et montrent comment gérer les points de données inconnus à l'aide de la fonction de classification.
  
  
• 03:15:00 Dans cette section, le créateur de la vidéo ajoute un attribut correct à une étiquette de test et compare cette étiquette avec la valeur de vérité précédente pour déterminer l'exactitude. Un sous-titre est également ajouté pour clarifier le début de l'ensemble de test. Le créateur ajoute ensuite un champ de statistiques pour calculer et afficher la précision du classificateur K voisin le plus proche, qui est défini sur 10 voisins les plus proches, ce qui donne une précision de 39,62 %. En changeant le paramètre en un voisin le plus proche, la précision est en fait bien pire, ce qui montre que considérer plusieurs voisins était une bonne idée.
  
  
• 03:20:00 Dans cette section, l'instructeur refactorise le code et discute de l'importance des limites de décision pour comprendre le fonctionnement d'un classifieur. Ils créent un nouveau fichier appelé "run evaluation" et chargent les constantes et les utilitaires nécessaires. L'instructeur explique comment créer un classificateur et comment obtenir des échantillons d'entraînement et de test pour calculer la précision d'un classificateur. Ils introduisent également des limites de décision, qui fournissent des informations précieuses sur la façon dont un classificateur détermine la classification d'un point de données. L'instructeur déclare que les limites de décision sont plus utiles que le simple comptage des différentes caractéristiques d'un point de données.
  
  
• 03:25:00 Dans cette section, l'orateur explique comment implémenter un classificateur K-plus proche voisin (KNN) en JavaScript. Le code commence par prédire les étiquettes pour chaque point d'échantillon de test à l'aide de la méthode KNN et calculer la précision en vérifiant le nombre correct de prédictions. Le fichier KN.js est créé pour définir la classe qui prend des échantillons d'apprentissage et K pour stocker et prédire un point donné. Le code de classe pour la classification est copié du visualiseur HTML vers KN.js et modifié pour s'adapter à la nouvelle classe. Le script d'évaluation d'exécution est mis à jour pour utiliser le classificateur KNN au lieu de l'ancienne méthode de classification. En refactorisant de cette manière, le code devient plus gérable et les erreurs stupides peuvent être évitées.
  
  
• 03:30:00 Dans cette section, l'instructeur montre comment générer un tracé basé sur des pixels sans utiliser de bibliothèques d'apprentissage automatique en normalisant les valeurs des pixels et en les codant par couleur en fonction des valeurs prédites. Le tracé est ensuite enregistré en tant qu'image PNG et défini comme arrière-plan d'un graphique. L'instructeur montre comment implémenter cette nouvelle fonctionnalité dans le fichier chart.js en prenant la coordonnée en haut à gauche en fonction des données, en obtenant la valeur de pixel des limites de données aux limites de pixel et en la divisant en fonction de la façon dont la mise à l'échelle a été effectuée à l'aide de la transformation.
  
  
• 03:35:00 Dans cette section de la vidéo, le présentateur discute de l'image générée dans la section précédente et commente sa faible résolution et son effet de lissage. Ils introduisent alors une image de plus haute résolution, qui ne nécessite plus l'affichage de données. Ils expliquent que les régions colorées nous renseignent sur les différentes étiquettes et sur l'intérêt d'observer l'apparition des différentes régions. Ils mettent ensuite les téléspectateurs au défi de calculer la précision de toutes les valeurs possibles de K et de créer un graphique linéaire pour déterminer la meilleure valeur et également de générer un tracé de limite de décision haute résolution pour la meilleure valeur.
  
  
• 03:40:00 Dans cette section, le YouTuber explique comment préparer des données pour Python en écrivant une fonction pour convertir des exemples de données au format CSV à l'aide de JavaScript. Ils créent une fonction appelée toCSV qui convertit des exemples de données avec des en-têtes et des noms de fonctionnalités au format CSV, couramment utilisé en Python. Ils génèrent le CSV avec des noms de fonctionnalités et des étiquettes pour les données d'entraînement et de test, puis passent à l'implémentation Python de K plus proche voisin à l'aide de bibliothèques. Ils ouvrent le fichier CSV de formation, lisent les lignes et analysent les données sous la forme d'un tableau de lignes représentées sous forme de chaîne, avec le caractère de nouvelle ligne.
  
  
• 03:45:00 Dans cette section, l'instructeur explique comment préparer les données pour la classification des K plus proches voisins sans utiliser de bibliothèques. Les données sont lues à partir d'un fichier CSV et stockées dans deux tableaux vides en Python - X pour les valeurs de caractéristiques et Y pour les étiquettes. L'instructeur parcourt une boucle pour remplir les tableaux, convertir les valeurs des caractéristiques en nombres flottants et remapper les étiquettes en nombres. Le remappage est réalisé à l'aide d'un dictionnaire Python. Les données sont ensuite ajustées à un objet classificateur KNN avec des paramètres définis pour émuler l'application Web, y compris 250 voisins, un algorithme de force brute et des poids uniformes. L'instructeur termine en soulignant l'importance de l'indentation en Python et en extrayant les données de fonction de lecture d'un fichier en tant que fonction.
  
  
• 03:50:00 Dans cette section, l'orateur montre comment transmettre des données au modèle et vérifier leur exactitude à l'aide de la fonction de score. Ils encouragent également les spectateurs à explorer des fonctionnalités supplémentaires de Python, telles que l'installation de matplotlib pour visualiser les valeurs des fonctionnalités et les limites de décision. La vidéo se termine par un appel aux téléspectateurs pour qu'ils réfléchissent à ce qu'ils ont appris jusqu'à présent et se préparent pour la prochaine phase du cours.

[MetaQuotes]

MIT 6.034 "Intelligence Artificielle". Automne 2010. Cours 1. Introduction et portée

1. Introduction et portée

Cette vidéo est une introduction au cours MIT 6.034 "Intelligence Artificielle". Le professeur explique la définition de l'intelligence artificielle et son importance, puis aborde les modèles de pensée et de représentations importants pour comprendre le sujet. Enfin, la vidéo donne un bref aperçu du cours, y compris comment la note est calculée et ce que le quiz et la finale impliqueront.

• 00:00:00 Dans cette vidéo, un professeur discute de la définition de l'intelligence artificielle et de son importance. Il poursuit en disant que quiconque suit le cours deviendra plus intelligent. Le professeur discute également des modèles de pensée et de leur importance pour bien comprendre le sujet. Enfin, il parle de l'importance des représentations pour faire de bons modèles.
  
  
• 00:05:00 Dans cette vidéo, le professeur explique comment fonctionnent les gyroscopes et comment représenter un problème sous forme de graphe. Il poursuit ensuite en expliquant comment résoudre le problème de l'oie et du grain de l'agriculteur Fox, qui est un exemple que beaucoup de gens connaissent peut-être depuis l'enfance.
  
  
• 00:10:00 La vidéo présente le concept d'intelligence artificielle et ses différentes composantes, y compris les tests générés par l'intelligence artificielle. La vidéo aborde ensuite le principe de Rumpelstiltskin, qui stipule qu'une fois que vous pouvez nommer quelque chose, vous pouvez en prendre le pouvoir.
  
  
• 00:15:00 Cette vidéo présente le concept d'idées simples, qui sont puissantes et peuvent être simples ou complexes. La vidéo aborde ensuite la définition et des exemples d'idées simples. Le point principal de la vidéo est que des idées simples sont importantes pour créer des programmes plus intelligents, et que les scientifiques et les ingénieurs ont des motivations différentes pour les étudier.
  
  
• 00:20:00 Cette vidéo traite de l'histoire de l'intelligence artificielle, en commençant par le travail effectué par Ada Lovelace il y a plus d'un siècle. L'ère moderne de l'IA a débuté avec l'article écrit par Marvin Minsky en 1960. En une journée, la discussion sur l'intelligence artificielle sera englobée dans le cours.
  
  
• 00:25:00 "L'ère du bulldozer" fait référence à l'âge où les gens ont commencé à voir qu'ils avaient accès à une puissance de calcul illimitée et ont commencé à développer des systèmes experts basés sur des règles.
  
  
• 00:30:00 La vidéo traite de l'histoire de l'évolution humaine et de l'idée du lycée, qui est que les humains ont évolué grâce à une amélioration graduelle et continue. Il poursuit en expliquant comment les changements accidentels qui ont conduit à l'évolution humaine étaient des produits évolutifs accidentels, et en spéculant sur ce que ces changements pourraient être.
  
  
• 00:35:00 Cette vidéo fournit une brève introduction aux idées de Noam Chomsky sur le développement de l'intelligence humaine. Les principaux points soulevés sont que la langue est au centre de l'intelligence humaine et que l'objectif principal du cours est d'aider les étudiants à développer des compétences dans le domaine. La vidéo mentionne également l'importance des récitations et des tutoriels, qui sont des aspects clés du cours.
  
  
• 00:40:00 Cette vidéo donne un bref aperçu du cours du MIT, y compris sa corrélation entre l'assiduité aux cours et les notes. La vidéo fournit ensuite un résumé de la façon dont le cours calcule la note d'un étudiant, ce qui inclut la prise en compte des performances de l'étudiant aux quiz et à la finale. Enfin, la vidéo avertit les étudiants de ne pas tenter de passer tous les examens finaux, car il y aurait trop de pression et moins de possibilités d'amélioration.
  
  
• 00:45:00 La vidéo présente le quiz et la finale et explique comment le quiz fonctionnera et le format de l'examen final. La vidéo explique également comment les étudiants pourront contacter l'instructeur et programmer des tutoriels.

[MetaQuotes]

Cours 2. Raisonnement : arbres d'objectifs et résolution de problèmes

2. Raisonnement : arbres d'objectifs et résolution de problèmes

Cette vidéo explique comment raisonner, les arbres d'objectifs et la résolution de problèmes. Il présente une technique appelée "réduction de problèmes" et explique comment elle peut être utilisée pour résoudre des problèmes de calcul. Il explique également comment utiliser les transformations heuristiques pour résoudre des problèmes et comment les connaissances peuvent être utilisées pour résoudre des problèmes dans des domaines complexes.

• 00:00:00 La vidéo présente la réduction de problèmes, qui est une technique de résolution de problèmes couramment utilisée par les étudiants en calcul. Il traite de la philosophie pédagogique qui sous-tend la réduction des problèmes et fournit une liste d'exemples de réduction des problèmes.
  
  
• 00:05:00 L'orateur explique comment fonctionne la résolution de problèmes et comment différentes transformations peuvent aider à résoudre un problème. Ils passent en revue quatre transformations sûres qui sont nécessaires pour résoudre un problème. La première étape consiste à appliquer toutes les transformations sûres, puis à regarder dans le tableau pour voir si le problème a été résolu. Si le problème a été résolu, l'orateur signalera le succès.
  
  
• 00:10:00 La vidéo aborde le concept d'arbres d'objectifs et de résolution de problèmes, et introduit l'idée de transformations heuristiques. Ces transformations, sans toujours réussir, peuvent être utiles dans certaines situations.
  
  
• 00:15:00 La vidéo traite de diverses transformations heuristiques pouvant être utilisées pour résoudre des problèmes. L'une de ces transformations est une famille de transformations dont je ne vous montrerai qu'une seule. Cette transformation ressemble à ceci : si vous avez l'intégrale d'une fonction de la tangente et de X, vous pouvez la réécrire comme l'intégrale d'une fonction de Y sur 1 plus y au carré dy. Cette transformation d'une forme trigonométrique en une forme polynomiale élimine tous les déchets trigonométriques dont nous ne voulons pas nous occuper. Il y a aussi un C dont nous avons besoin, et ce sera votre réaction instinctive appropriée. Vous voyez quelque chose de la forme 1 moins x au carré, et que faites-vous quand vous voyez cela ? Eh bien, vous pourriez le faire. Tu ne peux rien faire si Kristen a quelque chose à suggérer. Elle dit qu'à cause de quoi où est notre hongrois je tourne notre jeune tour, cela suggère que nous fassions la transformation qui implique X signe de personnes s'appliquent. Cela signifie que Scylla n'a plus besoin de s'en souvenir car à l'avenir, elle n'aura plus jamais à intégrer quoi que ce soit personnellement dans sa vie. Elle peut simplement simuler le programme. Ceux-ci vont de la forme polynomiale à une forme trigonométrique, vous avez donc trois
  
  
• 00:20:00 La vidéo traite du raisonnement, des arbres d'objectifs et de la résolution de problèmes. Le présentateur présente une technique de résolution de problèmes appelée "l'arbre des objectifs". Cet arbre montre comment les objectifs sont liés les uns aux autres, et il peut être utile pour prendre des décisions sur le problème à résoudre. Le présentateur explique que cette technique est également connue sous le nom d'"arbre d'induction de problèmes" ou "arbre d'objectifs".
  
  
• 00:25:00 Cette vidéo présente le concept d'arbres d'objectifs et de résolution de problèmes, et montre comment mesurer la profondeur de la composition de fonctions à l'aide de symboles. La vidéo montre ensuite comment on peut appliquer une transformation sûre pour diviser une intégrale en trois parties, et comment cela fonctionne pour une fonction rationnelle particulière.
  
  
• 00:30:00 La vidéo traite du programme de raisonnement, qui résout des problèmes en composant des transformations sûres. Il montre comment le programme s'est arrêté avant de trouver une solution à un problème particulier et s'est remis au travail sur un autre problème.
  
  
• 00:35:00 La vidéo discute du raisonnement derrière le modèle de Schlegel des problèmes de calcul de première année, qui est un modèle dans lequel des connaissances sur les transformations, le fonctionnement des vieux arbres et les tables sont nécessaires pour résoudre les problèmes. La vidéo mentionne également comment la profondeur de la composition fonctionnelle, qui est une technique suggérée par Brett, n'a pas vraiment d'importance parce que l'arbre ne pousse pas en profondeur ou en largeur.
  
  
• 00:40:00 La vidéo explique comment les connaissances sont représentées dans la résolution de problèmes et comment certaines transformations simplifient le problème. Il explique également comment les connaissances peuvent être utilisées pour résoudre des problèmes dans des domaines complexes.
  
  
• 00:45:00 L'orateur fait la démonstration d'un programme censé montrer comment les ordinateurs peuvent être "intelligents". Cependant, l'orateur se rend vite compte que le programme fait la même chose que lui, et donc l'ordinateur n'est pas vraiment intelligent.

[MetaQuotes]

Cours 3. Raisonnement : arbres d'objectifs et systèmes experts basés sur des règles

3. Raisonnement : arbres d'objectifs et systèmes experts basés sur des règles

Cette vidéo explique le fonctionnement d'un système expert basé sur des règles. Le système est conçu pour résoudre des problèmes difficiles à résoudre en utilisant des méthodes plus traditionnelles. Le système est composé de plusieurs règles qui sont reliées par et des portes, permettant au système de reconnaître un animal spécifique avec certitude.

• 00:00:00 Cette vidéo explique comment un système expert basé sur des règles (RBS) est construit et fournit un exemple du fonctionnement du système. Le RBS est conçu pour résoudre des problèmes difficiles à résoudre à l'aide de méthodes plus traditionnelles, telles que les équations algébriques.
  
  
• 00:05:00 Dans cette vidéo, le professeur Patrick Winston explique comment fonctionnent les programmes de raisonnement, ou systèmes experts basés sur des règles. La structure du programme est très simple, avec quatre blocs qui sont exécutés dans une boucle itérative afin d'atteindre un résultat souhaité. Le programme est capable de résoudre des problèmes impliquant des blocs simples car il prend des indices à partir de questions auxquelles il a répondu dans le passé et utilise la récursivité pour obtenir un résultat complexe.
  
  
• 00:10:00 La vidéo explique comment un arbre d'objectifs est utilisé pour répondre à des questions sur la façon dont quelque chose a été fait, et comment un arbre et-ou peut être utilisé pour ce faire. Il explique également que le programme d'intégration peut utiliser des arbres d'objectifs pour répondre à des questions sur son propre comportement.
  
  
• 00:15:00 Cette vidéo explique à quel point le comportement complexe est le résultat de la complexité de l'environnement, et non de la complexité du programme. Les systèmes experts basés sur des règles ont été développés à la fin des années 60 comme un moyen d'encapsuler les connaissances dans des règles simples, et ils sont toujours utilisés aujourd'hui.
  
  
• 00:20:00 Cette vidéo YouTube explique comment un système expert basé sur des règles à chaînage en avant (RBSES) peut être utilisé pour identifier les animaux dans un petit zoo. Le RBSES est composé de plusieurs règles qui sont reliées par et des portes, permettant au système de reconnaître un animal spécifique avec certitude.
  
  
• 00:25:00 Cette vidéo explique le fonctionnement d'un système expert à base de règles (RBE), en revenant sur une hypothèse pour déterminer si un objet est un certain type d'animal.
  
  
• 00:30:00 Un système expert basé sur des règles a été créé pour concevoir des maisons similaires à celles conçues par l'architecte portugais Siza. Le système est capable de traduire ce qu'un ensacheur d'épicerie dit en une règle si-alors, permettant à un ingénieur de la connaissance de le comprendre.
  
  
• 00:35:00 Dans cette vidéo, le professeur Patrick Winston discute des principes d'ingénierie des connaissances, y compris la nécessité de cas spécifiques et l'utilisation d'heuristiques. Il fournit également un exemple de la façon dont l'heuristique numéro deux, la question de savoir si deux objets sont identiques ou différents, peut être utilisée pour résoudre des problèmes.
  
  
• 00:40:00 Le présentateur discute de trois manières d'améliorer l'intelligence humaine : en construisant des systèmes basés sur des règles, en développant des programmes axés sur les objectifs et en utilisant des programmes d'intégration. L'heuristique numéro trois est que lorsqu'une règle ou un objectif n'est pas suivi, le système se fissure, indiquant un besoin de connaissances supplémentaires. Le présentateur le démontre en discutant d'un cas dans lequel un programme a prescrit un baril de pénicilline à un patient.
  
  
• 00:45:00 Cette vidéo explique comment fonctionne le raisonnement via des arbres d'objectifs et des systèmes experts basés sur des règles. Dans les deux exemples, le système est capable de lire des histoires et de déterminer les conséquences des actions.

[MetaQuotes]

Cours 4. Recherche : profondeur d'abord, escalade, faisceau

4. Recherche : profondeur d'abord, escalade, faisceau

Dans cette vidéo YouTube, Patrick Winston discute de différents algorithmes de recherche, y compris les recherches Depth-first, Hill Climbing, Beam et Best-first. En utilisant une carte comme exemple, il démontre les avantages et les limites de chaque algorithme et comment la compréhension de différentes méthodes de recherche peut améliorer les compétences en résolution de problèmes. Winston discute également de l'application des algorithmes de recherche dans les systèmes intelligents, en utilisant le système Genesis pour répondre aux questions sur l'histoire de Macbeth. Il introduit également le concept d'une victoire à la Pyrrhus et explique comment les programmes de recherche peuvent découvrir de telles situations en parcourant des graphiques et en rapportant leurs découvertes en anglais. Dans l'ensemble, la vidéo fournit un aperçu complet des algorithmes de recherche et de leur utilisation pratique dans des scénarios réels.

• 00:00:00 Dans cette section, Patrick Winston discute des différentes méthodes de recherche et de leur lien avec nos propres capacités de résolution de problèmes. Il démontre l'importance d'un bon algorithme de recherche avec l'exemple de trouver le chemin optimal d'un point à un autre sur une carte. Il introduit également le concept d'une recherche au British Museum, dans laquelle tous les chemins possibles sont explorés, mais note que cette méthode n'est pas efficace. Il poursuit en discutant de la profondeur d'abord, de l'escalade et de la recherche par faisceau et de la manière dont ils peuvent être utilisés dans différents scénarios. Il souligne que la compréhension de différents algorithmes de recherche peut aider à développer l'intuition sur la résolution de problèmes et peut également donner un aperçu de la façon dont notre cerveau aborde les problèmes.
  
  
• 00:05:00 Dans cette section, les concepts de recherches en profondeur d'abord, d'escalade et de faisceau sont introduits en utilisant l'exemple d'une carte. L'algorithme du British Museum est utilisé pour illustrer comment tous les chemins possibles peuvent être trouvés sans se mordre la queue sur une carte. Bien que la recherche soit représentée par des cartes, il est clair qu'elle ne se limite pas à elles et concerne en fait les choix qui sont faits lorsque vous essayez de prendre des décisions. La recherche en profondeur d'abord est l'une des recherches présentées, et elle consiste à avancer d'une manière résolue, à choisir un chemin et à revenir en arrière face à une impasse. Le processus de retour en arrière est également présenté comme un moyen de rendre l'algorithme plus efficace.
  
  
• 00:10:00 Dans cette section, la vidéo traite de deux algorithmes de recherche principaux : la recherche en profondeur d'abord et la recherche en largeur d'abord. La recherche en profondeur d'abord est mieux utilisée en conjonction avec la technique de retour en arrière facultative, car elle peut éviter de manquer un chemin qui mène à l'objectif. La recherche en largeur construit une arborescence niveau par niveau et complète un chemin qui mène à l'objectif. La vidéo teste ensuite les deux algorithmes de recherche sur un exemple de problème, en déplaçant la position de départ et en ajustant la recherche en conséquence. Un organigramme est introduit pour démontrer l'algorithme de recherche, en utilisant une file d'attente pour représenter les chemins à l'étude.
  
  
• 00:15:00 Dans cette section, l'orateur explique comment fonctionne l'algorithme de recherche en profondeur d'abord. L'algorithme commence par initialiser la file d'attente et étendre le premier chemin de la file d'attente. Après avoir étendu s, le locuteur obtient deux chemins, s va vers a et s va vers b. Pour la recherche en profondeur d'abord, les nouveaux chemins étendus sont placés au début de la file d'attente afin que l'algorithme puisse continuer à descendre dans l'arbre de recherche. L'orateur explique également que la recherche en largeur d'abord utilise le même algorithme que la recherche en profondeur d'abord avec une ligne modifiée, qui consiste à placer les nouveaux chemins à l'arrière de la file d'attente au lieu de l'avant.
  
  
• 00:20:00 Dans cette section, nous découvrons les limites de la recherche étendue et comment l'améliorer. L'algorithme est considéré comme inefficace et ne peut pas dire s'il se rapproche ou s'éloigne de l'objectif. De plus, il étend souvent les chemins qui vont au même nœud plus d'une fois, et nous devons éviter cela. En modifiant l'algorithme pour ne pas étendre un chemin à moins qu'un nœud final n'ait pas été étendu auparavant, nous pouvons éviter de perdre du temps sur des chemins dupliqués. En utilisant cette méthode, nous constatons une amélioration significative de l'efficacité de la recherche et de la qualité du chemin.
  
  
• 00:25:00 Dans cette section, la vidéo explore la recherche d'escalade en tant qu'approche plus éclairée pour trouver le nœud cible en tenant compte de la distance au nœud. Semblable à la recherche en profondeur d'abord, Hill Climbing répertorie les options de manière lexicale et rompt les liens en fonction de la proximité du nœud d'objectif. Cela se traduit par un chemin plus droit sans retour en arrière, bien que ce ne soit pas toujours le chemin optimal. La vidéo montre que Hill Climbing produit moins de mises en file d'attente et un chemin plus direct par rapport à Depth-First Search. La vidéo encourage l'utilisation d'heuristiques dans les algorithmes de recherche, le cas échéant.
  
  
• 00:30:00 Dans cette section, l'instructeur discute de la technique de recherche par faisceau, un complément ou un ajout à la recherche en largeur qui permet une recherche éclairée à l'aide d'heuristiques. Beam Search fixe une limite au nombre de chemins à prendre en compte à chaque niveau et ne conserve que les deux premiers chemins qui peuvent se rapprocher de l'objectif en tirant parti d'informations supplémentaires ou d'une mesure heuristique de la distance jusqu'à l'objectif. L'instructeur mentionne que Hill Climbing est également une recherche éclairée qui ajoute de nouveaux chemins à l'avant de la file d'attente en tenant compte de la distance jusqu'au but, qui sont triés pour que tout reste droit.
  
  
• 00:35:00 Dans cette section, l'orateur discute de Beam Search et de Best-first Search, deux algorithmes de recherche supplémentaires qui peuvent être utilisés dans des espaces continus tels que les montagnes. Beam Search implique de sélectionner et de conserver les w meilleurs chemins comme solution, tandis que Best-first Search implique de toujours travailler sur le nœud feuille le plus proche de l'objectif et peut sauter dans l'arbre de recherche. L'escalade peut rencontrer des problèmes dans des espaces continus, comme rester coincé dans un maximum local ou ne pas pouvoir se déplacer dans une zone plate. Enfin, l'orateur illustre un problème supplémentaire avec l'escalade dans des espaces de grande dimension, où un pont pointu peut être présent.
  
  
• 00:40:00 Dans cette section, la vidéo traite de l'intelligence de modélisation et du besoin d'algorithmes de recherche dans la construction de systèmes intelligents. L'orateur utilise l'exemple d'une carte topographique pour illustrer comment nous pouvons être trompés en pensant que nous sommes au sommet, alors que nous ne le sommes pas. Cela conduit au concept de recherche, qui est nécessaire pour faire des plans et évaluer les choix. L'orateur démontre ensuite l'utilisation du système Genesis pour répondre aux questions sur l'histoire de Macbeth à l'aide d'un algorithme de recherche. Le système absorbe les informations, construit un graphique d'élaboration et recherche des modèles dans l'histoire liés à la vengeance et à d'autres concepts de niveau supérieur.
  
  
• 00:45:00 Dans cette section, Patrick Winston discute du concept d'une victoire à la Pyrrhus, qui est une situation où tout semble aller bien au début mais qui finit par avoir des conséquences négatives. Il montre comment les programmes de recherche peuvent découvrir de telles informations en parcourant des graphiques et peuvent répondre à des questions basées sur ces informations. Les programmes utilisent une combinaison d'instructions explicites et de règles si/alors pour construire ces graphiques et rapporter les informations en anglais. Winston mentionne également que ces programmes peuvent générer des réponses de bon sens et des réflexions de niveau supérieur en rendant compte des recherches qui ont produit les informations. Enfin, il démontre la capacité du système à répondre aux questions sur le caractère et les motivations de Macbeth à l'aide d'une sortie de langage générée par un système d'analyseur.

[MetaQuotes]

Cours 5. Recherche : Optimal, Branch and Bound, A*

5. Recherche : Optimal, Branch and Bound, A*

La vidéo traite de plusieurs algorithmes de recherche pour trouver le chemin le plus court entre deux endroits, en se concentrant sur l'exemple de la Route 66 entre Chicago et Los Angeles. La vidéo présente le concept de distance heuristique et fournit des exemples de différents algorithmes de recherche, tels que l'escalade, la recherche par faisceau et la branche et la liaison. Le conférencier insiste sur l'importance d'utiliser des heuristiques admissibles et cohérentes dans l'algorithme A* pour optimiser la recherche. En outre, la vidéo note l'efficacité de l'utilisation d'une liste étendue et des distances des compagnies aériennes pour déterminer les limites inférieures sur le chemin le plus court. En fin de compte, la vidéo se termine par la promesse de discuter d'autres améliorations de l'algorithme A * dans la prochaine conférence.

• 00:00:00 Dans cette section, le professeur explique comment trouver le chemin le plus court entre deux endroits, en se concentrant sur l'exemple de la Route 66 entre Chicago et Los Angeles. Il mentionne la création du système d'autoroute inter-États par le président Eisenhower, qui voulait reproduire la capacité de l'armée allemande à déplacer rapidement des troupes à travers le pays. Le professeur introduit ensuite le concept de distance heuristique et comment il peut aider à trouver le meilleur chemin, même si ce n'est pas toujours vrai. Il donne également des exemples de différents algorithmes de recherche, tels que l'escalade et la recherche par faisceau, qui visent à trouver le meilleur chemin en étant proche de la destination.
  
  
• 00:05:00 Dans cette section, le professeur aborde le concept de distance heuristique et le principe de résolution de problèmes en demandant à quelqu'un qui connaît la réponse. Prenant l'exemple de trouver le chemin le plus court sur une carte, le professeur propose de suivre le chemin suggéré par Juana, mais le vérifie en vérifiant que tous les autres chemins possibles finissent par être plus longs que l'itinéraire suggéré. Le professeur élabore sur le processus de calcul de la longueur du chemin et de choix du chemin le plus court à prolonger, jusqu'à ce que la longueur du chemin corresponde à celle suggérée par Juana.
  
  
• 00:10:00 Dans cette section, l'orateur explique comment trouver le chemin le plus court sans oracle. L'approche consiste à prolonger le chemin le plus court jusqu'à atteindre l'objectif. L'orateur donne un exemple pour illustrer le processus de recherche du chemin le plus court en considérant des chemins avec des longueurs non négatives. L'approche vérifie si le travail effectué jusqu'à présent est perdu, et si ce n'est pas le cas, la longueur du chemin est la plus courte. L'orateur explique que cette approche peut trouver le chemin le plus court, mais il pourrait y avoir d'autres chemins si des longueurs de longueur nulle existent.
  
  
• 00:15:00 Dans cette section de la vidéo, l'orateur montre comment utiliser la branche et la liaison pour trouver le chemin le plus court sur une carte plus compliquée. Ils mentionnent la décoration de l'organigramme et expliquent le processus d'initialisation de la file d'attente, de test du premier chemin de la file d'attente et d'extension des chemins qui ne sont pas gagnants. L'orateur note que l'approche de branchement et de liaison met de nombreux chemins dans la file d'attente et étend de nombreux chemins qui ne sont pas optimaux, mais cela peut être amélioré en étendant uniquement les chemins qui n'ont pas été étendus auparavant. L'orateur souligne l'importance de n'utiliser que l'approche des chemins étendus pour trouver des chemins optimaux.
  
  
• 00:20:00 Dans cette section, le concept de liste étendue est présenté comme une amélioration de l'ajustement de l'algorithme branch-and-bound. La liste étendue empêche l'algorithme d'étendre les chemins qui ont déjà été étendus et qui ont des longueurs de chemin plus longues que celles qui ont déjà atteint le même point. En gardant une liste étendue, de vastes zones de l'arbre peuvent être élaguées, réduisant ainsi le nombre d'extensions nécessaires pour parvenir à une solution. Par rapport à l'exemple précédent, le nouvel algorithme ne nécessite que 38 extensions au lieu de 835, d'où un gain substantiel en temps de calcul.
  
  
• 00:25:00 Dans cette section, le concept d'utilisation des distances aériennes pour déterminer la limite inférieure du chemin le plus court possible est introduit. La distance accumulée et la distance aérienne sont ajoutées pour fournir une limite inférieure sur le chemin. La simulation est ensuite démontrée avec la sélection du chemin avec la distance potentielle la plus courte de S à G. En cas d'égalité, le chemin avec la valeur lexicalement la plus faible est choisi.
  
  
• 00:30:00 Dans cette section, l'intervenant discute de l'utilisation d'heuristiques pour accélérer les algorithmes de recherche de graphes. L'utilisation d'une heuristique admissible se produit lorsqu'une estimation est garantie inférieure à la distance réelle. La liste étendue est plus utile que l'utilisation de l'une de ces heuristiques de limite inférieure. Cependant, l'efficacité de l'heuristique dépend du problème, et en changeant le placement de la position de départ, les résultats de la recherche peuvent être modifiés. En fin de compte, il est important de noter que l'utilisation d'heuristiques peut ne pas répéter les mouvements à travers le même nœud, mais cela ne fera pas nécessairement quelque chose d'essentiel pour une recherche efficace.
  
  
• 00:35:00 Dans cette section, la vidéo traite de A*, un algorithme de recherche qui combine à la fois l'heuristique admissible et l'algorithme de branchement et de liaison. En utilisant les deux techniques, A* peut grandement améliorer ses performances individuelles. L'heuristique admissible utilise un objectif strict tandis que l'algorithme de branchement et de liaison comprend l'exploration spatiale impliquée. La vidéo montre comment A* peut résoudre les problèmes plus efficacement lorsque les deux techniques sont utilisées ensemble. Cependant, la vidéo note également que certaines circonstances peuvent rendre l'admissibilité impossible si la recherche va au-delà des cartes traditionnelles. Par conséquent, la hiérarchie admissible et l'algorithme A* pourraient devenir moins efficaces pour trouver des solutions optimales.
  
  
• 00:40:00 Dans cette section, le professeur explique le concept d'heuristique admissible dans l'algorithme A*. Il montre un exemple de carte avec des distances impaires et explique comment l'utilisation d'une heuristique admissible ne conduit pas toujours à trouver le chemin le plus court. Le professeur souligne que l'heuristique admissible ne fonctionne que pour les cartes et que pour faire fonctionner l'algorithme dans des situations qui ne sont pas des cartes, il faut quelque chose de plus fort que l'admissibilité dans l'heuristique. La vidéo se termine par la promesse de discuter de ce raffinement dans la prochaine conférence.
  
  
• 00:45:00 Dans cette section, le conférencier discute des exigences pour qu'une fonction heuristique fonctionne dans l'algorithme A*. Il introduit les concepts d'admissibilité et de cohérence, expliquant qu'une fonction heuristique doit être à la fois admissible et cohérente pour fonctionner dans des situations où elle n'est pas une carte. Il montre que l'utilisation d'une heuristique admissible mais incohérente peut entraîner l'échec de l'algorithme, même dans les scénarios où une heuristique cohérente aurait fonctionné. Enfin, l'enseignant souligne l'importance d'utiliser tous les avantages disponibles pour optimiser l'algorithme A*, y compris l'utilisation d'une liste étendue et d'une fonction heuristique appropriée.