Apprentissage Automatique et Réseaux Neuronaux - page 16

[MetaQuotes]

Cours d'apprentissage automatique pour débutants (parties 6 à 10)

Cours d'apprentissage automatique pour débutants

Partie 6

• 05:00:00 Dans cette section, l'instructeur aborde le concept de modèles à forte variance et à fort biais, où un surajustement et un sous-ajustement peuvent se produire. L'objectif de l'apprentissage automatique est d'avoir un modèle à faible biais et à faible variance pour obtenir une précision optimale. L'instructeur donne des exemples d'apprentissage d'ensemble, où plusieurs modèles sont formés sur des données et des prédictions sont extraites de chaque modèle pour être votées et déterminer finalement la bonne réponse ou prédiction. La majorité est souvent plus précise que la réponse d'un individu dans l'apprentissage d'ensemble, et l'instructeur explique le concept à l'aide d'exemples tels que des questions de quiz et le vote électoral.
  
  
• 05:05:00 Dans cette section, l'instructeur donne un aperçu de l'apprentissage d'ensemble et comment il peut être utilisé pour les problèmes de classification et de régression. Dans la classification, la majorité des votes sont pris en compte, alors que dans la régression, la moyenne ou la médiane des sorties des modèles de base sont utilisées pour la prédiction finale. Les techniques utilisées dans l'apprentissage d'ensemble comprennent le bagging, le boosting, l'empilement et la cascade, et la plupart des gagnants du concours Kaggle utilisent une certaine forme de techniques d'apprentissage d'ensemble. De plus, l'instructeur souligne que des entreprises comme Amazon et Google utilisent ces algorithmes, tels que XGBoost et la forêt aléatoire, dans leurs propres produits.
  
  
• 05:10:00 traite des bases du bagging, une technique d'apprentissage d'ensemble également connue sous le nom d'agrégation bootstrap. Le bagging implique un échantillonnage aléatoire de sous-ensembles de données d'apprentissage et de modèles d'apprentissage sur chaque sous-ensemble. L'idée est de réduire le surajustement et d'améliorer la précision du modèle en utilisant un ensemble de plusieurs modèles. La section explique comment fonctionne le bagging, y compris comment échantillonner les données, former des sous-ensembles de modèles et combiner les prédictions pour une meilleure précision.
  
  
• 05:15:00 Dans cette section, l'orateur explique le concept de bagging, une technique pour améliorer la précision des modèles d'apprentissage automatique. L'ensachage implique l'échantillonnage des données avec remplacement, puis la formation de modèles sur chaque échantillon. Les modèles individuels sont ensuite combinés pour former un modèle agrégé qui produit des prédictions plus précises. L'orateur note que l'ensachage est une technique conceptuellement simple qui n'implique aucune mathématique avancée.
  
  
• 05:20:00 Dans cette section, l'orateur discute de l'ensachage, qui aide à réduire la variance des modèles de base à forte variance et à faible biais. Le bagging combine ces modèles pour créer un modèle plus grand, à faible variance et à faible biais. L'échantillonnage de lignes est utilisé lors de l'échantillonnage des données, ce qui implique d'échantillonner uniquement les lignes de la grande distribution de données. Il est important de noter que dans le bagging, seul l'échantillonnage en ligne est utilisé, contrairement à la forêt aléatoire, qui utilise à la fois l'échantillonnage en ligne et en colonne. Le bagging est également connu sous le nom d'agrégation bootstrap, qui implique l'amorçage et l'agrégation de modèles de base.
  
  
• 05:25:00 Dans cette section, l'instructeur récapitule la technique d'ensachage, qui est un moyen de réduire la variance dans les modèles à forte variance et à faible biais. Le bagging consiste à prendre des sous-ensembles de données pour la formation et à combiner la majorité des votes pour la classification. L'instructeur pense qu'un algorithme puissant pour cela est la forêt aléatoire, qui est une combinaison d'arbres de décision, d'ensachage et d'échantillonnage de colonnes. Les arbres de décision prennent des décisions simples et divisent les nœuds, tandis que le bagging implique de prendre des sous-ensembles de données pour la formation. L'échantillonnage de colonne ou l'ensachage de caractéristiques est également utilisé, en prenant des sous-ensembles des colonnes. L'instructeur affirme que les forêts aléatoires sont puissantes et que de grandes entreprises comme Google, Quora et Amazon les utilisent.
  
  
• 05:30:00 Dans cette section, l'instructeur d'apprentissage automatique explique le concept d'ensachage et de forêt aléatoire. Le bagging implique l'échantillonnage des lignes avec remplacement et la formation d'un arbre de décision sur le sous-ensemble, tandis que la forêt aléatoire ajoute l'échantillonnage des colonnes au mélange. Cela signifie que les lignes et les colonnes sont échantillonnées, ce qui augmente les chances d'un modèle performant grâce à la technique d'apprentissage d'ensemble. L'instructeur mentionne également le concept de points hors sac (oob) qui sont les points laissés de côté après l'échantillonnage et peuvent être utilisés pour la validation croisée. Enfin, l'instructeur récapitule les principales différences entre le bagging et la forêt aléatoire.
  
  
• 05:35:00 Dans cette section, la vidéo traite des techniques d'ensachage et de forêt aléatoire dans l'apprentissage automatique. L'ensachage implique un échantillonnage en ligne, ce qui conduit à un modèle plus grand, réduisant la variance. La forêt aléatoire est la même, mais avec un échantillonnage de colonnes et des arbres de décision comme modèles de base. La complexité du train dans les arbres de décision est de l'ordre de n log m fois n fois d, alors que dans les forêts aléatoires, elle est d fois k fois n. La vidéo explique également comment les forêts aléatoires sont trivialement parallélisées, ce qui les rend faciles à former. Enfin, le concept d'arbres extrêmement aléatoires est introduit, qui teste des valeurs possibles pour déterminer le seuil dans les arbres de décision.
  
  
• 05:40:00 Dans cette section, l'orateur discute du concept d'arbres extrêmement aléatoires comme alternative à la méthode coûteuse en calcul consistant à essayer toutes les valeurs possibles dans Random Forest. En échantillonnant un sous-ensemble de colonnes et de lignes, la variance est réduite mais il y a moins de chances d'obtenir de bons résultats par rapport à Random Forest. L'orateur mentionne également les inconvénients de l'utilisation de Random Forest sur de grands ensembles de données en raison de sa complexité temporelle, mais suggère de l'essayer et de régler les hyperparamètres à l'aide de la recherche par grille. Ils présentent ensuite l'API scikit-learn pour implémenter Random Forest et mentionnent un projet pour affiner les hyperparamètres.
  
  
• 05:45:00 Dans cette section, le classificateur de forêt aléatoire est discuté avec ses paramètres et attributs. Le premier paramètre est n_estimators, qui est le nombre d'arbres de décision utilisés. Les critères de sélection des attributs et la profondeur maximale de l'arbre sont également expliqués ainsi que d'autres paramètres tels que l'échantillon minimum requis pour diviser et le nombre maximum d'entités. L'utilisation de l'importance des caractéristiques est également mentionnée afin de sélectionner des caractéristiques importantes pour le modèle. Le régresseur de forêt aléatoire est également brièvement discuté avec ses similitudes avec le classifieur.
  
  
• 05:50:00 Dans cette section de la vidéo, l'instructeur aborde les techniques d'ensemble, en particulier le Boosting. Le boosting est une autre technique d'apprentissage d'ensemble populaire, et l'instructeur donne un aperçu de Gradient Boosting, Adaptive Boosting ou AdaBoost, et Extreme Boosting ou XGBoost. L'instructeur mentionne également qu'il existe un ensemble de problèmes disponible sur GitHub pour que les téléspectateurs puissent l'essayer, et encourage les téléspectateurs à s'abonner à la chaîne YouTube pour soutenir la création de plus de contenu gratuit.
  
  
• 05:55:00 Dans cette section, la vidéo aborde les thèmes du bagging et du boosting dans l'apprentissage automatique. Le bagging est utilisé pour réduire la variance élevée dans les modèles en procédant à un échantillonnage de colonnes et de lignes, suivi d'une agrégation. Le boosting, d'autre part, est utilisé pour réduire les biais dans les modèles en combinant de manière additive les apprenants faibles dans un modèle fort. L'idée centrale de l'utilisation du boosting est de réduire le biais dans un modèle fortement biaisé. La vidéo fournit une intuition de base du boosting à l'aide d'un exemple de données d'entraînement.

Partie 7

• 06:00:00 Dans cette section, l'orateur explique l'idée de base derrière le boosting et comment cela fonctionne pour minimiser les erreurs. Le boosting est une technique d'apprentissage supervisé qui consiste à entraîner un modèle sur des données d'entraînement (x et y) avec une étiquette pour chaque exemple. Le modèle est ensuite utilisé pour prédire la sortie de chaque entrée, et la différence entre la valeur prédite et la valeur de vérité terrain est mesurée pour calculer la perte. Le modèle est formé pour réduire l'erreur résiduelle, en se concentrant sur les données qui sont mal classées ou qui ont une MSE ou MAE élevée. L'amplification consiste à ajuster plusieurs modèles sur les erreurs résiduelles, en minimisant l'erreur en s'y adaptant pour chaque exemple d'apprentissage. Le modèle final est la somme de tous ces modèles, pondérée par alpha.
  
  
• 06:05:00 Dans cette section, le concept de boosting est expliqué, qui est une technique pour réduire les biais dans les modèles d'apprentissage automatique. Le boosting convertit les apprenants faibles en apprenants forts en ajustant les erreurs résiduelles des modèles précédents, ce qui donne un modèle à faible biais et à faible variance qui fonctionne bien sur l'ensemble d'apprentissage. Cependant, il existe un risque de surajustement si le modèle est trop bon sur l'ensemble d'apprentissage. Plusieurs techniques d'amplification, telles que l'amplification de gradient, l'amplification adaptative et l'amplification extrême, sont discutées. De plus, l'idée derrière l'ensachage est brièvement mentionnée, qui est une autre technique pour améliorer les performances du modèle.
  
  
• 06:10:00 Dans cette section, l'instructeur explique le concept de gradient boosting, qui est un algorithme de boosting qui convertit les apprenants faibles en apprenants forts. Le gradient boosting est un algorithme puissant utilisé par les grandes entreprises de technologie et de production. Il s'agit d'une fonction de coût différentiable qui permet de prendre des dérivées pour améliorer l'erreur sous un ensemble d'apprentissage. L'instructeur fournit des exemples concrets de gradient boosting et discute des fonctions de coût différentiables et de leur importance dans l'algorithme. La discussion inclut l'utilisation de données de formation et une fonction de coût dans la descente de gradient, ce qui en fait un outil utile dans l'apprentissage automatique.
  
  
• 06:15:00 Dans cette section, l'intervenant explique l'algorithme d'entraînement d'un modèle à l'aide du boosting. L'algorithme consiste à initialiser le modèle avec une valeur constante, à calculer les résidus ou les pseudo-résidus, à prendre la dérivée partielle de la fonction de coût par rapport au modèle, à ajuster les apprenants de base sur les résidus des modèles précédents, puis à parcourir chaque modèle pour calculer les pseudo-résidus et ajuster les apprenants de base. L'objectif est de trouver la valeur lambda qui minimise la fonction de coût et améliore la précision du modèle.
  
  
• 06:20:00 Dans cette section, l'orateur explique le processus de l'algorithme d'amplification du gradient, qui commence par initialiser le modèle avec une constante, puis en appliquant une boucle for pour supprimer les résidus pour chaque exemple d'entraînement. Le modèle ajuste ensuite un apprenant de base aux résidus et calcule le multiplicateur lambda m pour chaque modèle. Pour mettre à jour le modèle, le modèle précédent est ajusté aux résidus précédents, et le modèle final est obtenu en ajoutant le modèle précédent et le nouveau modèle obtenu après résolution du problème d'optimisation unidimensionnel. L'orateur couvre également les concepts de régularisation et de rétrécissement et pourquoi ils sont nécessaires dans le renforcement en raison du biais élevé.
  
  
• 06:25:00 Dans cette section, la vidéo explique comment le boosting peut être utilisé pour réduire les biais élevés dans les modèles d'apprentissage automatique. Le boosting consiste à ajuster les résidus du modèle précédent à chaque itération, ce qui peut entraîner un surajustement et une augmentation de la variance. Pour éviter ce problème, la régularisation et le rétrécissement peuvent être ajoutés à l'aide d'un paramètre apprenable appelé v. Empiriquement, il a été constaté qu'une valeur de v égale à 0,1 entraîne des améliorations spectaculaires. La vidéo couvre également la complexité temporelle des arbres de décision d'amplification de gradient et la mise en œuvre de l'amplification de gradient via l'API scikit-learn.
  
  
• 06:30:00 Dans cette section, le conférencier discute de la mise en œuvre du classificateur Gradient Boosting à l'aide de l'API Scikit-learn. Ils expliquent les différents paramètres impliqués, tels que la perte, le taux d'apprentissage, le nombre d'estimateurs, etc. Le taux d'apprentissage est utilisé pour réduire la survariance et éviter le surajustement. L'implémentation de Gradient Boosting Classifier n'est qu'une ligne de code, et la probabilité de prédiction donne la probabilité que les données soient vraies pour une certaine classe. L'orateur discute également brièvement de la mise en œuvre de Gradient Boosting Regressor et souligne l'importance d'apprendre à partir de la documentation.
  
  
• 06:35:00 Dans cette section de la vidéo "Machine Learning Course for Beginners", l'instructeur discute du classificateur AdaBoost et de sa mise en œuvre à l'aide de l'API Cython, ainsi que de l'algorithme Extreme Gradient Boosting (XGBoost). L'instructeur explique que XGBoost est une version avancée de Gradient Boosting qui ajoute une randomisation par échantillonnage de lignes et de colonnes, ce qui en fait un outil puissant pour les problèmes d'apprentissage automatique. La section couvre également les différents paramètres utilisés dans XGBoost et leur importance pour affiner le modèle.
  
  
• 06:40:00 Dans cette section, le conférencier parle des différents packages pour les algorithmes d'apprentissage automatique tels que Gradient Boosting Tree, GB Linear et DART. Ils discutent des différents paramètres qui peuvent être ajustés, y compris la matrice d'évaluation et la régularisation, et comment ils affectent le modèle. L'orateur mentionne également XGBoost et montre comment il est utilisé en Python. Ils soulignent l'importance d'affiner le modèle et comment cela peut conduire à une meilleure précision. Enfin, le conférencier présente le concept d'empilement et comment il peut aider à améliorer la précision des modèles.
  
  
• 06:45:00 Dans cette section, l'instructeur présente le concept d'empilement et en quoi il diffère du bagging et du boosting. L'empilement implique de prendre différents apprenants de base qui sont très à l'écoute et qui ont un bon compromis entre biais et variance, et de les former sur différents sous-ensembles de données pour créer différents modèles. Ceci est différent du bagging, qui est utilisé pour réduire la variance élevée en utilisant des apprenants de base avec une variance élevée et un faible biais, et le boosting, où les modèles de base ne sont pas nécessairement très réglés. L'instructeur fournit un exemple d'empilement avec différents modèles de base, tels que la régression logistique, les machines à vecteurs de support et les k plus proches voisins, qui ont subi un réglage approfondi pour produire de bons modèles avec un bon compromis biais-variance.
  
  
• 06:50:00 Dans cette section, l'orateur explique l'intuition de base derrière l'empilement, qui est un type d'apprentissage d'ensemble. L'empilement consiste à diviser les données d'apprentissage en sous-ensembles et à former différents classificateurs sur chaque sous-ensemble. Ces apprenants de base sont bons pour équilibrer les biais et la variance. Contrairement au bagging, qui a une variance élevée et un faible biais, et au boosting, qui a un biais élevé et une faible variance. Après avoir obtenu les prédictions de chaque modèle, un méta-classificateur est formé sur les étiquettes de classe prédites ou leurs probabilités. L'idée est de combiner les prédictions de ces modèles d'ensemble pour créer un classifieur plus précis et plus robuste.
  
  
• 06:55:00 Dans cette section, l'instructeur décrit l'empilement, une méthode de combinaison de plusieurs modèles pour créer un nouveau modèle avec de meilleures performances. Le processus implique la formation de plusieurs modèles de base et l'utilisation de leurs prédictions comme caractéristiques pour former un classificateur de second niveau, qui génère les prédictions finales. L'instructeur montre un exemple de création d'un modèle de classification empilée à l'aide de la régression logistique, des k plus proches voisins, de Bayes naïf gaussien et de modèles de forêts aléatoires en Python à l'aide de la bibliothèque sklearn. Ils montrent également comment utiliser le classificateur d'empilement de la bibliothèque mlx10.

Partie 8

• 07:00:00 Dans cette section, l'orateur explique comment mettre en œuvre un classificateur d'empilement en utilisant différents modèles tels que les voisins K, la forêt aléatoire et la régression logistique. Ils parcourent l'instanciation de l'objet et effectuent une triple validation croisée pour sélectionner le meilleur modèle avec la plus grande précision. L'orateur montre également comment tracer les limites de décision et utiliser la recherche de grille pour ajuster le compromis entre biais et variance. En sélectionnant les meilleurs paramètres et fonctionnalités, le classificateur d'empilement peut fournir une prédiction plus précise que les modèles individuels.
  
  
• 07:05:00 Dans cette section, l'instructeur résume les sujets abordés dans les sections précédentes sur l'apprentissage d'ensemble, y compris le bagging, les forêts aléatoires, le boosting, les arbres de décision boostant le gradient, AdaBoost et XGBoost. L'instructeur donne également un aperçu de l'empilement et fournit des exemples de l'algorithme en action. La section se termine par un rappel pour s'abonner à la chaîne YouTube de l'instructeur et des informations sur un cours d'apprentissage automatique, CS01, qui couvre des sujets au-delà de l'apprentissage d'ensemble, y compris les réseaux de neurones, les GAN et les réseaux de neurones convolutifs. Enfin, l'instructeur taquine les sections à venir sur l'apprentissage non supervisé et les projets futurs.
  
  
• 07:10:00 Dans cette section, l'orateur introduit le concept d'apprentissage non supervisé, qui consiste à n'avoir accès qu'à des points de données sans étiquettes ni superviseur pour guider le processus d'apprentissage. Contrairement à l'apprentissage supervisé, où la sortie est connue, l'apprentissage non supervisé consiste à créer des grappes de points de données pour mieux les comprendre. À titre d'exemple motivant, l'orateur suggère de segmenter les clients d'une entreprise comme Amazon en fonction des similitudes, même s'il n'y a pas d'étiquette indiquant quel client appartient à quel segment. Le but de l'apprentissage non supervisé est de découvrir des modèles et une structure dans l'ensemble de données.
  
  
• 07:15:00 Dans cette section, l'instructeur discute de l'apprentissage non supervisé et de ses applications. Il explique que les scientifiques des données peuvent utiliser l'apprentissage non supervisé pour diviser les clients en segments et fournir des recommandations de produits en fonction de leur activité sur le site Web. Il utilise Amazon comme exemple d'entreprise qui utilise l'apprentissage non supervisé pour la segmentation de la clientèle et les moteurs de recommandation. L'instructeur explique également que l'apprentissage non supervisé peut être utilisé pour le regroupement dans des espaces de grande dimension, avec des éléments similaires proches les uns des autres et des éléments différents éloignés. Il donne des exemples d'analyse de séquences en biologie et de regroupement de clusters similaires en entreprise en tant qu'applications d'apprentissage non supervisé. Dans l'ensemble, l'instructeur donne un bref aperçu de l'apprentissage non supervisé et de ses applications potentielles dans diverses industries.
  
  
• 07:20:00 Dans cette section, l'orateur aborde différentes applications de l'apprentissage automatique, telles que le regroupement de clusters similaires dans des données commerciales pour un marketing ciblé et l'utilisation de moteurs de recommandation pour suggérer des produits en fonction de l'activité des utilisateurs. L'orateur mentionne également la segmentation d'images pour la détection d'objets, l'analyse des sentiments pour déterminer si un texte est positif ou négatif et la détection d'anomalies pour trouver des valeurs aberrantes dans un modèle. Ces diverses applications démontrent la versatilité du machine learning dans différents domaines.
  
  
• 07:25:00 Dans cette section, l'orateur présente le sujet du clustering et les différents types d'algorithmes de clustering tels que centrés et basés sur la densité. L'accent sera mis sur l'algorithme de clustering k-means, qui sera exploré en profondeur. L'orateur encourage également les téléspectateurs à travailler sur des ensembles de problèmes et des projets pour mieux comprendre l'apprentissage automatique. Le conférencier souligne l'importance de l'apprentissage non supervisé et montre comment le regroupement peut être appliqué dans divers domaines. Le regroupement sur un plan X et Y est utilisé pour illustrer le concept de regroupement. Dans l'ensemble, la section met en évidence les prochains sujets à couvrir dans le cours et encourage les téléspectateurs à continuer à apprendre.
  
  
• 07:30:00 Dans cette section, l'orateur explique l'apprentissage non supervisé et le regroupement, qui implique la segmentation des données en différents groupes. La terminologie de la distance intra-cluster et inter-cluster est discutée, où intra-cluster fait référence à la distance entre les points de données à l'intérieur d'un cluster, tandis que l'inter-cluster fait référence à la distance entre les clusters. L'objectif est d'avoir une petite distance intra-cluster et une grande distance inter-cluster, ce qui signifie que les données au sein des clusters doivent être similaires et que les données entre les clusters doivent être différentes. C'est ce qu'on appelle l'objectif d'optimisation.
  
  
• 07:35:00 Dans cette section, nous apprenons les techniques d'évaluation pour les modèles de clustering ou d'apprentissage non supervisé. La première technique introduite est l'indice de Dunn, qui représente la plus grande distance entre les grappes divisée par la distance minimale à l'intérieur des grappes. L'objectif est d'avoir un indice de Dunn élevé, ce qui signifie que la distance entre les clusters doit être grande, tandis que la distance au sein des clusters doit être petite. Cette technique nous permet d'évaluer la qualité de notre modèle de clustering.
  
  
• 07:40:00 Dans cette section, l'instructeur aborde les techniques d'évaluation des modèles de clustering. L'accent est mis sur l'indice de Dunn, qui est une matrice d'évaluation utilisée pour déterminer si l'intra-cluster est grand et l'inter-cluster est petit. L'instructeur fournit la définition de base de l'indice de Dunn, qui consiste à évaluer les distances maximales entre différents points de données au sein et entre les clusters. Une autre technique d'évaluation discutée est l'indice de Davies-Bouldin, qui est similaire à l'indice de Dunn, mais avec plus de contraintes. L'instructeur fournit également une définition en une ligne du regroupement, qui consiste à regrouper des objets ou des éléments d'une manière spécifique.
  
  
• 07:45:00 Dans cette section, l'orateur explique la définition de base du regroupement, qui est le processus d'organisation des données en groupes en fonction des similitudes et des différences. Il existe deux cas de clustering : intra-cluster et inter-cluster, qui mesurent respectivement la distance au sein d'un cluster et la différence entre tous les clusters. L'orateur aborde ensuite différents types de clustering, y compris le clustering basé sur la partition, qui divise les données en deux clusters, et le clustering hiérarchique, qui utilise des dendrogrammes pour visualiser le processus de clustering. L'orateur donne plus de détails sur le regroupement agglomératif et le regroupement divisionnaire au sein du regroupement hiérarchique, en fournissant un exemple de dendrogramme pour illustrer le processus.
  
  
• 07:50:00 Dans cette section, l'instructeur couvre différents types de clustering, y compris les clusters basés sur des partitions, hiérarchiques, bien séparés, basés sur le centre et basés sur la densité. L'instructeur explique que le clustering consiste à regrouper des objets similaires de manière à ce que les objets d'un cluster soient similaires les uns aux autres et que les objets entre les clusters soient différents. L'instructeur explique également comment évaluer les performances des modèles de clustering à l'aide de différents index, notamment l'index Dunn et l'index Davis-Bouldin. La section suivante se concentrera sur le clustering k-means, l'un des algorithmes centrés.
  
  
• 07:55:00 Dans cette section, l'instructeur récapitule les sous-sections précédentes qui couvraient les applications d'apprentissage non supervisé, les types de clustering, ainsi que l'intuition et la définition formelle du clustering. L'accent est ensuite mis sur l'algorithme de clustering k-means, également connu sous le nom d'algorithme de Lloyd, et ses diverses fonctionnalités telles que l'initialisation, les centroïdes, les hyperparamètres, les métriques d'évaluation et les limitations. L'instructeur fournit une visualisation de l'algorithme avec deux centroïdes initialisés de manière aléatoire et illustre l'étape d'affectation suivie de l'étape de calcul de la moyenne dans la première itération.

Partie 9

• 08:00:00 Dans cette section, l'instructeur explique en détail l'algorithme de clustering k-means. L'algorithme implique l'initialisation de k centroïdes, l'affectation des clusters, la mise à jour des clusters en supprimant la moyenne et la mise à jour du centroïde en attribuant le point de données le plus proche. Ce processus est répété jusqu'à ce que les centroïdes ne changent pas, indiquant que l'algorithme a convergé. L'instructeur mentionne également que le clustering k-means est également appelé algorithme de Lloyd et implique l'initialisation aléatoire de centroïdes.
  
  
• 08:05:00 Dans cette section, l'orateur explique les étapes de l'algorithme de clustering k-means. Ils sélectionnent d'abord le nombre de clusters (k), puis attribuent chaque point au cluster le plus proche. Ils recalculent le centroïde en prenant la moyenne et en le déplaçant, puis répètent le processus jusqu'à ce que les centroïdes cessent de changer. L'objectif d'optimisation est de minimiser la fonction de coût, qui peut être calculée à l'aide de la distance euclidienne entre les points de données et les centroïdes de cluster. La fonction de coût est également connue sous le nom de SSE (sum squared error) et l'objectif est de minimiser la variabilité intra-cluster. L'orateur note que d'autres mesures de distance en plus de l'euclide peuvent également être utilisées.
  
  
• 08:10:00 Dans cette section, l'instructeur explique pourquoi l'initialisation aléatoire des centroïdes dans le clustering K-means peut causer des problèmes et présente l'algorithme K-means++ comme solution. K-means++ implique de sélectionner plusieurs centroïdes et de choisir celui qui minimise la somme des erreurs quadratiques (SSE). L'instructeur présente également la méthode du coude, qui est utilisée pour déterminer le nombre optimal de centroïdes sur la base d'un tracé de SSE par rapport au nombre de grappes. Il est recommandé d'utiliser K-means++ et la méthode du coude plutôt que l'initialisation aléatoire pour de meilleurs résultats de clustering dans l'apprentissage automatique.
  
  
• 08:15:00 Dans cette section, l'instructeur explique la technique d'évaluation des k-moyennes, qui consiste à minimiser l'intra-cluster en calculant la distance entre les points à l'intérieur du cluster à l'aide de l'erreur quadratique somme. L'initialisation des centroïdes a un impact sur l'algorithme, et la technique k-means ++ est une méthode recommandée pour sélectionner les centroïdes sur la base de plusieurs exécutions avec un faible SSE. Le nombre de grappes peut être déterminé à l'aide de la méthode du coude, où la valeur k optimale est le point où le coude tourne. L'instructeur mentionne également certaines limitations du clustering k-means, telles que la sensibilité aux valeurs aberrantes, qui peuvent être résolues à l'aide de techniques basées sur la densité telles que DBSCAN ou le clustering hiérarchique. La complexité temporelle du clustering k-means dépend de la taille d'entrée, du nombre de clusters et des dimensions. L'instructeur recommande le cours de maîtrise DSA pour mieux appréhender le concept de complexité temporelle.
  
  
• 08:20:00 cluster avec p1 et p2, puis nous ajoutons p4 à ce cluster. Ensuite, nous fusionnons ce cluster en un seul, et enfin ajoutons p3 au cluster pour obtenir un seul cluster. Ceci est un exemple de clustering hiérarchique, qui est une technique où les points de données sont regroupés en fonction de leurs similitudes, formant une hiérarchie de clusters. La sous-section couvrira également le clustering agglomératif et diviseur, ainsi qu'un calcul manuel de l'algorithme.
  
  
• 08:25:00 Dans cette section, l'orateur explique le regroupement hiérarchique et le processus de conversion d'un groupe de nombres en une hiérarchie de groupes. L'exemple donné montre comment les clusters sont attachés les uns aux autres en fonction de la similarité jusqu'à ce qu'il ne reste qu'un seul cluster. L'orateur explique ensuite les deux types de regroupement hiérarchique - regroupement agglomératif et divisionnaire, et donne une intuition derrière les deux méthodes. Le clustering agglomératif est une approche descendante dans laquelle des clusters plus similaires sont attachés ensemble, tandis que le clustering diviseur est une approche ascendante dans laquelle les clusters sont divisés en clusters plus petits en fonction de la similarité.
  
  
• 08:30:00 Dans cette section, l'orateur explique l'intuition de base derrière le regroupement hiérarchique qui consiste à créer une hiérarchie de nombres ou de groupes. Le regroupement peut être effectué selon une approche de haut en bas ou de bas en haut, selon le type de regroupement, agglomératif ou diviseur. Le clustering agglomératif consiste à fusionner différents clusters en un seul, tandis que le clustering diviseur consiste à diviser un cluster en groupes uniques. L'orateur poursuit ensuite en expliquant l'algorithme de regroupement agglomératif qui consiste à calculer une matrice de proximité et à répéter le processus de fusion des clusters et de mise à jour de la matrice jusqu'à ce que tous les clusters soient couverts. Enfin, l'orateur donne un exemple de matrice approximative à quatre points pour illustrer le concept.
  
  
• 08:35:00 Dans cette section, le conférencier explique comment créer une matrice de proximité et un dendrogramme à l'aide d'un exemple de points de données. La matrice de proximité permet de mesurer la similarité entre deux points ou clusters, tandis que le dendrogramme montre la hiérarchie des clusters. Le conférencier met en évidence les trois méthodes utilisées pour mesurer la similarité entre les clusters, à savoir le min, le max et la moyenne du groupe.
  
  
• 08:40:00 Dans cette section, l'instructeur présente deux méthodes de fusion de clusters dans le clustering hiérarchique : minimum et maximum. L'approche minimale consiste à prendre la similarité entre deux clusters comme la distance minimale entre deux points quelconques dans les clusters. Les clusters avec la plus petite distance sont fusionnés en premier, et le processus se poursuit jusqu'à ce que tous les points soient dans un seul cluster. L'approche maximale est similaire, mais elle considère la similarité entre deux clusters comme la distance maximale entre deux points quelconques dans les clusters. L'instructeur donne un exemple utilisant une matrice de proximité pour illustrer ces concepts.
  
  
• 08:45:00 Dans cette section, l'instructeur explique le concept de mesure de similarité intercluster moyenne de groupe, qui est un autre type de mesure de similarité intercluster. Il fournit une équation pour cela et montre un dendrogramme pour expliquer comment cela fonctionne. L'instructeur discute ensuite des inconvénients de la mesure de distance minimale, en déclarant qu'elle est sensible aux valeurs aberrantes, et suggère aux apprenants de se référer aux pages de Wikipédia pour une meilleure compréhension. Il fournit également une complexité temporelle et spatiale pour le regroupement agglomératif, qui est de l'ordre de n carré pour l'espace et de l'ordre de n log carré de n ou de l'ordre de n cube pour la complexité temporelle. Enfin, il conclut la section en exhortant les apprenants à s'entraîner avec de nombreux projets pour consolider leur compréhension de l'apprentissage automatique.
  
  
• 08:50:00 Dans cette section, le conférencier discute de la section projet du cours et présente le modèle de prédiction de l'insuffisance cardiaque qui sera construit. L'orateur explique que le modèle prédira si une personne mourra en fonction de diverses caractéristiques telles que l'âge, le sexe, la tension artérielle, le diabète et le tabagisme. Les données de ce projet sont disponibles sur un lien fourni, et l'orateur explique que l'objectif commercial de ce projet est de construire un système d'IA de soins de santé qui aidera à la détection précoce des problèmes de santé pour sauver des vies. De plus, le conférencier mentionne qu'un projet de système de détection de spam sera également présenté dans le cours. Le haut-parleur importe les bibliothèques nécessaires, charge les données et imprime la forme des données.
  
  
• 08:55:00 Dans cette section, nous apprenons les bases de l'exploration des données, telles que la vérification de la forme des données et de ses informations. En utilisant la méthode info(), nous pouvons voir s'il y a des valeurs nulles, le type de données et l'utilisation de la mémoire. Nous pouvons également utiliser la méthode describe() pour mieux comprendre la distribution statistique des données numériques. L'analyse exploratoire des données (EDA) est une étape essentielle de l'apprentissage automatique, où nous posons des questions aux données et trouvons des réponses pour aider à fournir des solutions commerciales. Pour ce problème de classification binaire, nous examinerons la distribution des classes, où « 1 » signifie que la personne est décédée et « 0 » signifie que la personne est en vie.

Partie 10

• 09:00:00 Dans cette section de la vidéo, l'instructeur aborde le problème des données déséquilibrées dans l'apprentissage automatique. L'extrait de code montre la distribution des données où il y a 203 cas vivants et 96 cas de décès, ce qui est déséquilibré. Des données déséquilibrées signifient que les données ne sont pas également réparties entre les classes, ce qui peut entraîner un biais du modèle en faveur de certaines classes. L'instructeur explique que les données déséquilibrées sont un gros problème dans l'apprentissage automatique, où le modèle peut être plus enclin à être formé sur la classe majoritaire et à prédire cette classe plus souvent.
  
  
• 09:05:00 Dans cette section, l'orateur explique le concept de données équilibrées et comment les modèles fonctionnent le mieux avec elles car elles sont plus robustes et impartiales. Ils présentent ensuite différentes manières d'analyser les données, telles que la répartition par âge et le filtrage des données en fonction de certaines conditions. L'orateur montre un code python pour sélectionner les lignes où l'âge est supérieur à 50 ans et voir si la personne est décédée ou non. Ils utilisent des diagrammes circulaires pour visualiser les données et répondre aux questions commerciales, telles que le nombre total de cas de décès étant deux fois inférieur à celui des cas vivants et que la plupart de l'âge passe de 40 à 95 ans.
  
  
• 09:10:00 Dans cette section, l'instructeur passe en revue un extrait de code en Python où il calcule le nombre total de cas de régime et de cas sans régime. Ils constatent que sur un total de 203 cas, la plupart des cas sont des cas de régime alimentaire, mais plus de 50 d'entre eux ont plus de 50 ans et sont décédés. L'instructeur poursuit ensuite en expliquant comment ils peuvent répondre à plus de questions basées sur ces données et représenter visuellement les données pour les rendre plus faciles à comprendre. Enfin, l'instructeur passe en revue la vérification de la corrélation entre les variables et fournit un graphique pour expliquer ce que signifie la corrélation.
  
  
• 09:15:00 ans cette section, l'instructeur explique la corrélation et comment elle varie de moins un à plus un. Une variable plus proche de moins un signifie qu'elle est très similaire, tandis qu'une valeur plus proche de zéro signifie qu'il n'y a pas de transmission linéaire. La corrélation de Pearson est un moyen de déterminer si les données sont linéaires ou non, et plus la corrélation est proche de un, plus les données sont positivement corrélées. L'instructeur parle de corrélation parfaite et de la façon dont les diagonales sont toutes une, ce qui signifie que les carrés sont en corrélation avec chaque variable elle-même. Après avoir discuté des données et de la compréhension, l'instructeur passe au développement d'ensembles de données et à la façon de diviser les données en ensembles de formation et de test pour valider le modèle qui fonctionne le mieux. L'instructeur fournit un exemple d'ingénierie de fonctionnalités, qui consiste à ajouter plus de fonctionnalités avec des variables catégorielles et à appliquer des transformations sur les données pour insérer des fonctionnalités. Un terme d'interaction additionne le produit de deux caractéristiques, et l'instructeur montre comment parcourir toutes les colonnes et multiplier les deux colonnes ensemble.
  
  
• 09:20:00 Dans cette section, le présentateur discute du processus de construction d'un modèle et évalue sa matrice d'exactitude, de précision, de rappel et de confusion. Le présentateur utilise un algorithme appelé l'algorithme d'optimisation pour affiner un ensemble de données avec 10 000 points de données et dix caractéristiques. Ils expliquent comment fonctionne la descente de gradient stochastique et comment elle peut être utilisée pour minimiser le temps de calcul. De plus, ils expliquent les termes clés tels que « vrai positif » et « classe positive », qui sont importants pour comprendre la performance globale du modèle.
  
  
• 09:25:00 Dans cette section, l'orateur explique les concepts de vrai positif, faux positif, vrai négatif et faux négatif, et comment ils sont utilisés pour créer une matrice de confusion, qui montre le nombre d'instances correctement classées pour positif et classes négatives dans un modèle. L'orateur discute également de la précision et du rappel, qui répondent à différentes questions sur l'exactitude des prédictions positives et leurs occurrences réelles. L'orateur démontre l'utilisation de la régression logistique et des classificateurs de vecteurs de support avec un réglage fin approfondi, ainsi que des classificateurs d'arbre de décision, en utilisant la recherche aléatoire pour l'optimisation des paramètres. Les scores de formation et de test pour chaque classificateur sont également présentés.
  
  
• 09:30:00 Dans cette section de la vidéo, l'instructeur explique comment créer un système de détection de spam et de jambon à l'aide d'un ensemble de données téléchargé à partir du référentiel UCI. Les données sont sous forme de tableau, et l'instructeur les lit et les sépare en fonction d'un onglet, avec les en-têtes définis sur aucun et les colonnes intitulées 'étiquette' et 'messages'. L'objectif est de classer les messages comme spam ou non spam (ham), et l'instructeur parcourt le processus de réglage fin de différents modèles (tels qu'un classificateur de forêt aléatoire et un classificateur XGBoost) pour y parvenir. L'instructeur souligne également l'importance de la sélection des fonctionnalités et montre comment enregistrer le modèle XGBoost pour une utilisation future. Dans l'ensemble, il s'agit d'un projet intéressant qui démontre comment l'apprentissage automatique peut être utilisé pour résoudre des problèmes du monde réel.
  
  
• 09:35:00 Dans cette section de la vidéo, le présentateur passe par le processus d'exploration et d'analyse d'un ensemble de données de messages texte qui ont été téléchargés à partir d'un référentiel UCI. L'objectif est de créer un modèle d'apprentissage automatique capable de faire la différence entre les messages indésirables et les messages non indésirables. Le présentateur explique que les données textuelles doivent être converties en nombres pour que le modèle fonctionne, et ils montrent comment utiliser un vectoriseur de texte pour cela. Ils explorent ensuite la distribution des classes, notant que l'ensemble de données est déséquilibré avec plus de messages non spam que de messages spam. Enfin, ils expliquent l'importance de nettoyer les données textuelles, car des différences mineures d'orthographe ou de capitalisation peuvent entraîner des classifications incorrectes.
  
  
• 09:40:00 Dans cette section, l'instructeur explique le processus de prétraitement du texte, qui consiste à convertir tout le texte en minuscules, à remplacer certains caractères comme 0 et 3 par des équivalents textuels significatifs et à supprimer les caractères inutiles. L'instructeur suggère également d'explorer la radicalisation et la lemmatisation pour une réduction significative des mots dans le texte. Un exemple est donné en utilisant lambda pour appliquer un prétraitement de texte à chaque message, qui est ensuite stocké dans une nouvelle colonne appelée "texte traité".
  
  
• 09:45:00 Dans cette section, l'orateur parle du prétraitement du texte et de l'application de la radicalisation à l'aide du stemmer Porter pour réduire l'inflexion dans les mots. L'orateur mentionne également l'ingénierie des fonctionnalités, où la main est codée à zéro et étendue à un en appelant la méthode de la carte. L'ensemble d'apprentissage est ensuite converti en incorporations de mots, qui convertissent les mots en nombres à l'aide de techniques telles que le vecteur de comptage, le vecteur tf-idf et le sac de mots. Le texte est converti en une matrice creuse avec des éléments stockés, qui est ensuite utilisée dans l'algorithme Naive Bayes pour la classification. Enfin, l'orateur donne un exemple de la façon de tester un nouveau texte en appelant le compteur de vecteurs et le modèle pour déterminer s'il s'agit de spam ou non.
  
  
• 09:50:00 Dans cette section de la vidéo, l'orateur montre comment créer un système de base de détection de spam et de jambon à l'aide de techniques de traitement du langage naturel (NLP), telles que la transformation vectorielle par comptage et la prédiction de Naive Bayes. Le système prend les messages en entrée, les prétraite et prédit s'il s'agit de spam ou non. L'orateur souligne qu'il ne s'agit que d'un exemple de la façon de travailler avec des données en PNL et qu'il existe diverses autres techniques qui peuvent être utilisées. L'orateur conclut le cours et félicite les téléspectateurs de l'avoir terminé.

[MetaQuotes]

Apprentissage automatique pour tous - Cours complet

Apprentissage automatique pour tous - Cours complet

00:00:00 - 01:00:00 Cette partie de la vidéo aborde les bases de l'apprentissage automatique, y compris l'apprentissage supervisé et non supervisé. Il couvre également les différents modèles disponibles et comment les utiliser. Enfin, il explique comment mesurer les performances d'un modèle d'apprentissage automatique.

01:00:00 - 02:00:00 Cette partie explique comment utiliser l'apprentissage automatique pour prédire les résultats des événements. Il traite de la régression linéaire, de la régression logistique et des machines à vecteurs de support. Il explique également comment utiliser une grille de recherche pour former un modèle d'apprentissage automatique.

02:00:00 - 03:00:00 Cette partie couvre les bases de l'apprentissage automatique, y compris la régression linéaire et la rétropropagation. Il explique comment normaliser les données et ajuster un modèle de régression linéaire à l'aide de la bibliothèque TensorFlow.

03:00:00 - 03:50:00 Cette vidéo présente les concepts de l'apprentissage automatique, y compris l'apprentissage supervisé et non supervisé. Il montre comment utiliser une régression linéaire et un réseau de neurones pour faire des prédictions. Le présentateur explique également comment utiliser l'apprentissage automatique pour regrouper les données.

Partie 1

• 00:00:00 Dans cette vidéo, Kylie Ying explique les modèles d'apprentissage supervisés et non supervisés, leur fonctionnement et comment les programmer sur Google Colab.
  
  
• 00: 05: 00 Ce résumé en 1 paragraphe explique l'apprentissage supervisé, qui est un type d'apprentissage automatique où l'ordinateur reçoit un ensemble d'entrées et est invité à prédire l'étiquette d'une entrée donnée.
  
  
• 00:10:00 L'apprentissage supervisé est le processus d'attribution d'une étiquette aux données d'entrée afin de former un modèle d'apprentissage automatique. Le modèle produira alors une prédiction pour l'entrée donnée. L'apprentissage non supervisé est le processus d'utilisation de données non étiquetées pour en savoir plus sur les modèles de données. Dans l'apprentissage par renforcement, un agent est formé dans un environnement interactif basé sur des récompenses et des pénalités.
  
  
• 00:15:00 Cette vidéo traite de l'apprentissage automatique, de ses diverses applications et des différents types de données qu'il peut traiter. Il couvre également l'apprentissage supervisé et non supervisé et la régression.
  
  
• 00:20:00 Dans cette vidéo, l'instructeur explique comment fonctionne l'apprentissage automatique et comment l'utiliser pour prédire les résultats dans un ensemble de données. L'instructeur explique également comment ajuster la précision d'un modèle d'apprentissage automatique après la formation.
  
  
• 00:25:00 Cette vidéo traite du concept de perte et de son impact sur les performances d'un modèle d'apprentissage automatique. La perte est une mesure de la distance entre une prédiction d'un modèle d'apprentissage automatique et l'étiquette réelle donnée dans un ensemble de données donné. Il existe différentes fonctions de perte disponibles, chacune avec ses propres avantages et inconvénients. Enfin, la vidéo explique comment calculer et vérifier les performances d'un modèle d'apprentissage automatique.
  
  
• 00:30:00 La vidéo explique comment utiliser l'apprentissage automatique pour prédire les étiquettes de classe à partir d'un ensemble de données. L'ensemble de données comprend 10 entités, chacune correspondant à une classe. Les histogrammes sont utilisés pour comparer visuellement les distributions des caractéristiques entre les classes. La vidéo se termine par une discussion sur la façon dont les données pourraient être améliorées.
  
  
• 00:35:00 Dans cette vidéo, l'instructeur explique comment utiliser les techniques d'apprentissage automatique pour créer un ensemble de formation, de validation et de test. L'instructeur montre comment mettre à l'échelle un ensemble de données pour rendre les valeurs plus comparables, puis crée une fonction pour transformer les valeurs x. Enfin, l'instructeur crée un tableau numpy 2d et appelle la fonction hstack pour empiler les tableaux côte à côte.
  
  
• 00:40:00 Dans cette vidéo, l'instructeur présente les différents modèles d'apprentissage automatique disponibles et comment les utiliser dans le code. Parmi les modèles discutés figurent les k plus proches voisins, la régression linéaire et un réseau de neurones.
  
  
• 00:45:00 Dans cette vidéo, l'instructeur Alan Siegel passe en revue les bases de l'apprentissage automatique, y compris l'utilisation d'une fonction de distance et l'utilisation d'algorithmes de voisinage le plus proche. Il explique que, dans la classification binaire, l'algorithme du plus proche voisin utilisera une valeur "k" pour déterminer quel point est l'étiquette "plus" ou "moins". Il montre comment cela peut être appliqué à un ensemble de données sur la possession d'une voiture et la procréation, démontrant comment l'algorithme du plus proche voisin peut déterminer quel point est l'étiquette "plus" ou "moins" pour un point de données donné.
  
  
• 00:50:00 Cette vidéo explique comment utiliser l'apprentissage automatique pour prédire l'emplacement d'un point. La vidéo explique comment utiliser un algorithme des k plus proches voisins pour trouver le point le plus proche. La vidéo explique également comment utiliser un rapport de classification pour déterminer la classification du point.
  
  
• 00:55:00 Dans cette vidéo, un modèle d'apprentissage automatique est expliqué. Le modèle a une précision de 82 %, une précision de 77 % et un rappel de 89 %. Le modèle est décrit comme naïf bayes, qui est un simple modèle d'apprentissage automatique.

Partie 2

• 01:00:00 La règle de Bayes est une formule mathématique utilisée pour calculer la probabilité d'événements étant donné que d'autres événements se sont déjà produits. Dans cet exemple, la règle de Bayes est utilisée pour calculer la probabilité d'une maladie en cas de test positif.
  
  
• 01:05:00 Cette vidéo couvre les bases de l'apprentissage automatique, en mettant l'accent sur l'inférence bayésienne. Le présentateur montre comment appliquer l'inférence bayésienne aux problèmes de classification et discute des diverses distributions de probabilité impliquées.
  
  
• 01:10:00 Dans cette vidéo, une règle pour les baies naïves est expliquée, et il est montré que la probabilité d'un événement particulier, étant donné un ensemble de données, est proportionnelle à la somme des probabilités des événements individuels.
  
  
• 01:15:00 Cette vidéo explique comment l'apprentissage automatique peut être utilisé pour prédire les résultats d'événements, comme s'il va pleuvoir ou non pendant un match de football, ou quel jour on est. La vidéo aborde ensuite la régression logistique, qui est une technique d'apprentissage automatique plus avancée. La vidéo montre comment la ligne de régression peut être utilisée pour prédire la probabilité de différents résultats. La vidéo se termine par une démonstration de la façon dont la régression logistique peut être utilisée pour prédire si un élève réussira ou non un test particulier.
  
  
• 01:20:00 Dans cette vidéo, l'instructeur explique comment utiliser la régression linéaire pour estimer la probabilité qu'un classificateur soit correct. Pour ce faire, ils doivent d'abord réécrire l'équation comme p est égal à mx plus b. Cette équation peut prendre une plage allant de l'infini négatif à l'infini, mais doit rester entre zéro et un. Pour résoudre p, ils suppriment le logarithme des cotes, ce qui leur donne p sur un moins la probabilité.
  
  
• 01:25:00 Dans cette vidéo, le présentateur aborde trois types de modèles d'apprentissage automatique : la régression linéaire, la régression logistique et les machines à vecteurs de support. Le présentateur montre comment utiliser chaque modèle et donne des exemples de la façon dont chacun pourrait être utilisé.
  
  
• 01:30:00 Dans cette vidéo, l'instructeur explique le fonctionnement de l'apprentissage automatique et les différents types d'algorithmes disponibles. Il explique également comment maximiser les marges d'une machine à vecteurs de support (SVM) à l'aide de points de données situés sur les lignes de marge.
  
  
• 01:35:00 Dans cette vidéo, l'auteur présente différents modèles d'apprentissage automatique, notamment les machines à vecteurs de support (SVM), les réseaux de neurones et la régression logistique. Il montre que les SVM sont les plus précises des trois et que les réseaux de neurones peuvent être encore plus précis que les SVM.
  
  
• 01:40:00 Dans l'apprentissage automatique, un neurone est une unité de base de représentation dans un réseau de neurones. Les caractéristiques d'entrée d'un neurone sont multipliées par un poids, et la somme de toutes ces entrées multipliées est ensuite entrée dans le neurone. La fonction d'activation du neurone modifie l'état linéaire de ses entrées en fonction de l'erreur associée à ses prédictions. L'algorithme de descente de gradient est utilisé pour suivre la pente de la fonction quadratique vers une erreur plus faible.
  
  
• 01:45:00 Dans cette vidéo, l'instructeur explique comment fonctionne l'apprentissage automatique et comment programmer un réseau de neurones à l'aide de TensorFlow. Il montre ensuite comment créer un réseau neuronal séquentiel et comment calculer la perte par rapport à un poids.
  
  
• 01:50:00 Dans cette vidéo, le présentateur montre comment utiliser des algorithmes d'apprentissage automatique avec TensorFlow. Tout d'abord, ils importent TensorFlow et créent un modèle de réseau neuronal. Ensuite, ils définissent l'activation des couches et configurent les mesures de perte et de précision. Enfin, ils forment le modèle en utilisant une formation de 100 époques et une répartition de validation de 32 époques.
  
  
• 01:55:00 Dans cette vidéo, l'auteur explique comment entraîner un modèle d'apprentissage automatique à l'aide d'une recherche par grille. Il discute également de l'importance des hyperparamètres et de la manière de les définir.

Partie 3

• 02:00:00 Ce didacticiel vidéo montre comment utiliser l'apprentissage automatique pour la prédiction et la classification. La vidéo couvre les bases de la formation d'un modèle d'apprentissage automatique, de l'enregistrement de l'historique du modèle et du traçage des performances du modèle.
  
  
• 02:05:00 Cette vidéo montre comment créer un modèle de moindre perte pour un réseau de neurones à l'aide d'une technique appelée casting. Le modèle fonctionne de la même manière qu'un modèle utilisant une SVM, et la vidéo montre également comment créer un rapport de classification à l'aide de la sortie du réseau.
  
  
• 02:10:00 Dans cette vidéo, l'auteur explique la régression linéaire et comment calculer le résidu. Le résidu est la distance entre la prédiction et le point de données réel, et est utilisé pour déterminer la droite de meilleur ajustement pour la droite de régression.
  
  
• 02:15:00 La vidéo aborde les concepts de linéarité et d'indépendance et montre comment ces hypothèses peuvent être violées dans des ensembles de données non linéaires. Il aborde ensuite les hypothèses de normalité et d'homoscédasticité, et la manière dont celles-ci peuvent être évaluées à l'aide de parcelles résiduelles.
  
  
• 02:20:00 La mesure de l'erreur absolue moyenne nous indique en moyenne à quel point nos prédictions sont éloignées des valeurs réelles de notre ensemble d'apprentissage.
  
  
• 02:25:00 L'erreur quadratique moyenne (MSE) est une mesure de la performance d'une prédiction et est étroitement liée à l'erreur absolue moyenne. La RMSE est calculée en prenant la somme de tous les carrés des résidus et est utilisée pour mesurer la performance d'une prédiction par rapport à sa valeur attendue.
  
  
• 02:30:00 Ce cours vidéo d'une heure couvre les bases de l'apprentissage automatique, y compris la régression linéaire. Le cours couvre le sujet des résidus et comment les utiliser pour déterminer la meilleure ligne d'ajustement pour un ensemble de données.
  
  
• 02:35:00 Cette vidéo présente le concept d'apprentissage automatique et explique comment utiliser diverses bibliothèques et ensembles de données. Il explique ensuite comment utiliser un bloc de données pour représenter les données et comment analyser les données.
  
  
• 02:40:00 La vidéo explique comment utiliser l'apprentissage automatique pour prédire le nombre de vélos à différents moments de la journée. Il montre comment créer un ensemble d'entraînement, de validation et de test, et comment utiliser la fonction numpy.split pour diviser la trame de données en différents groupes.
  
  
• 02:45:00 La vidéo explique comment l'apprentissage automatique peut être utilisé pour résoudre des problèmes. L'instructeur fournit un exemple d'utilisation de l'apprentissage automatique pour prédire la température et fournit des informations sur la façon de calculer les coefficients de régression et de noter le modèle.
  
  
• 02:50:00 Dans cette vidéo, le créateur montre comment utiliser l'apprentissage automatique pour améliorer les performances d'un modèle de régression linéaire sur un nouvel ensemble de données.
  
  
• 02:55:00 Dans cette vidéo, le présentateur explique comment créer un modèle de régression linéaire en Python à l'aide de la bibliothèque TensorFlow. Ils expliquent qu'il est utile de normaliser les données avant de former le modèle, puis d'ajuster le modèle à l'aide de la rétropropagation. Ils montrent comment tracer la perte du modèle au fil du temps et comment le modèle a convergé vers un bon ajustement.

Partie 4

• 03:00:00 Cette vidéo explique les concepts d'apprentissage automatique d'une manière accessible à tous. L'instructeur montre comment utiliser un réseau de neurones pour prédire des valeurs à partir d'un ensemble de données et montre l'effet de la modification de divers paramètres.
  
  
• 03:05:00 Cette vidéo couvre les bases de l'apprentissage automatique, y compris l'historique de la régression linéaire et l'utilisation d'un réseau de neurones. Le présentateur montre ensuite comment calculer l'erreur quadratique moyenne pour une régression linéaire et un réseau de neurones, et compare les résultats.
  
  
• 03:10:00 Dans cette vidéo, l'instructeur explique le fonctionnement de l'apprentissage supervisé et non supervisé. Il explique comment une régression linéaire et un réseau de neurones peuvent être utilisés pour faire des prédictions.
  
  
• 03:15:00 Dans cette vidéo, le présentateur explique comment utiliser l'apprentissage automatique pour diviser les données en trois groupes. Ils utilisent ensuite ces informations pour calculer de nouveaux centroïdes et créer de nouveaux clusters.
  
  
• 03:20:00 Cette vidéo traite de deux types d'apprentissage automatique : l'apprentissage non supervisé, qui recherche des modèles dans les données, et l'apprentissage supervisé, qui utilise un ensemble d'entraînement pour apprendre à prédire les résultats futurs. Les techniques d'apprentissage non supervisé comprennent la maximisation des attentes et l'analyse des composantes principales, qui réduisent la dimensionnalité en trouvant les composantes principales des données. Les techniques d'apprentissage supervisé comprennent la régression linéaire et l'inférence bayésienne.
  
  
• 03:25:00 L'apprentissage automatique est un domaine d'analyse de données qui aide à faire des prédictions sur des données inconnues. Dans ce cours, l'instructeur explique comment utiliser l'analyse en composantes principales (ACP) pour réduire la dimensionnalité d'un ensemble de données. Cela permet une visualisation et une discrimination plus faciles des points de données.
  
  
• 03:30:00 Dans cette vidéo, le présentateur présente le concept de régression linéaire et son application aux données bidimensionnelles (2D). Ensuite, ils introduisent le concept d'analyse en composantes principales (ACP), qui est une technique utilisée pour réduire un ensemble de données à ses dimensions les plus pertinentes. Enfin, ils discutent de l'utilisation de l'apprentissage non supervisé dans l'apprentissage automatique.
  
  
• 03:35:00 Cette vidéo explique comment utiliser l'apprentissage automatique pour la classification à l'aide de l'apprentissage non supervisé. Le présentateur montre comment utiliser les pandas pour importer des données, puis trace les données les unes par rapport aux autres pour voir les résultats. Ils concluent en discutant de l'apparence de certaines données et suggèrent que le regroupement pourrait être amélioré en utilisant un classificateur différent.
  
  
• 03:40:00 La vidéo enseigne comment utiliser des algorithmes d'apprentissage automatique pour regrouper des données.
  
  
• 03:45:00 Dans cette vidéo, un expert en apprentissage automatique explique comment appliquer diverses techniques d'apprentissage automatique pour résoudre des problèmes spécifiques. La vidéo couvre également l'analyse par grappes et l'ACP.
  
  
• 03:50:00 Cette vidéo explique l'apprentissage automatique et ses différentes étapes, y compris l'apprentissage non supervisé. Il explique également comment effectuer un clustering à l'aide de k-means. La vidéo se termine par une discussion sur l'apprentissage supervisé et ses différentes étapes, y compris la classification et la régression.

[MetaQuotes]

Cours intensif sur TensorFlow 2.0

Cours intensif sur TensorFlow 2.0

La vidéo "TensorFlow 2.0 Crash Course" couvre les bases des réseaux de neurones et leur architecture, avec un focus sur la classification des images. L'instructeur utilise un jeu de serpent et un ensemble de données de fashion mnist comme exemples pour former le réseau neuronal à travers le processus d'ajustement des poids et des biais en fonction des fonctions de perte. La vidéo montre l'importance du prétraitement des données et de l'utilisation de fonctions d'activation, telles que sigmoïde et ReLU, pour créer des modèles plus complexes. L'orateur insiste également sur l'importance des données de test et de formation et montre comment charger et modifier les données d'image pour le modèle. Enfin, le présentateur montre comment définir l'architecture d'un modèle dans Keras, l'entraîner à l'aide de méthodes de compilation et d'ajustement, et faire des prédictions sur des images spécifiques à l'aide de "model.predict".

La deuxième partie du didacticiel vidéo couvre divers aspects de la création d'un réseau neuronal de base capable de classer les articles de mode et d'effectuer une analyse des sentiments sur les critiques de films. En commençant par le chargement et la préparation des données pour la formation, le didacticiel explique ensuite l'importance du prétraitement des données et de la normalisation des longueurs des séquences d'entrée. Le didacticiel couvre ensuite la création d'une architecture de modèle appropriée, y compris l'utilisation de différentes couches telles que l'intégration et les couches denses. Enfin, le didacticiel explique comment affiner les hyperparamètres, valider le modèle, enregistrer et charger des modèles et évaluer les performances du modèle sur des données externes. Dans l'ensemble, le didacticiel fournit une structure essentielle sur laquelle acquérir des connaissances plus avancées sur les réseaux de neurones. Il couvre également différents sujets liés à TensorFlow 2.0, y compris l'encodage des données pour le modèle, l'exécution d'un modèle enregistré pour la prédiction et l'installation de la version GPU de TensorFlow 2.0 sur Ubuntu Linux. Dans la section d'encodage, le présentateur parcourt le processus de découpage et de nettoyage des données pour garantir un mappage de mots approprié et crée une fonction de recherche pour encoder les données à des fins de prédiction. Ils démontrent ensuite l'importance de préparer les données d'entrée dans le bon format pour le modèle à traiter, avant de passer à un tutoriel sur l'installation de la version GPU de TensorFlow 2.0 sur un système Linux, conseillant au public d'être patient en raison de la taille des téléchargements impliqués. .

• 00:00:00 Dans cette section, l'instructeur présente le concept de réseaux de neurones et leur fonctionnement. Les réseaux neuronaux sont composés de couches interconnectées de neurones, similaires au fonctionnement des neurones de notre cerveau. Ces neurones peuvent s'activer ou non, et les connexions entre eux déterminent quand ils s'activent et quels autres neurones ils peuvent déclencher. Un réseau neuronal fonctionne en prenant l'entrée d'une couche de neurones et en la faisant passer à travers une ou plusieurs couches cachées avant de produire la sortie de la couche finale. L'architecture d'un réseau de neurones peut varier en fonction du type de problème qu'il est utilisé pour résoudre, mais une approche courante consiste à utiliser un réseau de neurones entièrement connecté où chaque neurone d'une couche est connecté à chaque neurone de la couche suivante. L'instructeur insiste sur l'importance de comprendre les mathématiques derrière les réseaux de neurones pour pouvoir en créer des réussis et complexes.
  
  
• 00:05:00 Dans cette section, l'instructeur explique les bases des réseaux de neurones et leur fonctionnement pour résoudre un problème. Il construit un réseau neuronal simple utilisant quatre entrées et une sortie qui est entraîné pour maintenir un serpent en vie dans un jeu. L'entrée indique s'il y a un obstacle devant, à gauche et à droite du serpent, et la direction de mouvement recommandée qui a trois valeurs différentes : -1 pour gauche, 0 pour droit et 1 pour droite. Lorsqu'il reçoit une entrée, le réseau de neurones donne en sortie un 0 ou un 1, indiquant si oui ou non la direction recommandée doit être suivie. Il est conçu pour suivre la direction recommandée s'il peut maintenir le serpent en vie, sinon il ne la suivra pas.
  
  
• 00:10:00 Dans cette section, l'orateur discute de l'architecture des réseaux de neurones et de leur fonctionnement. Les couches d'entrée et de sortie sont connectées par des poids, et la sortie est déterminée en prenant la somme pondérée des valeurs multipliée par ces poids, avec une valeur de biais également incluse. Le réseau est ensuite formé en saisissant une grande quantité de données et en ajustant les biais et les pondérations afin de produire des sorties précises. Si la sortie est correcte, aucun ajustement n'est effectué, mais si elle est incorrecte, le réseau ajuste les pondérations et les biais pour améliorer la précision.
  
  
• 00: 15: 00 Dans cette section, l'instructeur explique le processus de formation d'un réseau de neurones, dans lequel les informations sont transmises à travers le réseau afin qu'il puisse ajuster les poids et les biais pour obtenir des réponses plus correctes. Le réseau commence par des pondérations et des biais aléatoires et les ajuste de manière itérative jusqu'à ce qu'il atteigne un haut niveau de précision. Des fonctions d'activation, des fonctions non linéaires qui ajoutent de la complexité au réseau, sont ensuite introduites. La fonction d'activation sigmoïde en particulier est décrite comme mappant toute valeur d'entrée entre moins un et un, permettant des sorties dans une certaine plage. Cela introduit plus de complexité et de richesse dans le réseau.
  
  
• 00:20:00 Dans cette section, le conférencier discute des fonctions d'activation et de leur rôle dans les réseaux de neurones. Ces fonctions permettent une plus grande complexité dans le modèle en activant des fonctions non linéaires, qui se rapprochent mieux des données du monde réel. Sigmoïde est l'une des fonctions d'activation de base qui transforme la sortie en une plage de 0 à 1. Une fonction plus récemment utilisée est l'unité linéaire rectifiée (ReLU), qui définit les valeurs négatives sur 0 et rend les valeurs positives plus positives, gardant ainsi les données points dans une plage de 0 à l'infini positif. Le conférencier explique également que les fonctions de perte sont essentielles pour comprendre comment les poids et les biais des modèles doivent être ajustés. Ils calculent l'erreur entre la sortie prévue et la sortie réelle, permettant un réglage et un ajustement plus efficaces.
  
  
• 00:25:00 Dans cette section, le conférencier explique le concept de réseaux neuronaux et comment les couches cachées peuvent être utilisées pour créer des modèles plus complexes qui peuvent résoudre des problèmes difficiles. La vidéo met également l'accent sur l'importance des données et sur la façon dont elles doivent être prétraitées et mises sous la bonne forme avant d'être envoyées à une baie. L'orateur travaille à partir du didacticiel 2.0 de TensorFlow, mais ajoute des informations supplémentaires qui peuvent être déroutantes pour les nouveaux utilisateurs de réseaux de neurones. Le didacticiel utilise le jeu de données fashion mnist, qui contient des images de vêtements, comme exemple de classification d'images. La vidéo se termine en montrant aux téléspectateurs comment installer TensorFlow 2.0 et matplotlib.
  
  
• 00:30:00 Dans cette section, la vidéo couvre les packages nécessaires à installer tels que tensorflow, keras, numpy et matplotlib pour représenter graphiquement et afficher des images. La vidéo explique également la différence entre les données de test et de formation, où environ 90 à 80 % des données sont transmises au réseau pour le former, et les données restantes sont utilisées pour tester la précision et s'assurer que le réseau ne se contente pas de mémoriser le données. La vidéo utilise Keras pour diviser l'ensemble de données en données d'entraînement et de test avec des étiquettes. Enfin, la vidéo donne un aperçu de la représentation des étiquettes, chaque image ayant une étiquette spécifique qui lui est attribuée entre 0 et 9.
  
  
• 00:35:00 Dans cette section, l'instructeur montre comment charger et modifier les données d'image pour le modèle TensorFlow 2.0. Il crée une liste de noms d'étiquettes, indiquant ce que chaque numéro d'étiquette représente. Il utilise ensuite la librairie Matplotlib pour afficher les images et explique qu'il s'agit de tableaux de 28x28 pixels. Les valeurs de pixel sont divisées par 255 pour réduire la taille des données, ce qui facilite leur utilisation dans le modèle. Les données modifiées, composées de valeurs décimales, sont chargées dans le modèle, qui prédira la classe, c'est-à-dire le numéro d'étiquette, entre 0 et 9. L'instructeur conclut en mentionnant qu'il démontrera la configuration, la formation et le test du modèle dans le section suivante.
  
  
• 00:40:00 Dans cette section du cours accéléré TensorFlow 2.0, l'intervenant explique l'architecture d'un réseau de neurones pour la classification d'images. L'entrée est un tableau de 28x28 pixels avec des valeurs en niveaux de gris, qui est aplati en une liste de 784 pixels pour alimenter la couche d'entrée du réseau neuronal. La couche de sortie comporte 10 neurones, chacun représentant l'une des 10 classes (0-9). Le but est que le neurone le plus activé représente la classe prédite. L'orateur couvre également les couches cachées, soulignant qu'un réseau à deux couches est possible mais pas idéal pour les tâches de reconnaissance d'images plus complexes.
  
  
• 00:45:00 Dans cette section du cours d'initiation à TensorFlow 2.0, l'instructeur explique le concept de couches cachées dans les réseaux de neurones. En ajoutant une couche cachée avec 128 neurones, le réseau peut analyser l'image et identifier des modèles qui peuvent aider à mieux reconnaître l'image. La sélection de 128 neurones est quelque peu arbitraire et le nombre de neurones pour une couche cachée dépend de l'application. L'instructeur procède ensuite à la définition de l'architecture ou des couches du modèle dans Keras. L'architecture comprend une couche d'entrée aplatie, deux couches denses ou entièrement connectées et une couche de sortie avec 10 neurones et une activation softmax pour donner la probabilité que le réseau reconnaisse une classe particulière.
  
  
• 00: 50: 00 Dans cette section, la vidéo explique le processus de configuration des paramètres d'un modèle et de sa formation à l'aide des méthodes "compile" et "fit" dans TensorFlow 2.0. Cela inclut la définition de l'optimiseur, de la fonction de perte et des métriques à utiliser dans le modèle compilé avant de définir le nombre d'époques pour la formation. La vidéo fournit également une explication simple de ce que sont les époques et comment elles influencent la précision du modèle. Après avoir exécuté le fichier, la précision du test du modèle est évaluée et s'avère être de 87, légèrement inférieure à la précision de la formation.
  
  
• 00:55:00 Dans cette section, le présentateur montre comment utiliser le modèle pour faire des prédictions sur des images spécifiques. Il explique que vous devez utiliser la méthode "model.predict" et transmettre une liste ou un tableau np qui inclut la forme d'entrée des images. La méthode vous donnera alors un groupe de prédictions, car elle s'attend à ce que vous transmettiez un tas de choses différentes et les prédit toutes à l'aide du modèle. La sortie est une série de listes différentes, chacune contenant les prédictions du modèle pour une image particulière. Le présentateur note que cette fonctionnalité est parfois négligée dans les vidéos didactiques, mais il est important de comprendre comment utiliser le modèle de manière pratique.

• 01:00:00 Dans cette section, l'orateur montre comment interpréter et valider les prédictions de réseau à l'aide de la fonction np.argmax() qui trouve l'index du nombre le plus élevé dans une liste. Ils prennent la valeur de cette fonction et la transmettent aux noms de classe pour obtenir le nom réel de la classe prédite. L'orateur poursuit en mettant en place une boucle for de base pour afficher plusieurs images à partir des images de test et montre la prédiction correspondante pour chacune d'entre elles. Ils montrent comment cela peut être utilisé pour valider que le modèle prédit avec précision et que la prédiction a du sens par rapport à l'image d'entrée affichée. Enfin, l'orateur note une solution rapide à une erreur qu'il a rencontrée.
  
  
• 01:05:00 Dans cette section, le didacticiel vidéo montre comment créer un modèle simple capable de classer des articles de mode, comme une chemise ou un t-shirt, à l'aide de TensorFlow 2.0. Le didacticiel décrit le processus de prédiction pour plusieurs images et explique comment prédire pour une image. Le modèle est basé sur un problème de classification simple et est conçu pour fournir une vue d'ensemble des réseaux de neurones de base. Dans les prochaines vidéos, le contenu deviendra plus avancé et couvrira les problèmes avec des données réelles. Bien que les données utilisées dans ce didacticiel soient simples, le chargement et le prétraitement de grands ensembles de données peuvent être difficiles, et des ajustements seront nécessaires pour les rendre utilisables. Cependant, le didacticiel fournit une structure facile à suivre, offrant une base solide sur laquelle acquérir des connaissances sur les réseaux de neurones.
  
  
• 01:10:00 Dans cette section, l'auteur du didacticiel explique comment charger des données et les préparer pour la formation en les divisant en ensembles de formation et de test. Ils introduisent le concept de mots codés en nombres entiers et comment ils représentent les critiques de films. L'auteur explique ensuite que ces nombres correspondent à certains mots et montre comment faire correspondre ces nombres entiers à leurs mots respectifs. Ils démontrent également la création d'un index de mots qui attribue un entier unique à chaque mot de l'ensemble de données. Enfin, ils ajoutent des clés spéciales à l'index de mots et expliquent comment elles seront utilisées dans les parties ultérieures du didacticiel.
  
  
• 01:15:00 Dans cette section, l'orateur explique le processus d'attribution de valeurs pour les mots de remplissage, de début, inconnus et inutilisés à leurs clés respectives dans l'ensemble de données d'apprentissage et de test. Ils ajoutent une balise de remplissage pour que tous les ensembles de critiques de films aient la même longueur en ajoutant des mots de remplissage à la fin d'une liste pour que la critique de film entière ait la même taille. Pour créer un dictionnaire qui permet aux nombres entiers de pointer vers un mot au lieu de l'inverse, la liste d'index de mots inversés est utilisée pour inverser les valeurs dans les clés pour y parvenir. Enfin, l'orateur explique la fonction de décodage des données d'apprentissage et de test en mots lisibles par l'homme à l'aide d'une chaîne vierge jointe et d'un index de mots inversé.
  
  
• 01:20:00 Dans cette section, le tuteur explique comment normaliser ou définir une longueur définie pour toutes les révisions en utilisant des balises de remplissage pour identifier la longueur des révisions. Le tuteur explique qu'il est impossible de déterminer la longueur des neurones d'entrée car l'ensemble de données peut être de longueurs différentes, donc une balise de remplissage est utilisée pour résoudre cette limitation. Le tuteur montre comment utiliser les fonctions Tensorflow telles que le prétraitement et la séquence pour remplir des séquences à une longueur spécifique ou normaliser toutes les séquences à une longueur définie par l'utilisateur. Enfin, le tuteur fournit un récapitulatif de l'ensemble de la section et met en évidence les différents mécanismes utilisés pour charger, encoder, décoder et pré-traiter les données.
  
  
• 01:25:00 Dans cette section, l'instructeur vidéo poursuit le prétraitement des données et les finalise pour qu'elles soient sous une forme cohérente pouvant être acceptée par le modèle. Après vérification de la cohérence des données, la vidéo passe à la définition de l'architecture du modèle. L'instructeur explique l'utilisation de différentes couches telles que l'intégration, la mise en commun des moyennes globales 1D et les couches denses avec différentes fonctions d'activation. Ils discutent également de la façon dont la sortie du modèle sera un seul neurone avec une valeur comprise entre 0 et 1, indiquant la probabilité que l'examen soit positif ou négatif. La vidéo se termine par une discussion sur l'importance des incorporations de mots et sur la manière dont elles aident à comprendre l'architecture du modèle.
  
  
• 01:30:00 Dans cette section, l'orateur discute du concept de vecteurs de mots et de la manière dont la couche d'intégration peut aider à regrouper des mots ayant des significations similaires. La couche d'intégration génère des vecteurs de mots, qui sont essentiellement des coefficients dans un espace à 16 dimensions, pour chaque mot ou terme codé en entier dans les données d'entrée. Initialement, la couche crée 10 000 vecteurs de mots pour chaque terme et les regroupe de manière aléatoire. La couche détermine ensuite la similitude entre les vecteurs en regardant l'angle entre eux et essaie de regrouper les mots similaires plus près les uns des autres. Ce processus aide l'ordinateur à comprendre le sens et le contexte des mots, ce qui est essentiel pour une classification précise des critiques de films comme positives ou négatives.
  
  
• 01:35:00 Dans cette section, la vidéo explique comment la couche d'intégration dans un réseau de neurones est utilisée pour regrouper des mots similaires en fonction de leur contexte, plutôt que simplement de leur contenu. En regardant les mots autour d'un mot particulier, le réseau de neurones peut déterminer quels mots sont liés les uns aux autres et les regrouper dans la couche d'intégration. La sortie de cette couche est ensuite réduite à l'aide d'une couche de regroupement de moyenne globale, qui place les données dans une dimension inférieure pour faciliter le calcul et la formation du réseau. La vidéo fournit un schéma de l'apparence du réseau après le passage des données d'entrée à travers la couche d'intégration et les couches suivantes du réseau de neurones.
  
  
• 01:40:00 Dans cette section, la vidéo couvre la création d'une couche dense pour la reconnaissance de formes dans un réseau de neurones utilisé pour l'analyse des sentiments. Le réseau neuronal prend des vecteurs de mots représentant différents mots, les calcule en moyenne et les transmet à la couche dense de 16 neurones. La couche dense recherche des modèles de mots et tente de classer les avis positifs ou négatifs à l'aide de la fonction sigmoïde pour générer une valeur comprise entre 0 et 1. Le modèle est ensuite compilé avec un optimiseur, une fonction de perte et une entropie croisée binaire pour calculer le différence entre les valeurs prévues et réelles. Les données sont divisées en ensembles de validation et d'apprentissage pour mesurer avec précision les performances du modèle sur de nouvelles données lors des tests.
  
  
• 01:45:00 Dans cette section, le présentateur modifie les données de test pour en faire des données de validation, qui sont un sous-ensemble des données de formation qui seront utilisées pour valider le modèle. Il explique que les hyperparamètres sont importants dans l'apprentissage automatique et les réseaux de neurones et que les utilisateurs doivent affiner les paramètres individuels pour obtenir des résultats précis. Il explique également le concept de taille de lot, qui spécifie le nombre de critiques de films qui seront chargées à la fois, et le définit sur 512. Enfin, il adapte le modèle aux données et l'évalue sur les données de test, ce qui montre une précision de 87 %. Le présentateur insiste sur l'importance des données de validation et explique que parfois un modèle peut être moins précis sur de nouvelles données.
  
  
• 01:50:00 Dans cette section de la vidéo, l'orateur explique comment enregistrer et charger des modèles dans TensorFlow pour éviter d'avoir à réentraîner le modèle à chaque fois qu'une prédiction est faite, ce qui peut être particulièrement gênant pour les modèles plus volumineux qui peuvent prendre des jours, des semaines, voire des mois pour s'entraîner. Après avoir augmenté la taille du vocabulaire du modèle, l'orateur montre comment enregistrer le modèle à l'aide de la fonction "model.save()" et lui donne un nom avec une extension ".h5", qui est l'extension utilisée pour les modèles enregistrés dans TensorFlow et Kéras. Dans les prochaines vidéos, l'orateur prévoit de discuter des modèles de points de contrôle et des modèles de chargement par lots avec différentes tailles de données.
  
  
• 01:55:00 Dans cette section, l'intervenant explique comment enregistrer et charger un modèle dans TensorFlow 2.0. Le modèle peut être enregistré dans des données binaires, ce qui permet de gagner du temps lors de la réalisation de prédictions car le modèle n'a pas besoin d'être ré-entraîné à chaque fois. Pour charger le modèle, une seule ligne de code doit être ajoutée avec le nom du fichier. L'orateur montre ensuite comment tester le modèle sur des données externes en ouvrant un fichier texte dans le code et en prétraitant les données afin qu'elles puissent être introduites dans le modèle. Il est important de noter que la taille du fichier texte doit être au maximum de 250 mots pour correspondre aux données de formation. Le prétraitement comprend la suppression des caractères indésirables tels que les virgules et les crochets.

• 02:00:00 Dans cette section, le créateur de la vidéo explique le processus d'encodage et de réduction des données à 250 mots afin qu'elles puissent être utilisées dans le modèle de prédiction. Les symboles tels que les points, les guillemets et les crochets doivent être supprimés pour garantir des mappages de mots corrects. Une fonction est créée pour rechercher les mappages de tous les mots dans les données et renvoyer une liste codée. Une fois les données encodées, le modèle est utilisé pour faire une prédiction et le texte original, la révision encodée et la prédiction sont imprimés. Enfin, une fonction review_in_code est définie pour convertir les données de chaîne en une liste codée.
  
  
• 02:05:00 Dans cette section de la vidéo, le présentateur exécute le modèle enregistré et rencontre une erreur due à un problème d'encodage de code. Après avoir résolu le problème, le présentateur montre comment traduire l'examen dans un format que le réseau peut comprendre en utilisant un vocabulaire de 88 000 mots pour attribuer des indices correspondants à chaque mot de l'examen. La sortie qui en résulte identifie avec précision l'examen comme positif, soulignant l'importance de manipuler les données d'entrée pour s'assurer qu'elles sont sous la bonne forme pour que le réseau puisse les traiter. La vidéo passe ensuite à un didacticiel sur l'installation de la version GPU de TensorFlow 2.0 sur un système Ubuntu Linux, avec des instructions sur l'installation de CUDA et cuDNN pour l'accélération GPU.
  
  
• 02:10:00 Dans cette section, l'intervenant guide les téléspectateurs tout au long du processus d'installation de TensorFlow 2.0 sur leur ordinateur à l'aide de la version GPU. Ils fournissent un guide étape par étape pour installer les packages NVIDIA, y compris les pilotes appropriés, et le framework TensorFlow 2.0 lui-même. L'orateur note que, bien que le processus soit relativement simple, il peut prendre un certain temps en raison de la taille des téléchargements impliqués. Ils conseillent également aux téléspectateurs rencontrant des problèmes d'utilisation du GPU de désinstaller la version CPU de TensorFlow et de consulter la section des commentaires pour obtenir de l'aide.

[MetaQuotes]

Cours complet TensorFlow 2.0 - Tutoriel sur les réseaux de neurones Python pour débutants (parties 1 à 4)

Cours complet TensorFlow 2.0 - Tutoriel sur les réseaux de neurones Python pour débutants

00:00:00 - 01:00:00 Cette vidéo présente une introduction à TensorFlow 2.0, une bibliothèque pour la manipulation de données et l'apprentissage automatique. L'instructeur explique ce qu'est un tenseur et comment utiliser des tenseurs pour stocker des calculs partiellement définis. Il montre également comment utiliser les fonctions de classement de points TF et de remodelage de points TF pour contrôler le nombre de dimensions dans un tenseur.

01:00:00 - 02:00:00 Le didacticiel vidéo explique comment utiliser la régression linéaire pour prédire les valeurs d'un ensemble de données. L'ensemble de données Titanic est utilisé comme exemple. Le présentateur explique comment la régression linéaire est utilisée pour prédire les valeurs dans un ensemble de données et comment créer des colonnes de caractéristiques dans un ensemble de données à l'aide de TensorFlow.

02:00:00 - 03:00:00 Ce didacticiel vidéo couvre les bases de l'utilisation de Python pour les réseaux de neurones. La vidéo commence par une description de la façon dont un réseau de neurones est composé de couches de neurones interconnectés. La vidéo explique ensuite comment créer un générateur de nombres aléatoires et comment former un réseau de neurones. Enfin, la vidéo montre comment connecter des neurones et des poids, comment transmettre des informations à travers le réseau et comment calculer la valeur de sortie d'un neurone.

03:00:00 - 04:00:00 Cette vidéo explique comment utiliser TensorFlow pour créer un réseau neuronal convolutif pour la reconnaissance d'images. La vidéo couvre les bases des réseaux de neurones convolutifs, y compris leur fonctionnement et l'utilisation de modèles pré-formés.

04:00:00 - 05:00:00 Cette vidéo explique comment utiliser TensorFlow pour entraîner un modèle de machine learning capable de prédire la classe d'une image. La vidéo couvre des concepts de base tels que l'apprentissage en profondeur et les réseaux de neurones convolutifs.

05:00:00 - 06:00:00 Cette vidéo est un guide complet sur l'utilisation de TensorFlow 2.0 pour l'entraînement des réseaux de neurones. Il couvre les formes d'entrée et de sortie du réseau neuronal, comment créer une fonction de perte et comment utiliser le modèle pour prédire une séquence. La vidéo montre également comment générer du texte avec TensorFlow.

06:00:00 - 06:50:00 Ce didacticiel vidéo présente les bases de TensorFlow 2.0, une puissante bibliothèque de machine learning. Après avoir présenté TensorFlow et ses concepts clés, le didacticiel guide les spectateurs à travers une série de didacticiels sur différentes tâches d'apprentissage automatique telles que l'apprentissage en profondeur et l'apprentissage par renforcement.

Partie 1

• 00:00:00 Ce didacticiel vidéo enseigne aux débutants comment utiliser TensorFlow 2.0 pour les réseaux de neurones en Python. L'instructeur explique les différences entre l'intelligence artificielle, les réseaux de neurones et l'apprentissage automatique, et fournit des ressources pour le cours, y compris des exercices pratiques et des exemples de code.
  
  
• 00:05:00 L'apprentissage automatique est un sous-domaine de l'intelligence artificielle qui permet aux ordinateurs de générer eux-mêmes des règles, sans avoir à être explicitement programmés.
  
  
• 00:10:00 La vidéo explique les bases des réseaux de neurones et de l'apprentissage en profondeur, et comment ces systèmes fonctionnent en transformant les données à travers plusieurs couches. Les réseaux de neurones peuvent être utilisés pour une variété de tâches, y compris l'apprentissage automatique et l'intelligence artificielle. La vidéo fournit également un exemple d'ensemble de données sur les notes des élèves.
  
  
• 00:15:00 Cette vidéo traite de la différence entre l'intelligence artificielle, l'apprentissage automatique et les réseaux de neurones, puis aborde l'apprentissage supervisé.
  
  
• 00:20:00 L'apprentissage automatique non supervisé est utilisé lorsque nous n'avons aucune donnée d'entrée. Il est utilisé pour déterminer des groupes de points de données similaires.
  
  
• 00:25:00 Cette vidéo donne un aperçu de trois différents types d'apprentissage automatique : apprentissage supervisé, non supervisé et par renforcement. Le dernier type, l'apprentissage par renforcement, est expliqué plus en détail avec un exemple de jeu où un agent d'intelligence artificielle (IA) tente d'atteindre un objectif spécifique.
  
  
• 00:30:00 Dans cette vidéo, une introduction de base à TensorFlow est donnée, suivie d'une discussion sur le fonctionnement de la bibliothèque à un niveau inférieur. TensorFlow est ensuite abordé plus en détail, y compris les deux composants principaux : les graphiques et les sessions. Un graphe est une collection de calculs partiels liés les uns aux autres, et une session est un moyen d'exécuter une partie ou la totalité du graphe.
  
  
• 00:35:00 Dans cette vidéo, l'instructeur présente les bases de TensorFlow, y compris le concept de graphiques et de sessions. Il montre ensuite comment utiliser Google Collaboratory pour créer et exécuter des blocs de code, ainsi qu'importer et utiliser divers modules. Enfin, il aborde les avantages de l'utilisation de TensorFlow sur un ordinateur aux ressources limitées.
  
  
• 00:40:00 Dans cette vidéo, l'instructeur montre comment importer et utiliser TensorFlow 2.0 avec des réseaux de neurones Python. TensorFlow est une bibliothèque pour la manipulation de données et l'apprentissage automatique. TensorFlow 2.0 est une nouvelle version de la bibliothèque qui améliore les performances. L'instructeur explique également ce qu'est un tenseur et comment il généralise les vecteurs et les matrices.
  
  
• 00:45:00 TensorFlow 2.0 introduit des tenseurs, qui sont des objets importants qui stockent des calculs partiellement définis. Les tenseurs ont un type de données et une forme, et chaque tenseur a un rang et un degré. Pour déterminer le rang d'un tenseur, utilisez la méthode de classement des points TF.
  
  
• 00:50:00 Dans cette vidéo, l'auteur présente le concept de formes tensorielles et explique comment elles peuvent être utilisées pour identifier le nombre d'éléments dans un tenseur. Il introduit également le concept de rang de tenseur et montre comment il peut être utilisé pour contrôler le nombre de dimensions dans un tenseur. Enfin, il montre comment remodeler un vecteur de données dans une forme différente à l'aide de la fonction de remodelage de points TF.
  
  
• 00: 55: 00 Cette vidéo enseigne les bases des tenseurs, y compris leurs différents types, comment créer et évaluer des tenseurs et comment les remodeler.

Partie 2

• 01:00:00 Cette vidéo explique l'idée de base de la régression linéaire, qui est un algorithme d'apprentissage automatique utilisé pour prédire les valeurs futures à partir de données passées. La régression linéaire est utilisée lorsque les points de données sont corrélés de manière linéaire.
  
  
• 01:05:00 Dans ce didacticiel, vous apprendrez à utiliser la régression linéaire pour prédire de nouveaux points de données à l'aide d'une ligne de meilleur ajustement.
  
  
• 01:10:00 Dans cette vidéo, le présentateur explique comment la régression linéaire est utilisée pour prédire les valeurs d'un ensemble de données. Ils expliquent d'abord comment fonctionne la régression linéaire en trois dimensions, puis montrent comment la coder dans TensorFlow.
  
  
• 01:15:00 La vidéo présente l'ensemble de données du Titanic et explique pourquoi la régression linéaire est un bon algorithme pour prédire qui survivra sur le navire. L'ensemble de données est chargé dans pandas et Excel.
  
  
• 01:20:00 Cette vidéo explique comment utiliser un bloc de données pour stocker des données et comment utiliser l'opérateur point pour rechercher des valeurs spécifiques à l'intérieur du bloc de données.
  
  
• 01:25:00 Dans cette vidéo, l'instructeur explique les bases des Tensors et comment ils sont utilisés dans l'apprentissage automatique. Il montre ensuite comment créer un modèle à l'aide d'un ensemble de données d'apprentissage et d'un ensemble de données de test.
  
  
• 01:30:00 Dans cette vidéo, l'auteur explique comment créer des colonnes de caractéristiques dans un ensemble de données à l'aide de TensorFlow. Ces colonnes seront utilisées pour entraîner un estimateur linéaire ou un modèle.
  
  
• 01:35:00 Dans cette vidéo, l'instructeur explique comment créer des colonnes de caractéristiques et des colonnes numériques dans un modèle TensorFlow, et comment entraîner le modèle à l'aide de lots.
  
  
• 01:40:00 Le cours complet TF 2.0 explique comment créer un réseau de neurones à l'aide de Python, et comment former et évaluer le réseau. Le didacticiel vidéo montre comment créer une fonction d'entrée et comment utiliser la fonction pour créer des images du jeu de données panda.
  
  
• 01:45:00 Ce résumé en 1 paragraphe explique comment utiliser un modèle TensorFlow pour faire des prédictions sur un ensemble de données. Tout d'abord, vous créez le modèle à l'aide de la syntaxe du module estimateur. Ensuite, vous entraînez le modèle à l'aide d'un objet classificateur linéaire. Enfin, vous évaluez le modèle et imprimez la précision.
  
  
• 01:50:00 Cette vidéo explique comment utiliser TensorFlow pour créer des réseaux de neurones pour prédire les résultats, y compris comment parcourir les prédictions et accéder aux valeurs réelles.
  
  
• 01:55:00 Dans ce didacticiel, l'auteur montre comment utiliser TensorFlow pour former un réseau de neurones afin de prédire les espèces de fleurs à partir d'un ensemble de données. L'auteur explique également les différents types de réseaux de neurones et comment utiliser les fonctions d'entrée pour optimiser leurs performances.

Partie 3

• 02:00:00 Dans cette vidéo, l'auteur décrit le processus de création d'un réseau de neurones dans TensorFlow 2.0 et explique les différents modèles disponibles. Ils montrent ensuite comment construire le réseau de neurones et le former à l'aide d'un classificateur dnn.
  
  
• 02:05:00 Dans cette vidéo, une fonction d'entraînement et d'évaluation est créée pour un réseau de neurones. Un lambda est utilisé pour définir la fonction sur une ligne. La fonction est ensuite utilisée pour entraîner le réseau de neurones. La précision du réseau neuronal formé est affichée.
  
  
• 02:10:00 La vidéo montre comment utiliser la fonction de prédiction de TensorFlow pour prédire la classe d'une fleur. L'utilisateur saisit d'abord les caractéristiques de la fleur, telles que la longueur des sépales, la longueur des pétales et la largeur. Ensuite, ils créent un dictionnaire prédictif et l'alimentent en fonctionnalités. TensorFlow prédit ensuite la classe de la fleur en fonction des caractéristiques d'entrée. Enfin, l'utilisateur imprime la prédiction et la probabilité de la prédiction.
  
  
• 02:15:00 Cette vidéo couvre les bases des réseaux de neurones, y compris la classification et le clustering.
  
  
• 02:20:00 La vidéo explique comment utiliser les réseaux de neurones Python pour regrouper des points de données. Après avoir étiqueté tous les points de données, la vidéo explique comment trouver le centre de masse le plus proche entre tous les clusters et comment réaffecter les points de données au cluster le plus proche.
  
  
• 02:25:00 Dans cette vidéo, l'instructeur couvre les bases des réseaux de neurones et des modèles de Markov cachés. Il commence par discuter des types de données utilisés dans l'apprentissage automatique, tels que les k-means et la régression linéaire. Il discute ensuite d'un modèle météorologique de base et de la manière de créer un modèle de Markov caché pour prédire le temps qu'il fera un jour donné.
  
  
• 02:30:00 Dans ce didacticiel vidéo, le présentateur présente les bases de TensorFlow, y compris son utilisation pour les réseaux de neurones. Il poursuit ensuite en expliquant comment créer un modèle météorologique de base dans TensorFlow, en utilisant deux états et deux distributions de probabilité. Le présentateur montre ensuite comment utiliser le modèle pour prédire la température de la semaine prochaine.
  
  
• 02:35:00 Cette vidéo montre comment utiliser TensorFlow pour créer un réseau de neurones afin de prédire la température moyenne chaque jour d'une séquence donnée. La vidéo explique comment importer les modules nécessaires et créer un modèle. Le modèle prédit correctement la température moyenne le premier jour de la séquence, mais prédit la mauvaise température les jours suivants. Après avoir résolu le problème, la vidéo montre comment utiliser un module TensorFlow différent pour prédire avec succès la température moyenne chaque jour de la séquence.
  
  
• 02:40:00 Cette vidéo décrit comment exécuter un modèle dans TensorFlow 2.0 à l'aide de la commande Moyenne. Il s'agit d'une commande utile pour comparer les valeurs attendues des variables dans un modèle.
  
  
• 02:45:00 Dans ce module, l'instructeur discutera des réseaux de neurones et de leur fonctionnement, ainsi que de la manière dont un réseau de neurones est composé de couches. Il expliquera également comment une couche d'entrée reçoit des données brutes et comment un réseau neuronal serait capable de classer ces données.
  
  
• 02:50:00 Le "Cours complet TensorFlow 2.0 - Tutoriel sur les réseaux de neurones Python pour les débutants" fournit un guide étape par étape pour créer un réseau de neurones de base en Python. La première couche est un neurone d'entrée, suivi d'une couche cachée, puis d'une couche de sortie. La couche de sortie a un neurone pour chaque élément d'information d'entrée, et les neurones de la couche cachée sont connectés les uns aux autres et à la couche de sortie. La couche cachée est connectée à la couche d'entrée et à la couche de sortie, appelée réseau neuronal densément connecté.
  
  
• 02:55:00 Ce didacticiel vidéo montre comment utiliser Python pour les réseaux de neurones, montrant comment créer un générateur de nombres aléatoires et former un réseau de neurones. La vidéo explique également comment connecter les neurones et les poids, comment transmettre des informations via le réseau et comment calculer la valeur de sortie d'un neurone.

Partie 4

• 03:00:00 Dans cette vidéo, un réseau de neurones Python est expliqué, à l'aide d'une fonction d'activation. Cette fonction écrase/carre les nombres négatifs et positifs, permettant au réseau d'identifier plus facilement les couleurs rouge et bleue.
  
  
• 03:05:00 Dans cette vidéo, l'auteur explique le concept d'une fonction d'activation et comment elle affecte la sortie d'un réseau de neurones. Il explique également comment une fonction d'activation peut être utilisée pour introduire de la complexité dans le réseau. L'auteur poursuit ensuite en discutant d'une fonction de perte, qui est utilisée pour former un réseau de neurones.
  
  
• 03:10:00 Cette vidéo présente le concept de réseaux de neurones et décrit les trois principales fonctions de perte utilisées dans la formation des réseaux de neurones : erreur quadratique moyenne, erreur absolue moyenne et perte de charnière. Il poursuit ensuite en expliquant la descente de gradient, qui est l'algorithme utilisé pour optimiser les performances du réseau neuronal.
  
  
• 03:15:00 Ce didacticiel vidéo présente les bases de TensorFlow, notamment comment créer et entraîner un réseau de neurones. La vidéo couvre également l'utilisation d'un algorithme d'optimisation de réseau de neurones et explique comment évaluer les performances d'un réseau de neurones.
  
  
• 03:20:00 Dans cette vidéo, l'instructeur montre comment utiliser TensorFlow pour entraîner un réseau de neurones en Python. L'ensemble de données utilisé dans la démonstration comprend des images de différents types de vêtements, et l'instructeur montre comment utiliser les fonctions d'entraînement et de test de TensorFlow pour valider les prédictions du réseau.
  
  
• 03:25:00 Dans cette vidéo, l'instructeur décrit les bases d'un réseau de neurones, y compris les couches et les nœuds d'un réseau de neurones, et la fonction d'activation utilisée pour déterminer la valeur de sortie d'un neurone. L'instructeur décrit également comment créer un modèle dans TensorFlow et comment exécuter le modèle.
  
  
• 03:30:00 Dans ce didacticiel vidéo d'une heure, le créateur couvre les bases de TensorFlow, y compris l'architecture et la fonction d'un réseau de neurones. Ils montrent ensuite comment compiler et adapter un réseau de neurones, et enfin le former sur un ensemble de formation. Le surajustement est expliqué et la précision du modèle formé est comparée à celle d'un ensemble de test.
  
  
• 03:35:00 Dans cette vidéo, l'instructeur explique comment les réseaux de neurones peuvent sur-adapter et comment améliorer la généralisation en ajustant les hyperparamètres. Il montre ensuite comment faire des prédictions sur des images de test en utilisant l'objet prédit du réseau de neurones.
  
  
• 03:40:00 Ce didacticiel vidéo explique comment utiliser TensorFlow pour créer un réseau neuronal convolutif pour la vision par ordinateur en profondeur. La vidéo explique ce qu'est un réseau neuronal convolutif, son fonctionnement et l'utilisation de modèles pré-formés.
  
  
• 03:45:00 La vidéo explique la différence entre un réseau neuronal dense et un réseau neuronal convolutif, et explique qu'un réseau neuronal convolutif apprend des modèles locaux au lieu de modèles globaux.
  
  
• 03:50:00 Le réseau neuronal convolutif (CNN) est un algorithme d'apprentissage automatique utilisé pour analyser et comprendre les images. Le réseau neuronal convolutif est composé d'un certain nombre de couches différentes qui sont utilisées pour analyser et comprendre l'image. La première couche est utilisée pour identifier la présence de filtres spécifiques dans l'image.
  
  
• 03:55:00 Dans cette vidéo, l'instructeur explique comment trouver un filtre dans une image à l'aide du produit croisé. Le filtre est déterminé en fonction de la similarité des valeurs de pixel entre l'image et le filtre.

[MetaQuotes]

Python TensorFlow pour l'apprentissage automatique - Tutoriel de classification de texte de réseau de neurones

Python TensorFlow pour l'apprentissage automatique - Tutoriel de classification de texte de réseau de neurones

Dans ce didacticiel YouTube, le présentateur couvre une gamme de sujets liés à Python TensorFlow pour l'apprentissage automatique et la classification de texte par réseau de neurones. Ils commencent par discuter du processus de configuration dans Google Colab et de l'importation des bibliothèques nécessaires, avant de se concentrer sur l'ensemble de données Wine Reviews et d'utiliser Matplotlib pour tracer les histogrammes des différentes fonctionnalités. Le didacticiel couvre les concepts d'apprentissage automatique, y compris l'apprentissage supervisé, et la différence entre les données qualitatives et quantitatives, ainsi que les entrées et les prédictions dans les scénarios de classification tels que la classification binaire et multiclasse. Les autres sujets abordés incluent les fonctions de perte, les réseaux de neurones, les fonctions d'activation, la descente de gradient et la rétropropagation, ainsi que la mise en œuvre de réseaux de neurones dans TensorFlow. Enfin, le présentateur met en œuvre un réseau de neurones à l'aide de TensorFlow pour la classification de texte, démontrant les avantages de l'utilisation de packages et de bibliothèques pour augmenter l'efficacité.

La deuxième partie du didacticiel vidéo couvre divers aspects de l'apprentissage automatique avec TensorFlow en Python, en se concentrant spécifiquement sur la classification de texte par réseau de neurones. Le didacticiel couvre la division des données en ensembles d'entraînement et de test, la création d'un modèle simple avec TensorFlow et Keras, la mise à l'échelle et l'équilibrage des ensembles de données, l'utilisation de réseaux de neurones récurrents et l'utilisation de TensorFlow Hub pour la classification de texte. Le didacticiel met l'accent sur l'importance d'évaluer la précision du modèle et l'utilisation de divers composants de réseau neuronal, tels que les fonctions d'activation, les couches d'abandon et différents types de cellules. Le didacticiel se termine en résumant les principaux points à retenir, notamment la création de réseaux de neurones, l'utilisation de TensorFlow pour la classification de texte et l'utilisation de données numériques.

• 00:00:00 Dans cette section de la vidéo, Kylie Ying commence par montrer aux téléspectateurs comment configurer un nouveau bloc-notes dans Google Colab et importer les bibliothèques nécessaires telles que NumPy, Pandas, Matplotlib, TensorFlow et TensorFlow Hub. Après avoir importé ces bibliothèques, elle télécharge un ensemble de données appelé "Wine Reviews" sous forme de fichier CSV et le lit comme un Pandas DataFrame, en sélectionnant les colonnes qu'elle souhaite analyser, telles que le pays, la description, les points et le prix. Elle décide de se concentrer sur l'analyse de la relation entre la description et les colonnes de points pour voir si un modèle de réseau neuronal peut être formé pour classer si une critique de vin se situe à l'extrémité inférieure ou supérieure du spectre des points.
  
  
• 00: 05: 00 Dans cette section de la vidéo, l'orateur explique comment supprimer des colonnes dans une trame de données pandas et tracer un histogramme à l'aide de Matplotlib. Ils tracent la colonne des points pour voir la distribution des valeurs et décident de classer les avis en dessous de 90 et au-dessus de 90. L'orateur donne également une brève explication de l'apprentissage automatique, y compris la différence entre l'intelligence artificielle, l'apprentissage automatique et la science des données, avec l'apprentissage automatique étant un sous-ensemble de l'IA qui se concentre sur la résolution d'un problème spécifique à l'aide de données. Les domaines de l'IA, de l'apprentissage automatique et de la science des données se chevauchent et peuvent utiliser des techniques d'apprentissage automatique pour analyser les données et en tirer des enseignements.
  
  
• 00:10:00 Dans cette section, le conférencier présente trois types différents d'apprentissage automatique : l'apprentissage supervisé, l'apprentissage non supervisé et l'apprentissage par renforcement. Le didacticiel se concentre sur l'apprentissage supervisé où l'entrée a une étiquette de sortie correspondante et est utilisée pour former des modèles pour apprendre les sorties. L'orateur explique que le modèle d'apprentissage automatique apprend des modèles dans les données pour arriver à la prédiction et que la liste des entrées est appelée un vecteur de caractéristiques. L'orateur discute également des deux différents types d'entrées de données qualitatives : les nombres catégoriels et finis de catégories ou de groupes. Le didacticiel se concentre sur l'utilisation de paires d'entrées et de sorties étiquetées pour effectuer des prédictions futures.
  
  
• 00:15:00 Dans cette section, la vidéo présente le concept de caractéristiques qualitatives et quantitatives et comment elles peuvent être encodées en nombres pour les ordinateurs. Les caractéristiques qualitatives, telles que la nationalité ou les tranches d'âge, sont celles qui ne sont pas associées à un numéro, et elles peuvent être encodées à l'aide d'un encodage à chaud. Les caractéristiques numériques, telles que la taille d'un bureau ou la température du feu, sont quantitatives et peuvent être continues ou discrètes. La vidéo fait également la distinction entre les données nominales, qui n'ont pas d'ordre inhérent, et les données ordinales, qui ont un ordre inhérent, et explique comment différents types de caractéristiques qualitatives peuvent nécessiter différentes techniques de codage.
  
  
• 00:20:00 Dans cette section, l'orateur explique les différents types d'entrées et de prédictions dans l'apprentissage supervisé. Les entrées peuvent être continues ou discrètes, tandis que les prédictions peuvent être classées comme binaires ou multi-classes. Pour la classification binaire, le modèle prédit si une entrée appartient à l'une des deux catégories, tandis que la classification multi-classe implique le mappage des entrées à l'une de plusieurs catégories. De plus, la régression est utilisée pour prédire les valeurs continues. L'orateur taquine ensuite le sujet des modèles, mais n'entre pas encore dans les détails. Enfin, l'orateur aborde brièvement comment faire apprendre le modèle et évaluer ses performances.
  
  
• 00: 25: 00 Dans cette section, l'orateur discute de l'ensemble de données qu'il utilisera pour un exemple concret et explique la structure des données. L'ensemble de données contient des informations sur les individus, y compris des variables quantitatives telles que le nombre de grossesses, les niveaux de glucose et la pression artérielle, ainsi qu'une variable de résultat indiquant s'ils sont diabétiques ou non. Chaque ligne représente un individu différent et chaque colonne représente une caractéristique différente qui peut être introduite dans le modèle. Le vecteur de caractéristiques est ce qui est connecté au modèle, la cible de ce vecteur de caractéristiques étant la sortie à prédire. L'orateur poursuit en expliquant que l'ensemble de données est divisé en un ensemble de données d'apprentissage, un ensemble de données de validation et un ensemble de données de test, et que l'ensemble de données de validation est utilisé pour vérifier que le modèle peut gérer des données invisibles avant que le modèle ne soit testé sur le jeu de données de test.
  
  
• 00: 30: 00 Dans cette section, l'orateur discute des fonctions de perte et de la manière dont elles quantifient la différence entre les valeurs prédites et les valeurs réelles dans les scénarios de régression et de classification binaire. Dans la régression, la fonction de perte L1 trouve la différence entre les valeurs prédites et réelles, tandis que la fonction de perte L2 met les différences au carré. Dans la classification binaire, la perte d'entropie croisée binaire trouve la différence entre les probabilités prédites et réelles d'appartenir à une classe particulière. Le conférencier explique également la précision comme mesure de performance dans les scénarios de classification. Enfin, le conférencier présente le concept de modèle et comment il s'intègre dans le processus global d'apprentissage automatique.
  
  
• 00: 35: 00 Dans cette section, l'orateur discute des réseaux de neurones, déclarant qu'ils sont populaires pour leur capacité à être utilisés pour la classification et la régression. Cependant, le conférencier mentionne également que les réseaux de neurones sont parfois surutilisés et que leur utilisation pour des modèles simples peut être inutile. L'orateur explique comment les réseaux de neurones sont une boîte noire et manquent donc parfois de transparence. Ils expliquent la structure d'un réseau de neurones, y compris la manière dont les caractéristiques sont multipliées par des poids et ajoutées à des biais avant de passer par une fonction d'activation. Le conférencier insiste sur l'importance d'utiliser une fonction d'activation non linéaire pour éviter que le réseau de neurones ne devienne une simple régression linéaire.
  
  
• 00:40:00 Dans cette section, la vidéo traite des fonctions d'activation et de leur rôle dans les réseaux de neurones. Si un réseau de neurones utilisait simplement une fonction linéaire, il ne remplirait pas son objectif. Les fonctions d'activation, telles que sigmoïde, tange et relu, permettent à chaque neurone d'être projeté dans un espace non linéaire, ce qui permet le processus de formation. La vidéo explique ensuite le concept de descente de gradient et de rétropropagation, qui sont les raisons pour lesquelles les réseaux de neurones fonctionnent. La descente de gradient mesure la pente de la fonction de perte et la rétropropagation ajuste les valeurs de poids pour minimiser la perte. Grâce à ce processus, une nouvelle valeur de poids est définie pour chaque paramètre, qui est l'ancien poids plus un certain alpha.
  
  
• 00:45:00 Dans cette section, la vidéo traite de la mise en œuvre des réseaux de neurones dans l'apprentissage automatique à l'aide de bibliothèques telles que TensorFlow qui ont déjà été développées et optimisées. La bibliothèque TensorFlow est une bibliothèque open source qui permet de développer et de former des modèles d'apprentissage automatique. La bibliothèque comprend de nombreux modules, dont Keras, qui contient des modules qui aident les utilisateurs à créer et à optimiser des modèles, tels que différents optimiseurs. La vidéo explique également pourquoi il est avantageux d'utiliser des bibliothèques établies plutôt que de coder un réseau de neurones à partir de zéro.
  
  
• 00: 50: 00 Dans cette section, le présentateur montre aux téléspectateurs comment mettre en œuvre un réseau de neurones à l'aide de TensorFlow pour la classification de texte. Ils commencent par présenter les avantages de l'utilisation de packages et de bibliothèques pour améliorer l'efficacité, avant de passer à la création d'un nouveau bloc-notes dans lequel ils chargent un ensemble de données appelé diabetes.csv à l'aide de la fonction de lecture csv. L'ensemble de données provient de l'Institut national du diabète et des maladies digestives et rénales et comprend diverses caractéristiques et données démographiques sur les patients, ainsi qu'une classification indiquant si le patient est atteint de diabète. Le présentateur montre ensuite comment visualiser les données en traçant des histogrammes des différentes caractéristiques, indexées selon que le patient est diabétique ou non, à l'aide d'une boucle for dans le Jupyter Notebook.
  
  
• 00: 55: 00 Dans cette section du didacticiel vidéo sur l'utilisation de Python TensorFlow pour l'apprentissage automatique et la classification de texte de réseau neuronal, le présentateur crée un nouveau cadre de données avec des résultats définis sur zéro et un autre avec des résultats définis sur un pour différencier les patients atteints de diabète et ceux sans. L'étape suivante consiste à visualiser le nombre de patients diabétiques positifs et négatifs, ce qui semble peu concluant car il n'y a pas de schéma séparable entre les différentes valeurs. Cela met en évidence l'importance de l'apprentissage automatique dans la prédiction du diabète en considérant toutes les caractéristiques ensemble. Enfin, le présentateur divise le bloc de données en valeurs x et y pour une analyse plus approfondie.

• 01:00:00 Dans cette section, l'orateur explique comment diviser les données en ensembles d'entraînement et de test à l'aide du module Scikit-learn. Le locuteur importe le module, appelle la fonction train_test_split et transmet les fonctionnalités d'entrée et de sortie. La taille du test est définie sur 20 %, tandis que la taille de la formation est définie sur 60 % de l'ensemble de données. Les ensembles temporaires sont ensuite utilisés pour créer des ensembles de validation et de test en utilisant une répartition 50/50. Enfin, l'orateur construit un modèle simple à l'aide de TensorFlow et Keras, en particulier la couche dense avec 16 neurones qui sont densément connectés à la couche précédente.
  
  
• 01:05:00 Dans cette section, l'orateur explique le processus de création d'un réseau de neurones pour la classification binaire à l'aide de TensorFlow en Python. Ils ajoutent des couches et une fonction d'activation appelée sigmoïde qui mappe l'entrée aux probabilités d'appartenance ou non à une seule classe. Le modèle est ensuite compilé avec un optimiseur appelé "adam", une fonction de perte appelée "entropie croisée binaire" et une métrique de précision. Avant de former le modèle, ils évaluent ses performances sur les données de formation et de validation, ce qui donne une faible précision. Enfin, l'orateur entraîne le modèle à l'aide de la fonction "model.fit", en transmettant les données d'entraînement et de validation, la taille du lot et le nombre d'époques.
  
  
• 01:10:00 Dans cette section, le présentateur discute de la nécessité de mettre à l'échelle les fonctionnalités de l'ensemble de données pour s'assurer qu'elles se trouvent sur une plage plus standardisée. Le présentateur explique comment importer le package nécessaire pour mettre à l'échelle les fonctionnalités à l'aide du prétraitement sklearn et du scalaire standard. Après avoir mis à l'échelle les entités, le présentateur vérifie la plage de valeurs et trace le bloc de données transformé pour démontrer que la plupart des entités sont maintenant à une échelle similaire. La mise à l'échelle des fonctionnalités permet de garantir que les fonctionnalités n'affectent pas le résultat du réseau neuronal en raison des différentes plages.
  
  
• 01:15:00 Dans cette section, le didacticiel vidéo se concentre sur la normalisation et l'équilibrage de l'ensemble de données via un processus appelé suréchantillonnage aléatoire. En visualisant les données, l'instructeur démontre comment l'ensemble de données pour les patients diabétiques et les patients non diabétiques est fortement déséquilibré, ce qui conduit à un réseau neuronal qui peut ne pas s'entraîner correctement. En utilisant l'échantillonneur aléatoire sur échantillonneur, davantage d'échantillons aléatoires sont ajoutés à l'ensemble de données, équilibrant ainsi les longueurs des deux catégories. Ceci est réalisé en important un autre package appelé Imbalance learn dot over sampling qui inclut un Random Over Sampler. L'ensemble de données est à nouveau divisé à l'aide de la fonction fit_resample, ce qui rend les deux résultats approximativement égaux à un. Après avoir réexécuté les cellules, la précision du modèle est plus proche de 50 %, ce qui indique que l'équilibrage de l'ensemble de données a entraîné une meilleure performance du modèle.
  
  
• 01:20:00 Dans cette section, le créateur évalue le modèle de réseau neuronal sur un ensemble de données de test et atteint une précision de 77,5 %, ce qui montre que le modèle réussit à se généraliser à des données invisibles. Le didacticiel aborde ensuite les réseaux de neurones récurrents (RNN) et leur utilité pour les données impliquant des séquences ou des séries. Les RNN permettent la création d'une mémoire au sein du réseau de neurones, lui permettant de se souvenir des informations des étapes de temps précédentes. Cependant, l'utilisation de RNN peut entraîner des problèmes tels que l'explosion ou la disparition des gradients lors de la rétropropagation.
  
  
• 01:25:00 Dans cette section, l'orateur discute des problèmes liés aux gradients qui se rapprochent de plus en plus de zéro, ce qui empêche les modèles de se mettre à jour et d'apprendre. Pour lutter contre cela, différents types de cellules ou de neurones peuvent être utilisés, tels que l'unité récurrente fermée et l'unité de mémoire à long terme. L'orateur passe ensuite à un exemple TensorFlow avec une classification de texte à l'aide de critiques de vins et montre comment diviser les données en ensembles de données d'entraînement, de validation et de test. L'orateur utilise la fonction de division de numpy pour montrer une manière différente de diviser les données et souligne l'importance d'être flexible lorsque vous travaillez avec des ensembles de données.
  
  
• 01:30:00 Dans cette section, le didacticiel vidéo explique comment diviser un ensemble de données en ensembles d'entraînement, de validation et de test et comment les convertir en un objet tf.data.Dataset dans TensorFlow. L'instructeur utilise une taille de lot plus grande et tf.data.autotune en raison de la grande taille de l'ensemble de données, et ajuste le code de fonction pour changer la variable cible en "label" puisque les données ont déjà été étiquetées. Le didacticiel explique également le fonctionnement du hub TensorFlow, qui est utilisé pour la classification de texte dans ce didacticiel. La vidéo montre également comment visualiser les ensembles de données dans les objets d'ensemble de données TensorFlow.
  
  
• 01:35:00 Dans cette section, le didacticiel vidéo explique comment utiliser TensorFlow Hub, un référentiel de modèles d'apprentissage automatique pré-entraînés, pour faciliter la classification de texte. La vidéo explique que les ordinateurs ne comprennent pas le texte, donc le texte doit être transformé en nombres que l'ordinateur peut comprendre. Pour effectuer cette transformation, la vidéo utilise nnlm, une intégration de texte basée sur des jetons formée sur les actualités anglaises de Google, et convertit tout le texte en un vecteur de nombres. La vidéo montre ensuite comment créer un modèle de réseau neuronal à l'aide de TensorFlow Keras avec une couche dense, une fonction d'activation ReLU et une sortie de classification binaire. La vidéo compile le modèle et l'évalue sur les données de formation et de validation, montrant une précision d'environ 40 %.
  
  
• 01:40:00 Dans cette section de la vidéo, l'orateur entraîne un modèle d'apprentissage automatique et observe les résultats. La précision de l'entraînement augmente et la perte diminue, indiquant que le modèle est bien entraîné. Cependant, la précision de la validation plafonne et même diminue légèrement, ce qui indique que le modèle ne se généralise pas bien et qu'il est surajusté. Pour résoudre ce problème, l'orateur suggère d'ajouter des couches d'abandon, qui sélectionnent au hasard quelques nœuds à "éteindre" lors de chaque itération d'entraînement. Cela introduit plus de caractère aléatoire et de variabilité dans le modèle, ce qui l'aide à mieux généraliser. Enfin, le locuteur répète la couche hub et compile le modèle.
  
  
• 01:45:00 Dans cette section, l'utilisateur évalue le réseau de neurones qui a été créé et entraîné dans la section précédente. La perte diminue et la précision augmente, mais l'utilisateur arrête l'entraînement tôt après seulement cinq époques. Le modèle est évalué sur les données de test et la précision est d'environ 83 %. L'utilisateur montre ensuite comment recréer le modèle à l'aide d'un LSTM et commence par créer un encodeur avec un jeton max défini sur 2000. Le modèle est ensuite défini à l'aide de l'encodeur et d'une couche d'intégration avec une dimension d'entrée définie sur la longueur du vocabulaire de l'encodeur. et une dimension de sortie définie sur 32. Enfin, une couche LSTM est ajoutée avec 32 nœuds.
  
  
• 01:50:00 Dans cette section de la vidéo, l'instructeur construit le réseau de neurones en ajoutant une couche dense et une couche de suppression pour éviter le surajustement. La fonction d'activation de la sortie est sigmoïde, tandis que l'entrée nécessite un tokenizer. La précision du modèle se situe autour de 53 et la perte autour de 0,7. Ensuite, le modèle est entraîné en évaluant les données d'entraînement et de validation. À la fin de la formation, la précision des données de test s'avère être de 84. Le didacticiel se termine avec l'instructeur résumant les plats à emporter, qui apprend à construire un réseau de neurones à anticipation, à utiliser TensorFlow pour la classification de texte et à implémenter numérique données.

[MetaQuotes]

Cours complet TensorFlow 2.0 - Tutoriel sur les réseaux de neurones Python pour débutants (parties 5 à 7)

Cours complet TensorFlow 2.0 - Tutoriel sur les réseaux de neurones Python pour débutants

Partie 5

• 04:00:00 La vidéo explique comment fonctionnent les réseaux de neurones convolutifs et comment le rembourrage et la foulée contribuent à rendre le réseau plus facile à utiliser.
  
  
• 04:05:00 Dans cette vidéo, l'instructeur explique comment les opérations de regroupement, telles que min et max, sont utilisées pour réduire la dimensionnalité d'une carte d'entités. Il montre ensuite comment cela se fait en montrant comment échantillonner des valeurs à partir d'une carte de caractéristiques et générer une carte de caractéristiques avec une dimensionnalité réduite. Ensuite, l'instructeur montre comment utiliser une opération de regroupement deux par deux pour réduire de moitié la taille de la carte d'entités. Il montre ensuite comment utiliser une opération de regroupement maximal pour rechercher des entités dans une zone. Il montre ensuite comment utiliser une opération de regroupement moyen pour trouver des entités dans une zone. Enfin, l'instructeur montre comment utiliser Kerris pour créer un réseau neuronal convolutionnel.
  
  
• 04:10:00 Dans ce didacticiel vidéo, l'instructeur montre comment créer un réseau de neurones à convolution (CNN) à l'aide de Python. La première couche du CNN est une couche de regroupement maximum qui réduit la dimensionnalité des données d'entrée. Les deux couches suivantes sont une couche convolutive et une couche de regroupement maximum. La couche finale est une couche dense qui classe les données d'entrée.
  
  
• 04:15:00 Cette vidéo explique comment l'augmentation des données peut être utilisée pour améliorer les performances d'un modèle d'apprentissage automatique. L'augmentation des données consiste à modifier une image pour la rendre plus similaire aux données d'apprentissage, ce qui peut améliorer la capacité de généralisation du modèle.
  
  
• 04:20:00 Cette vidéo montre comment utiliser des modèles pré-entraînés dans TensorFlow 2.0 pour améliorer la précision des classifications.
  
  
• 04:25:00 Dans cette vidéo, le présentateur explique comment utiliser un modèle TensorFlow pré-entraîné pour reconnaître les images de différents animaux. Tout d'abord, ils expliquent comment charger le modèle dans TensorFlow et redimensionner les images à la même taille. Ensuite, ils montrent comment appliquer le modèle aux ensembles de données de formation et de validation. Enfin, ils montrent comment utiliser le modèle pour reconnaître des images d'animaux.
  
  
• 04:30:00 Dans cette vidéo, l'instructeur montre comment créer un réseau de neurones à l'aide de TensorFlow 2.0 pour s'entraîner sur un ensemble de données de 1 000 classes de chiens et de chats. Le réseau est pré-entraîné à l'aide d'un modèle de base, puis une couche de prédiction est ajoutée. L'instructeur montre également comment geler les paramètres pouvant être entraînés d'une couche afin que le réseau ne soit pas recyclé lors de son utilisation pour la prédiction. Le modèle est ensuite évalué et entraîné sur un nouveau jeu de données.
  
  
• 04:35:00 Cette vidéo explique comment utiliser TensorFlow pour entraîner un modèle capable de prédire la classe d'une image. La vidéo couvre des concepts de base tels que l'apprentissage en profondeur et les réseaux de neurones convolutifs.
  
  
• 04:40:00 Cette vidéo explique comment les réseaux de neurones récurrents peuvent être utilisés pour comprendre et traiter le langage naturel. La première section explique ce qu'est le traitement du langage naturel et en quoi les réseaux de neurones récurrents diffèrent des réseaux de neurones réguliers. La deuxième section explique comment convertir des données textuelles en données numériques pouvant être utilisées par un réseau de neurones récurrent. La dernière section explique comment utiliser les réseaux de neurones récurrents pour effectuer une analyse des sentiments et la génération de texte à barre oblique.
  
  
• 04:45:00 La première méthode dont nous parlerons s'appelle le sac de mots. Cet algorithme examine une phrase et la convertit en une représentation numérique où chaque mot de la phrase est codé avec un nombre. Cela peut être utile pour les tâches où la simple présence d'un mot suffit à déterminer le sens de la phrase. Cependant, lorsqu'il s'agit d'entrées plus complexes, cette technique peut échouer.
  
  
• 04:50:00 La vidéo traite de l'utilisation d'un sac de mots d'encodage pour le texte, ainsi que de quelques autres méthodes d'encodage. Un problème avec cette approche est qu'elle perd l'ordre des mots, ce qui peut rendre difficile pour un modèle d'apprentissage automatique d'identifier correctement le sentiment dans le texte.
  
  
• 04:55:00 Dans cette vidéo, l'instructeur explique comment fonctionnent les incorporations de mots et comment elles peuvent être utilisées pour améliorer la précision des prédictions d'un réseau de neurones. L'instructeur présente ensuite les réseaux neuronaux récurrents, qui sont un type de réseau neuronal particulièrement efficace pour le traitement des données textuelles.

Partie 6

• 05:00:00 Un réseau de neurones récurrent est un type de réseau de neurones qui traite des données à différents pas de temps et maintient une mémoire interne. Cela permet au réseau d'acquérir progressivement une compréhension d'un texte ou d'une entrée.
  
  
• 05:05:00 Cette vidéo explique les bases de TensorFlow 2.0, qui comprend une description d'une couche de réseau neuronal récurrent (RNN) simple et d'une couche de mémoire longue à court terme (LSTM). La couche LSTM est conçue pour aider la couche RNN à se souvenir des phrases précédentes dans une séquence de texte, ce qui peut devenir de plus en plus difficile à mesure que la longueur de la séquence augmente.
  
  
• 05:10:00 Le cours complet TensorFlow 2.0 - Le didacticiel sur les réseaux de neurones Python pour débutants couvre les bases des réseaux de neurones, y compris les réseaux de neurones récurrents, qui sont utilisés pour l'analyse des sentiments dans les critiques de films.
  
  
• 05:15:00 Dans cette vidéo, le présentateur montre comment remplir une révision de texte à une longueur spécifique à l'aide de Python et décrit comment le modèle est formé. Ils mentionnent également qu'ils accélèrent le processus de formation en utilisant un GPU.
  
  
• 05:20:00 Dans cette vidéo, l'auteur propose un cours complet sur l'enseignement des réseaux de neurones Python pour les débutants. Le cours commence par une introduction aux réseaux de neurones, suivi d'un didacticiel sur la façon de former un réseau de neurones à l'aide de TensorFlow 2.0. Une fois le réseau de neurones formé, l'auteur montre comment faire des prédictions sur un ensemble de données de critiques de films. Les résultats montrent que le réseau de neurones n'est pas assez précis et l'auteur fournit une fonction pour coder le texte en jetons que le réseau de neurones doit traiter. L'auteur fournit également une fonction de décodage pour reconvertir le texte en mots.
  
  
• 05:25:00 Ce résumé d'un paragraphe explique comment la fonction de décodage des entiers encode du texte dans une critique de film en Python. Cette fonction prend une séquence de mots et les transforme en nombres entiers, puis utilise la fonction de texte ENCODE pour coder les nombres entiers. Enfin, le modèle est utilisé pour prédire la révision d'un texte donné. Le premier examen devrait être positif à 72 %, tandis que le deuxième examen devrait être positif à 23 %.
  
  
• 05:30:00 Dans cette dernière vidéo du cours complet TensorFlow 2.0, un réseau neuronal récurrent est créé pour générer une pièce basée sur un texte de Shakespeare. Le fichier est chargé et lu, et la longueur du texte est calculée. Les 250 premiers caractères sont lus et analysés pour déterminer le schéma de codage. Les caractères sont encodés sous forme d'entiers et le vocabulaire est créé. L'indice de chaque caractère est calculé et stocké dans le vocabulaire.
  
  
• 05:35:00 Dans cette vidéo, l'instructeur enseigne comment utiliser TensorFlow pour entraîner un réseau de neurones à l'aide d'un ensemble de données textuelles. L'instructeur convertit d'abord l'ensemble de données textuelles en nombres entiers, puis entraîne le réseau de neurones à l'aide d'une séquence de 101 exemples d'entraînement par époque.
  
  
• 05:40:00 Cette vidéo explique comment créer un modèle dans TensorFlow 2.0 à l'aide de la fonction intégrée "créer un modèle". Le modèle est formé sur un ensemble de 64 exemples de formation, puis enregistré afin que les prédictions puissent être faites sur une séquence d'entrée.
  
  
• 05:45:00 L'auteur décrit les étapes nécessaires pour entraîner un réseau de neurones à l'aide de TensorFlow. Tout d'abord, l'auteur décrit les formes d'entrée et de sortie du réseau de neurones. Ensuite, l'auteur explique comment créer une fonction de perte pour optimiser le réseau de neurones. Enfin, l'auteur montre comment utiliser le modèle pour prédire une séquence de 100 échantillons.
  
  
• 05:50:00 Dans cette vidéo, TensorFlow est expliqué en détail, notamment son fonctionnement avec les réseaux de neurones récurrents. La vidéo explique également comment créer une fonction de perte pour déterminer les performances d'un modèle.
  
  
• 05:55:00 Cette vidéo présente la bibliothèque TensorFlow 2.0 pour la formation de réseaux de neurones et montre comment reconstruire un modèle avec une nouvelle taille de lot de un. La vidéo comprend également une démonstration de la façon de générer du texte avec TensorFlow.

Partie 7

• 06:00:00 Dans cette vidéo, TensorFlow 2.0 Complete Course - Python Neural Networks for Beginners Tutorial, l'utilisateur explique comment générer une séquence de texte à l'aide d'un réseau de neurones récurrent. La première étape consiste à réinitialiser l'état du réseau et à générer une liste de prédictions. Ensuite, l'utilisateur entraîne le réseau sur un script d'animation B et affiche les résultats.
  
  
• 06:05:00 Ce didacticiel vidéo couvre les bases de TensorFlow 2.0, y compris la création d'un réseau de neurones simple en Python. La vidéo passe ensuite à la discussion sur l'apprentissage par renforcement, qui est une technique avancée plus complexe. La vidéo se termine par une discussion sur la terminologie et un récapitulatif de ce qu'est l'apprentissage par renforcement.
  
  
• 06:10:00 L'apprentissage par renforcement est une méthode d'entraînement de l'IA pour accomplir des tâches dans un environnement en les récompensant pour les actions qui conduisent à une amélioration des performances. Le but de l'apprentissage par renforcement est de maximiser une récompense, qui peut être tout ce que l'agent essaie d'obtenir dans l'environnement. Dans ce cours, l'instructeur couvre les concepts d'état, d'action et de récompense.
  
  
• 06:15:00 L'objectif de l'agent dans cet exemple est de maximiser sa récompense dans l'environnement en apprenant une table de repères qui prédit la récompense pour différentes actions dans différents états.
  
  
• 06:20:00 TensorFlow est une bibliothèque d'apprentissage automatique qui permet aux utilisateurs de créer des modèles capables d'apprendre à partir des données. Dans cette vidéo, l'instructeur explique comment fonctionne l'apprentissage Q et comment il est utilisé pour optimiser le comportement d'un agent dans un environnement simulé. Il poursuit en expliquant comment utiliser la table de repères pour optimiser le comportement de l'agent.
  
  
• 06:25:00 Dans cette vidéo, nous découvrons les réseaux de neurones utilisés dans un didacticiel pour débutant sur TensorFlow 2.0. La première partie de la vidéo couvre les bases des réseaux de neurones et leur fonctionnement. Nous explorons ensuite comment créer un agent simple qui apprend à naviguer dans un environnement 3D soit en utilisant la table de repères actuelle, soit en choisissant une action au hasard. La deuxième partie de la vidéo explique les formules utilisées pour mettre à jour la table des repères de l'agent.
  
  
• 06:30:00 La vidéo "TensorFlow 2.0 Complete Course - Python Neural Networks for Beginners Tutorial" présente le langage de programmation TensorFlow 2.0 et ses structures de données et algorithmes associés pour les réseaux de neurones, qui sont un type de modèle d'apprentissage automatique. La vidéo montre ensuite comment créer et entraîner un modèle de réseau neuronal simple à l'aide du logiciel de gym openAI.
  
  
• 06:35:00 Le cours complet TensorFlow 2.0 commence par l'introduction du modèle acteur-critique, qui est utilisé pour entraîner un réseau de neurones. Il montre ensuite comment créer un environnement de lac gelé à l'aide de NumPy et TensorFlow. Le cours explique comment utiliser q learning pour résoudre le problème de navigation dans l'environnement.
  
  
• 06:40:00 Cette vidéo propose un didacticiel complet sur l'utilisation de TensorFlow 2.0 pour créer un réseau de neurones pour les débutants. Tout d'abord, l'instructeur explique la variable epsilon et comment elle affecte la probabilité que l'agent effectue une action aléatoire. Ensuite, l'instructeur montre comment créer une liste de récompenses et comment mettre à jour les valeurs q de l'agent à l'aide de la formule de récompense. Enfin, l'instructeur montre comment définir l'état actuel de l'agent et vérifier s'il a fini d'explorer l'environnement.
  
  
• 06:45:00 Dans ce dernier module du "Cours complet TensorFlow 2.0 - Tutoriel sur les réseaux de neurones Python pour débutants", l'instructeur explique comment utiliser la table de repères pour ajuster la valeur epsilon afin d'augmenter lentement la récompense moyenne lorsque l'agent se déplace. un labyrinthe.
  
  
• 06:50:00 Ce didacticiel vidéo présente les bases de TensorFlow, une puissante bibliothèque d'apprentissage automatique. Après avoir présenté TensorFlow et ses concepts clés, le didacticiel guide les spectateurs à travers une série de didacticiels sur différentes tâches d'apprentissage automatique telles que l'apprentissage en profondeur et l'apprentissage par renforcement.

[MetaQuotes]

Cours Keras avec TensorFlow - Tutoriel sur l'apprentissage en profondeur Python et les réseaux de neurones pour les débutants

Cours Keras avec TensorFlow - Tutoriel sur l'apprentissage en profondeur Python et les réseaux de neurones pour les débutants

Le cours Keras avec TensorFlow vise à enseigner aux utilisateurs comment utiliser Keras, une API de réseau neuronal écrite en Python et intégrée à TensorFlow. Il couvre les bases de l'organisation et du prétraitement des données, la construction et la formation de réseaux de neurones artificiels, ainsi que l'importance de la normalisation des données et de la création d'ensembles de validation. Le cours fournit également des ressources telles que des fichiers vidéo et texte et un guide sur la façon de configurer un GPU pour une efficacité accrue. Les utilisateurs apprennent également à enregistrer et à charger des modèles, y compris des options pour tout enregistrer, uniquement l'architecture ou uniquement les poids. Le cours convient à ceux qui ont des compétences de base en programmation et une certaine expérience avec Python.

La deuxième section du "Cours Keras avec TensorFlow" couvre une variété de sujets, en commençant par charger des poids dans un nouveau modèle Keras avec la même architecture que le modèle d'origine. L'instructeur explique ensuite comment préparer et prétraiter les données d'image pour former un réseau neuronal convolutif afin de classer les images comme chats ou chiens avant de passer à la construction et à la formation d'un modèle séquentiel Keras pour le premier CNN. La section comprend des détails sur la formation du modèle à l'aide d'un générateur contenant des données d'étiquette pour la validation lors de l'ajustement du modèle, et comment tracer une matrice de confusion pour évaluer les performances du modèle. Il conclut en démontrant comment affiner un modèle VGG 16 pré-formé pour classer les images de chats et de chiens, ajuster son pré-traitement et le former également.

Dans la troisième section, l'instructeur présente MobileNets, une alternative plus petite et plus rapide aux modèles plus complexes. Ils démontrent le téléchargement et l'utilisation de MobileNets dans un Jupyter Notebook, l'organisation d'un ensemble de données pour les chiffres de la langue des signes et l'ajustement du modèle pour une nouvelle tâche de classification. L'instructeur insiste sur l'importance de pointer correctement l'itérateur vers l'emplacement de l'ensemble de données sur le disque, le nombre de couches à geler pendant la formation et le réglage des hyperparamètres pour réduire les problèmes de surajustement. La dernière section présente l'augmentation des données et son potentiel pour réduire le surajustement et augmenter la taille de l'ensemble de données, et fournit des instructions sur les différents types d'augmentation (par exemple, le déplacement, le retournement, la rotation), l'enregistrement des images augmentées sur le disque et leur ajout à la formation. ensemble.

• 00:00:00 Dans cette section, il est expliqué que le cours est axé sur l'enseignement de l'utilisation de Keras, une API de réseau neuronal écrite en Python et intégrée à TensorFlow. Il commence par les bases de l'organisation et du prétraitement des données, puis passe à la construction et à la formation de réseaux de neurones artificiels. Le cours recommande quelques compétences de programmation de base et une certaine expérience avec Python, mais donnera également de brèves introductions à chaque concept d'apprentissage en profondeur avant de passer par l'implémentation du code. Le cours fournit également des ressources vidéo et textuelles, y compris les fichiers de code utilisés dans le cours, qui sont régulièrement testés et maintenus, et l'accès au téléchargement de ces fichiers est disponible pour les membres de Deep Lizard Hive Mind. Il est en outre expliqué que Keras a été développé dans le but de permettre une expérimentation rapide des utilisateurs, et étant intégré à TensorFlow, Keras est maintenant complètement intégré à l'API TensorFlow. Des recommandations sont fournies pour apprendre plusieurs API de réseau neuronal et ne pas s'en tenir à une pour toujours pour démontrer l'expérience et la comparaison entre elles, rendant ainsi le candidat plus précieux.
  
  
• 00:05:00 Dans cette section du cours Keras avec TensorFlow, le besoin d'un GPU est discuté, et il est noté qu'il n'est pas requis pour le cours. Cependant, si un utilisateur souhaite utiliser un GPU, un guide est disponible sur la configuration du GPU pour qu'il fonctionne avec TensorFlow. Il est recommandé de suivre d'abord le cours avec un CPU, puis de configurer le GPU pour une efficacité et une vitesse accrues. La section suivante explique comment préparer et traiter les données numériques pour le réseau de neurones artificiels et les différents formats de données attendus par le modèle séquentiel de Keras. La fonction d'ajustement s'attend à ce que les données d'entrée (x) se trouvent dans un tableau NumPy, un tenseur TensorFlow, un mappage dict, un ensemble de données TF ou un générateur Keras. Les données cibles (y) doivent également être au même format que x.
  
  
• 00: 10: 00 Dans cette section, l'instructeur explique que la normalisation des données ou les techniques de standardisation peuvent mettre les données dans un format qui facilite l'apprentissage du modèle d'apprentissage en profondeur. L'instructeur utilise un ensemble de données numériques simple comme exemple, où un médicament expérimental a été testé sur des individus âgés de 13 à 100 ans, et environ 95 % des patients qui faisaient partie de la population plus âgée, 65 ans ou plus, ont subi des effets secondaires, tandis qu'environ 95 ans % des patients de moins de 65 ans n'ont ressenti aucun effet secondaire. L'instructeur passe ensuite par une boucle for qui génère des nombres entiers aléatoires qui imitent le scénario réel de patients ayant subi ou non des effets secondaires, puis ajoute ces échantillons et les étiquettes correspondantes à deux listes distinctes.
  
  
• 00: 15: 00 Dans cette section de la vidéo, l'instructeur résume le processus de génération et de préparation de données pour un réseau de neurones à l'aide de tableaux NumPy dans l'API Keras intégrée à TensorFlow. Ils expliquent que la liste des échantillons contient des âges et que la liste des étiquettes contient des zéros et des uns représentant des effets secondaires, ou aucun effet secondaire, pour correspondre à chaque âge. Les données sont ensuite traitées et transformées dans le format de tableau NumPy attendu par la fonction fit, et les données sont mélangées à l'aide de la fonction shuffle pour supprimer tout ordre imposé du processus de génération de données. De plus, les données sont remises à l'échelle d'une échelle de 13 à 100, jusqu'à une échelle de zéro à un, et reformées pour que la fonction de transformation d'ajustement accepte des données unidimensionnelles. Enfin, l'instructeur montre comment construire un réseau de neurones artificiels sur ces données, en utilisant un modèle séquentiel de l'API keras.
  
  
• 00:20:00 Dans cette section de la vidéo, le présentateur explique comment créer un modèle de réseau neuronal à l'aide de l'API Keras intégrée à TensorFlow. Le modèle est un modèle séquentiel et est créé en tant qu'instance de la classe Sequential. La première couche dense crée la première couche cachée et comporte 16 unités avec la fonction d'activation ReLU. La deuxième couche dense crée la deuxième couche cachée et comporte 32 unités avec la fonction d'activation ReLU. La dernière couche est la couche de sortie avec deux unités représentant les deux classes de sortie possibles. Le présentateur explique que la couche de sortie est suivie de la fonction Softmax, qui donne des probabilités pour chaque classe de sortie. Le présentateur montre ensuite comment utiliser la fonction model.summary() pour afficher un résumé visuel de l'architecture du modèle.
  
  
• 00:25:00 Dans cette section, nous apprenons à entraîner un réseau de neurones sur les données créées et traitées dans les sections précédentes. Après avoir construit notre modèle, nous le compilons avec la perte, l'optimiseur et les métriques appropriés. Nous spécifions ensuite les données d'entrée, les données cibles, la taille du lot et le nombre d'époques pour la formation dans la fonction d'ajustement. L'entraînement commence et nous voyons qu'en 30 époques, notre modèle simple atteint une précision de 94 % sans trop d'effort. C'est un excellent exemple de la facilité de démarrage avec Keras.
  
  
• 00:30:00 Dans cette section, le concept d'ensemble de validation est expliqué dans le contexte de la formation de modèles d'apprentissage automatique, et l'importance de son utilisation est mise en évidence. La création d'un ensemble de validation permet aux utilisateurs d'évaluer dans quelle mesure un modèle se généralise sur des données sur lesquelles il n'a pas été formé. Le surajustement peut être évité en examinant la précision des résultats de l'ensemble de validation, qui ne doit pas être significativement inférieure à celle des données d'apprentissage. Deux méthodes pour créer et utiliser des ensembles de validation avec un modèle séquentiel Keras sont discutées, la seconde méthode permettant à Keras de créer l'ensemble de validation pour l'utilisateur.
  
  
• 00:35:00 Dans cette section, la vidéo explique comment créer un ensemble de validation à partir de l'ensemble d'apprentissage à l'aide du paramètre de fractionnement de validation, qui divise un pourcentage spécifié des données d'apprentissage en un ensemble de validation. La vidéo note que l'ensemble de validation est complètement tenu en dehors de l'ensemble d'apprentissage et sera créé à la volée chaque fois que la fonction d'ajustement est appelée. Il est également important de mélanger les données d'apprentissage avant de les transmettre pour s'assurer que l'ensemble de validation n'est pas seulement le dernier X pour cent des données non mélangées. La vidéo explique également comment utiliser l'ensemble de validation pour vérifier si le modèle est sur-ajusté ou se généralise bien, et discute de l'étape suivante d'utilisation d'un ensemble de test pour l'inférence.
  
  
• 00:40:00 Dans cette section, l'instructeur explique le processus d'inférence dans l'apprentissage en profondeur. L'inférence est le processus de déploiement d'un modèle formé sur les ensembles de données du monde réel pour obtenir les prédictions sur de nouvelles données que le modèle n'a pas vues auparavant. Pour s'assurer que le modèle peut se généraliser suffisamment bien pour faire des prédictions précises sur de nouvelles données, l'instructeur suggère d'utiliser un ensemble de tests. L'ensemble de test doit être traité dans le même format que les données d'apprentissage. L'auteur montre comment procéder en mélangeant les données de test, en les mettant à l'échelle entre 0 et 1, et en prédisant les données de test avec un modèle formé pour obtenir la probabilité de la classe à laquelle appartient chaque élément de l'ensemble de test.
  
  
• 00: 45: 00 Dans cette section, nous examinons l'utilisation d'une matrice de confusion pour observer visuellement dans quelle mesure un modèle de réseau neuronal prédit les données de test. En important les packages nécessaires et en créant une matrice de confusion à l'aide de scikit-learn, nous pouvons comparer les véritables étiquettes de l'ensemble de test avec les étiquettes prédites, et ainsi mieux comprendre la précision des prédictions de notre modèle. Nous voyons également comment tracer la fonction de matrice de confusion et comment certaines valeurs y sont obtenues, prétraitées et visualisées. Un lien vers une fonction utile pour le cours Keras avec TensorFlow est également disponible sur le blog Deep Lizard.
  
  
• 00:50:00 Dans cette section, l'instructeur montre comment tracer une matrice de confusion pour visualiser la précision des prédictions du modèle. Le graphique affiche les libellés prédits sur l'axe des x et les véritables libellés sur l'axe des y. Les prédictions correctes sont affichées dans des carrés bleus allant en diagonale du haut à gauche vers le bas à droite du tracé. La matrice de confusion permet à l'utilisateur de visualiser les performances du modèle et d'identifier les classes qui pourraient nécessiter des améliorations. L'instructeur explique que la matrice de confusion est un excellent outil à utiliser pour évaluer les performances d'un modèle et qu'elle peut aider à déterminer quelles classes nécessitent un travail supplémentaire. Enfin, l'instructeur montre comment enregistrer un modèle séquentiel Keras à l'aide de la fonction `.save()`, qui enregistre l'architecture, les pondérations et la configuration d'entraînement du modèle dans un fichier h5.
  
  
• 00:55:00 Dans cette section, l'instructeur passe en revue les différentes manières d'enregistrer et de charger un modèle dans Keras avec TensorFlow. La première option, et la plus complète, consiste à enregistrer et à charger tout ce qui concerne le modèle, y compris son architecture, ses poids et sa configuration d'entraînement. La deuxième option consiste à enregistrer uniquement l'architecture du modèle à l'aide de la fonction "vers JSON", qui peut ensuite être utilisée pour créer ultérieurement un nouveau modèle avec la même architecture. La troisième option consiste à enregistrer uniquement les poids du modèle à l'aide de la fonction "enregistrer les poids", qui peut être chargée dans un nouveau modèle pour mettre à jour ses poids, mais n'enregistre aucun autre détail sur le modèle. L'instructeur explique également que le même processus peut être effectué en utilisant des chaînes YAML au lieu de chaînes JSON.

• 01:00:00 Dans cette section, le présentateur discute du chargement des poids dans un nouveau modèle Keras avec la même architecture que le modèle d'origine. Il explique que la forme des poids chargés doit correspondre à la forme de l'architecture du modèle pour que le mappage des poids fonctionne. Le présentateur montre ensuite comment charger et remplir un nouveau modèle avec les poids du modèle d'origine à l'aide des fonctions "charger les poids" et "obtenir les poids" de Keras. La section passe ensuite à un nouveau sujet, qui prépare et traite les données d'image pour former un réseau neuronal convolutif afin de classer les images comme chats ou chiens, en utilisant l'ensemble de données de la compétition Kaggle chats contre chiens. Le présentateur explique les étapes manuelles et programmatiques nécessaires pour préparer les données pour le traitement.
  
  
• 01:05:00 Dans cette section, l'instructeur organise les données en trois sous-ensembles : ensembles d'entraînement, de validation et de test. L'ensemble de données utilisé dans le didacticiel contient 25 000 images de chats et de chiens, mais pour accélérer le processus de formation, seules 1 000 images sont utilisées pour la formation, 200 pour la validation et 100 pour les tests. Les données sont organisées dans différents répertoires pour chaque ensemble, et la structure du répertoire est vérifiée pour s'assurer qu'elle n'existe pas déjà. Les images sont sélectionnées au hasard en fonction des noms de fichiers, où les images de chat et de chien ont les mots "chat" et "chien" dans leurs noms de fichier respectifs. Enfin, le chemin d'accès aux données est spécifié pour chaque ensemble afin de pointer vers l'emplacement correct sur le disque.
  
  
• 01:10:00 Dans cette section, la vidéo explique comment préparer des données pour un modèle séquentiel Keras en créant des lots de données à l'aide du générateur de données d'image. Les ensembles de formation, de validation et de test sont définis et redimensionnés à une hauteur et une largeur spécifiées pour l'uniformité. La fonction de prétraitement, tf.keras.applications.VGG16.preprocess_input, est appliquée aux images avant qu'elles ne soient transmises au réseau. La vidéo avertit les téléspectateurs de ne pas insister sur les détails techniques du prétraitement, comme cela sera expliqué dans les prochains épisodes. De plus, la vidéo spécifie que le mélange est égal à faux pour l'ensemble de test, expliquant que lors de l'exécution de l'inférence, les étiquettes non réglées de l'ensemble de test sont nécessaires pour afficher les résultats de prédiction dans une matrice de confusion, et les données ne doivent pas être mélangées pour y accéder.
  
  
• 01:15:00 Dans cette section, l'instructeur montre comment obtenir et organiser des données d'image pour un réseau neuronal convolutionnel. Les lots de trains, composés de dix images et des étiquettes correspondantes, sont tracés à l'aide d'une fonction de prétraitement qui fausse les données de couleur RVB. Cependant, les images peuvent toujours être distinguées comme un chat ou un chien à l'aide d'un vecteur codé à chaud pour les étiquettes. L'instructeur note que parfois les étiquettes correspondantes pour l'ensemble de test peuvent ne pas être disponibles, et dirige les téléspectateurs vers le blog pour obtenir des conseils sur la gestion de tels cas. L'épisode se termine par un aperçu de la section suivante où un réseau neuronal convolutif sera construit et formé sur des données d'images de chats et de chiens.
  
  
• 01:20:00 Dans cette section du didacticiel TensorFlow, un modèle séquentiel Keras est utilisé pour le premier réseau de neurones à convolution (CNN). La première couche du modèle est une couche convolutive 2D avec 32 filtres et une taille de noyau de 3x3, suivie de la fonction d'activation ReLU populaire avec un "même" rembourrage pour mettre à zéro les images. La forme d'entrée est spécifiée comme 224x224x3 pour les images au format RVB. La première couche convolutive est ensuite suivie d'une couche de pooling max avec une taille de pool de 2x2 et des foulées de 2. Une autre couche convolutive 2D, similaire à la première mais avec 64 filtres au lieu de 32, est ajoutée suivie d'une autre couche de pooling max. La sortie aplatie de la couche de regroupement maximum est ensuite transmise à une couche de sortie dense avec deux nœuds correspondant respectivement à chat et chien. La couche de sortie est suivie par la fonction d'activation softmax pour donner des probabilités pour chaque sortie correspondante du modèle.
  
  
• 01:25:00 Dans cette section, l'instructeur explique comment former un modèle à l'aide de Keras avec TensorFlow et comment utiliser un générateur contenant des données d'étiquette pour la validation lors de l'ajustement du modèle. Le modèle est entraîné avec la compilation, puis la fonction d'ajustement est définie à l'aide des ensembles d'entraînement et de validation, et l'époque et la verbosité sont définies. L'avertissement qui se produit pendant la formation est un bogue dans TensorFlow, et l'instructeur indique comment ignorer cet avertissement. Les résultats montrent que si la précision sur l'ensemble d'apprentissage est de 100 %, la précision de la validation n'est que de 69 %, ce qui indique un surajustement. Le modèle nécessitera une attention supplémentaire pour lutter contre le problème de surajustement s'il doit être utilisé en production. Le prochain épisode explorera comment le modèle formé résiste à l'inférence dans la prédiction sur les images de l'ensemble de test.
  
  
• 01:30:00 Dans cette section de la vidéo, l'instructeur explique le processus d'utilisation d'une fonction de tracé d'images pour tracer un lot de données de test à partir de lots de test et imprimer les étiquettes correspondantes pour les images. L'instructeur insiste sur l'importance de ne pas mélanger l'ensemble de données de test pour assurer le mappage correct entre les étiquettes et les échantillons. Ensuite, les prédictions sont obtenues en appelant model.predict avec des lots de test spécifiés en entrée. L'instructeur imprime les prédictions arrondies et explique comment les interpréter. Ils mentionnent également l'utilisation d'une matrice de confusion pour visualiser les résultats, et la fonction de matrice de confusion de scikit-learn est utilisée avec les véritables étiquettes transmises à l'aide de classes de lots de test.
  
  
• 01:35:00 Dans cette section, la vidéo explique comment tracer une matrice de confusion pour évaluer les performances du modèle dans la classification des images de chats et de chiens à l'aide de l'API Keras de TensorFlow. La matrice de confusion est tracée à l'aide d'une fonction de scikit-learn et les indices de classe sont ajustés en conséquence. La diagonale de la matrice de confusion représente les prédictions correctes et le modèle semble sur-ajusté. La section suivante montrera comment affiner un modèle VGG 16 pré-formé pour classer les images de chats et de chiens, qui a remporté le concours ImageNet 2014. La vidéo explique également brièvement la fonction de prétraitement VGG 16, qui soustrait uniquement la valeur RVB moyenne calculée à partir de chaque pixel de l'ensemble d'apprentissage des données d'image.
  
  
• 01:40:00 Dans cette section, l'instructeur explique le prétraitement qui a été effectué pour le modèle VGG-16 et comment les nouvelles données doivent être traitées de la même manière pour correspondre à la façon dont VGG-16 a été formé à l'origine. L'instructeur mentionne que Keras a des fonctions intégrées pour les modèles populaires comme VGG-16, qui a mis en place un prétraitement qui correspond au modèle correspondant. L'instructeur explique également que le modèle VGG-16 prévoyait à l'origine pour 1000 classes imageNet différentes, et l'objectif est de changer la dernière couche de sortie pour ne prédire que deux classes de sortie correspondant au chat et au chien. Enfin, l'instructeur crée un nouveau modèle séquentiel en parcourant chaque couche VGG-16 et en excluant la dernière couche de sortie. Ce nouveau modèle est destiné à être peaufiné et n'a que deux classes de sortie.
  
  
• 01:45:00 Dans cette section, nous voyons comment modifier et entraîner le modèle VGG 16 affiné sur un ensemble de données de chats et de chiens. La dernière couche du modèle, qui prédit 1 000 classes de sortie, a été supprimée et une nouvelle couche dense qui n'a que deux classes de sortie pour chat et chien est ajoutée. Toutes les couches précédentes ont été définies pour ne pas être formables, à l'exception de la couche de sortie contenant 8000 paramètres formables. Le modèle est compilé en utilisant l'entropie croisée catégorielle comme perte et précision comme métrique, et il est formé à l'aide de la méthode fit () en lui transmettant l'ensemble de données d'apprentissage et l'ensemble de validation.
  
  
• 01:50:00 Dans cette section, l'instructeur discute des résultats de l'entraînement du modèle VGG 16 sur des images de chats et de chiens avec une spécificité sur la précision des ensembles d'entraînement et de validation. Le modèle VGG 16 avait déjà été entraîné sur des images de chats et de chiens de la bibliothèque de réseaux d'images, et l'entraînement en cours sur la couche de sortie consiste à entraîner le modèle à ne générer que des classes de chats ou de chiens. En seulement cinq époques, le modèle VGG 16 avait une précision d'entraînement de 99 %, tandis que la précision de validation était équivalente à 98 %, ce qui indique à quel point ce modèle se généralise aux données de chat et de chien dans les ensembles de validation par rapport au réseau neuronal convolutif simple. Dans le prochain épisode, le modèle VGG 16 affiné sera utilisé pour l'inférence afin de prédire les images de chat et de chien dans l'ensemble de test, et compte tenu de la précision de l'ensemble de validation, nous devrions également nous attendre à voir de bons résultats sur l'ensemble de test. .
  
  
• 01:55:00 Dans cette section de la vidéo, l'instructeur discute de l'utilisation d'une matrice de confusion pour évaluer les performances d'un modèle VGG16 affiné sur un ensemble de test invisible. La diagonale de la matrice de confusion est examinée, ce qui révèle que le modèle a atteint un taux de précision de 96 %. Alors que l'approche de réglage fin adoptée pour le modèle VGG16 était minime, l'instructeur explique que les prochains épisodes couvriront davantage de méthodes de réglage fin sur d'autres modèles pré-formés, tels que MobileNets. Ces modèles plus petits et à faible consommation d'énergie sont mieux adaptés au déploiement sur des appareils mobiles en raison de leur taille et de leur nombre de paramètres considérablement plus petits.

• 02:00:00 Dans cette section de la vidéo, l'instructeur présente MobileNets - une alternative plus petite et plus rapide aux modèles plus gros comme le VGG 16. Bien que les MobileNets ne soient pas aussi précis que certains de ces modèles lourds, la réduction de la précision est relativement faible. L'instructeur parcourt les étapes pour télécharger et travailler avec MobileNets dans un Jupyter Notebook, y compris l'importation des packages nécessaires, le téléchargement et l'attribution du modèle MobileNet, et la création d'une fonction appelée « prepare_image » pour redimensionner et formater les images avant de les transmettre via le MobileNet. modèle de traitement. Dans l'ensemble, l'accent est mis sur la compréhension des compromis entre précision et taille/vitesse lorsque vous travaillez avec différents modèles d'apprentissage en profondeur et sur la manière de les utiliser efficacement.
  
  
• 02:05:00 Dans cette section, l'instructeur montre comment utiliser un modèle MobileNet pré-formé pour prédire les cinq premières classes possibles d'images données. Ils affichent d'abord une image de lézard et la transmettent à une fonction de prétraitement avant de la transmettre à la fonction de prédiction de MobileNet. MobileNet prédit les trois premières classes avec des probabilités élevées, le caméléon américain étant le plus probable. Ils répètent le même processus avec une image d'une tasse de café et le modèle prédit qu'il s'agit d'un expresso avec une probabilité de 99 %. Enfin, ils transmettent une image de fraise au modèle et obtiennent les prédictions pour les meilleures classes possibles.
  
  
• 02:10:00 Dans cette section de la vidéo, le présentateur montre les résultats des prédictions du modèle de réseau mobile pour un échantillon aléatoire d'images, qui comprend une fraise et d'autres fruits. Le présentateur mentionne que bien qu'il y ait eu une petite réduction de la précision du modèle, cela n'est pas perceptible lors de tests comme ceux montrés dans la vidéo. L'étape suivante consiste à affiner le modèle de réseau mobile pour un ensemble de données personnalisé composé de chiffres en langue des signes. Le présentateur montre comment organiser l'ensemble de données sur disque et le déplacer vers le répertoire de travail avant de le traiter par programmation dans un Jupyter Notebook.
  
  
• 02:15:00 Dans cette section, l'instructeur explique comment organiser les données d'image dans des répertoires d'apprentissage, de validation et de test à l'aide d'un script Python. La première étape consiste à vérifier le nombre d'échantillons dans chaque classe, qui va de 204 à 208. Ensuite, à l'aide d'une boucle for, le script déplace chaque répertoire de classe vers le répertoire train et crée des répertoires séparés pour les ensembles valides et de test pour chaque classe. . Enfin, le script échantillonne des images aléatoires de chaque classe dans le répertoire train, les déplace vers le répertoire valide, et échantillonne plus d'images et les déplace vers le répertoire test. Après l'exécution du script, les données sont organisées dans des répertoires distincts pour chaque ensemble, et le nombre d'images dans chaque classe peut être vérifié en vérifiant les répertoires correspondants.
  
  
• 02: 20: 00 Dans cette section de la vidéo, l'orateur discute de la structure organisationnelle de l'ensemble de données avec lequel il travaillera, qui est similaire à l'ensemble de données sur les chats et les chiens utilisé plus tôt dans le cours, mais contient maintenant 10 classes au lieu de deux. Ils montrent ensuite comment prétraiter les données en définissant les répertoires d'entraînement, de validation et de test et en créant des itérateurs de répertoire à l'aide du générateur de données d'image. La fonction de prétraitement utilisée est la fonction de prétraitement de réseau mobile, qui met à l'échelle les données d'image pour qu'elles soient sur une échelle de moins un à un. Les paramètres de l'itérateur, tels que la taille de l'image cible et la taille du lot, sont également définis. L'orateur souligne l'importance de pointer correctement l'itérateur vers l'emplacement de l'ensemble de données sur le disque, car un pointage incorrect pourrait entraîner la recherche d'images nulles.
  
  
• 02:25:00 Dans cette section du cours Keras avec TensorFlow, l'instructeur explique comment affiner le modèle MobileNet préformé pour une nouvelle tâche de classification. La première étape consiste à télécharger le modèle MobileNet et à examiner ses couches à l'aide de la fonction "model.summary()". Ils sélectionnent ensuite les couches jusqu'à la sixième à la dernière couche et créent une nouvelle couche de sortie dense avec 10 unités. Ceci est suivi par la création d'un nouveau modèle fonctionnel qui transmet toutes les couches précédentes jusqu'à la sixième à la dernière couche et le réseau mobile à la couche de sortie. Le nouveau modèle est créé et l'étape suivante consiste à geler toutes les couches sauf les 23 dernières pour la formation. L'instructeur note que le nombre de calques à geler nécessite une expérimentation personnelle et peut varier en fonction de la tâche.
  
  
• 02:30:00 Dans cette section, l'instructeur affine le modèle MobileNet d'origine, en entraînant uniquement les 23 dernières couches et en remplaçant la couche de sortie par une couche comportant 10 classes au lieu de 1 000. Le modèle est compilé et formé à l'aide de l'optimiseur Adam avec un taux d'apprentissage de 0,0001 et une fonction de perte d'entropie croisée catégorielle. Après un entraînement de 30 époques, le modèle atteint une précision de 100 % sur l'ensemble d'apprentissage et une précision de 92 % sur l'ensemble de validation. Bien qu'il y ait un certain surajustement, avec une précision de validation inférieure à la précision de l'entraînement, l'instructeur suggère que l'exécution de plus d'époques ou le réglage d'hyperparamètres peut aider à réduire le problème de surajustement.
  
  
• 02:35:00 Dans cette section de la vidéo, l'instructeur montre comment utiliser un modèle affiné sur l'ensemble de test et tracer les prédictions sur une matrice de confusion. La matrice de confusion indique que le modèle a bien fonctionné avec des prédictions généralement correctes sur l'ensemble de test. Le modèle a une précision de 90 % sur l'ensemble de test, ce qui est attendu compte tenu de la précision sur l'ensemble de validation. L'instructeur souligne que la série sur MobileNet a fourni un aperçu de la façon d'affiner les modèles pour les ensembles de données personnalisés et d'utiliser l'apprentissage par transfert. Le prochain épisode montrera comment utiliser l'augmentation de données sur les images à l'aide de l'API Keras de TensorFlow.
  
  
• 02:40:00 Dans cette section, l'importance de l'augmentation des données pour l'apprentissage en profondeur est mise en évidence, en particulier lorsqu'il n'y a pas suffisamment de données pour entraîner le modèle. L'augmentation des données peut aider à réduire le surajustement et à augmenter la taille de l'ensemble d'apprentissage. Le code pour augmenter les données d'image à l'aide de Keras est ensuite introduit, où un générateur de données d'image est créé et divers paramètres d'augmentation sont spécifiés, tels que la plage de rotation, la plage de décalage de largeur et la plage de zoom. Une image aléatoire d'un répertoire de chiens est choisie et la fonction de flux est appelée pour générer un lot d'images augmentées à partir de cette image unique. Les images augmentées résultantes sont ensuite tracées à l'aide d'une fonction d'images de tracé prédéfinie.
  
  
• 02:45:00 Dans cette section, l'instructeur traite de l'augmentation des données, qui est une méthode d'augmentation artificielle de la taille d'un ensemble de données en créant des variations de données existantes. En examinant différentes images, l'instructeur identifie les types d'augmentation de données qui leur ont été appliqués, tels que le déplacement, le retournement et la rotation, et explique comment cette technique peut être utile pour développer un ensemble de données. En augmentant la variété de l'ensemble de données, un modèle peut devenir plus robuste et mieux classer les données. L'instructeur fournit également une brève instruction pour enregistrer ces images augmentées sur le disque et les ajouter à l'ensemble de formation.

[MetaQuotes]

Cours accéléré Scikit-learn - Bibliothèque d'apprentissage automatique pour Python

Cours accéléré Scikit-learn - Bibliothèque d'apprentissage automatique pour Python

La vidéo "Scikit-learn Crash Course" donne un aperçu de l'utilisation de la bibliothèque Scikit-learn pour l'apprentissage automatique en Python. La vidéo couvre la préparation des données, la création et l'ajustement du modèle, le réglage des hyperparamètres via la recherche de grille et l'évaluation du modèle. L'importance du prétraitement et des transformateurs dans l'amélioration des performances du modèle est soulignée, avec des exemples de détartreur standard et de transformateur quantile. La vidéo traite également de l'importance de l'évaluation du modèle et du choix de la bonne métrique pour le problème, ainsi que de la gestion des ensembles de données déséquilibrés et des catégories inconnues dans un codage à chaud. Le conférencier met l'accent sur la compréhension de l'ensemble de données et des biais potentiels dans les prédictions du modèle, et fournit un exemple de détection de fraude par carte de crédit.

La deuxième partie de la vidéo couvre plusieurs sujets, notamment la recherche de grille, les métriques, les pipelines, le réglage des seuils, la modélisation des séries chronologiques et la gestion des valeurs aberrantes. L'instructeur explore l'utilisation de métriques personnalisées et l'importance d'équilibrer la précision et le rappel dans la création de modèles. De plus, le classificateur de vote est présenté comme un méta-estimateur qui augmente la flexibilité et l'expressivité du modèle. La vidéo se termine par la présentation de l'outil Human Learn, qui permet de construire et de comparer des systèmes basés sur des règles pouvant être combinés avec des algorithmes d'apprentissage automatique. En outre, l'outil FunctionClassifier est exploré, ce qui permet aux utilisateurs de créer une logique personnalisée en tant que modèle de classificateur et d'ajouter des comportements tels que la détection des valeurs aberrantes. Dans l'ensemble, la vidéo fournit un aperçu complet de Scikit-learn et de son API flexible, soulignant l'importance de comprendre les métriques pertinentes pour la création et la personnalisation de modèles.

• 00:00:00 Les données y. X contient les caractéristiques ou les variables d'entrée, tandis que Y contient la cible ou la variable de sortie que nous voulons prédire. Nous avons divisé les données en un ensemble d'apprentissage et un ensemble de test pour évaluer les performances du modèle. Ensuite, nous devons prétraiter les données. L'une des techniques de prétraitement les plus importantes est la mise à l'échelle, qui consiste à normaliser les valeurs des caractéristiques afin qu'elles se situent toutes dans une plage similaire. Cela aide le modèle à apprendre plus efficacement. Enfin, nous choisissons un modèle et l'entraînons sur l'ensemble d'entraînement. Une fois le modèle formé, nous évaluons ses performances sur l'ensemble de test et faisons des prédictions sur de nouvelles données. Dans les sections suivantes, nous approfondirons les sujets du prétraitement, de l'évaluation du modèle et des méta estimateurs.
  
  
• 00:05:00 Dans cette section, le conférencier explique comment diviser les données en ensembles x et y pour les modèles d'apprentissage automatique. L'ensemble x représente les données utilisées pour faire des prédictions, tandis que l'ensemble y contient la prédiction d'intérêt. À l'aide de la bibliothèque scikit-learn, les utilisateurs peuvent charger des ensembles de données de référence à des fins éducatives. Le conférencier explique également le processus en deux phases de création et d'ajustement d'un modèle pour apprendre des données afin de faire des prédictions. Le modèle k-plus proche voisin est utilisé comme exemple, mais le modèle de régression linéaire est également présenté pour illustrer comment différents modèles peuvent toujours avoir la même API dans scikit-learn.
  
  
• 00: 10: 00 Dans cette section, la vidéo du cours intensif Scikit-learn explique comment le modèle du voisin le plus proche K fonctionne dans un ensemble de données simple qui présente les pieds carrés d'une maison et sa proximité avec les écoles. Le modèle fait des prédictions basées sur les 5 voisins les plus proches, mais le défi peut survenir lors de l'utilisation de distances qui ont des échelles différentes, ce qui signifie qu'un axe peut avoir un effet beaucoup plus important sur les prédictions qu'un autre. Cela nécessite de repenser ce qu'est un modèle d'apprentissage automatique et suggère qu'il doit y avoir un prétraitement avant que les données ne soient transmises au modèle K-plus proche voisin, de sorte que la mise à l'échelle soit effectuée avant que les prédictions ne soient faites, et que tout ce qui se trouve à l'intérieur du pré- la boîte de traitement fait partie du modèle.
  
  
• 00: 15: 00 Dans cette section, la vidéo explore le concept de pipeline dans Scikit-learn, qui permet le chaînage des étapes de traitement et l'appel de dot fit et dot predict pour l'ensemble du pipeline lorsqu'il est formé. En utilisant un pipeline, il est possible de gérer automatiquement les étapes de prétraitement, telles que la mise à l'échelle et la normalisation, pour apprendre des données afin d'assurer un système robuste. Cependant, cette approche introduit un problème où le modèle est autorisé à mémoriser les données d'origine. La vidéo montre comment le graphique suggère à tort une prédiction parfaite, mais le modèle ne peut le faire que parce qu'il est autorisé à mémoriser le point de données d'origine, empêchant une comparaison équitable et une prévisibilité fiable sur de nouvelles données.
  
  
• 00: 20: 00 Dans cette section, l'instructeur explique la méthode d'évaluation des performances d'un modèle à l'aide d'un ensemble de données de test distinct pour éviter de juger le modèle sur le même ensemble de données sur lequel il a été formé. Il suggère de diviser l'ensemble de données en segments et d'en utiliser un pour la formation et les autres pour les tests. De plus, il présente l'objet cv de recherche de grille de Scikit-learn, qui permet une validation croisée automatisée pour déterminer les meilleurs hyperparamètres à utiliser dans le modèle. Cet objet peut être utilisé avec le pipeline créé précédemment pour affiner le modèle et améliorer ses capacités prédictives.
  
  
• 00:25:00 Dans cette section, l'instructeur passe en revue divers paramètres du modèle KNearestNeighbors et montre comment utiliser l'objet GridSearch pour trouver le meilleur ensemble d'hyperparamètres. L'objet GridSearch effectuera automatiquement une validation croisée et gardera une trace des résultats, ce qui facilitera l'analyse et le choix de la meilleure configuration. Cependant, l'instructeur souligne que s'il est important d'utiliser l'API et les blocs de construction appropriés lorsque vous travaillez avec scikit-learn, il est tout aussi important de comprendre et d'analyser l'ensemble de données utilisé. L'instructeur montre comment accéder et afficher la description d'un ensemble de données et souligne l'importance de prendre le temps de comprendre les variables de l'ensemble de données avant de construire un modèle.
  
  
• 00: 30: 00 Dans cette section, l'orateur discute des pièges potentiels de l'application aveugle de modèles d'apprentissage automatique sans comprendre pleinement les données utilisées pour la formation et la prédiction. Même des variables apparemment anodines, telles que la proportion d'une certaine race dans une ville, peuvent conduire à des algorithmes biaisés, voire racistes. Le conférencier souligne l'importance d'examiner et de tester minutieusement le modèle avant de le déployer en production. L'utilisation de la recherche par grille et d'autres méthodes peut fournir des garanties statistiques, mais elle peut également créer un faux sentiment d'optimisme et provoquer des angles morts. Il est de la responsabilité de l'utilisateur de se renseigner sur les données utilisées et d'envisager des mécanismes éthiques et de rétroaction, ainsi que des scénarios de secours en cas de problème en production.
  
  
• 00:35:00 Dans cette section, l'importance de la transformation des données dans la construction de modèles est mise en évidence. La vidéo traite de l'utilisation des transformateurs et de leur importance dans l'amélioration des performances du modèle. Le scaler standard de Scikit-Learn est utilisé pour redimensionner un ensemble de données, et bien que ses performances soient bonnes, la vidéo montre comment il pourrait être amélioré en utilisant d'autres méthodes de mise à l'échelle. L'approche consiste à soustraire la moyenne de l'ensemble de données et à diviser par l'écart type. Bien que l'approche mette à l'échelle les données, elle laisse des valeurs aberrantes, ce qui peut affecter certains algorithmes. La vidéo souligne en outre l'importance du prétraitement pour obtenir les résultats souhaités du modèle.
  
  
• 00:40:00 Dans cette section de la vidéo, l'orateur discute du concept de normalisation et comment l'utiliser efficacement en calculant des quantiles au lieu de valeurs moyennes. En utilisant des quantiles, l'effet des valeurs aberrantes sur les données est réduit et le processus devient plus robuste. L'orateur montre comment mettre en œuvre le transformateur quantile en tant qu'étape de prétraitement, en remplacement du scaler standard, pour obtenir de meilleurs résultats dans les modèles d'apprentissage automatique. L'effet profond du transformateur sur les données de sortie est illustré par une fonction de sortie de tracé qui forme un modèle k plus proche voisin et produit des prédictions à la fois pour l'échelle standard et le transformateur quantile.
  
  
• 00:45:00 Dans cette section de la vidéo, l'orateur explique comment le prétraitement peut affecter considérablement la classification des ensembles de données. Dans le premier exemple, le locuteur utilise le transformateur quantile qui rend le modèle plus stable et mieux adapté pour traiter les valeurs aberrantes à long terme. Le deuxième exemple montre comment l'ajout de nouvelles fonctionnalités peut améliorer les performances du modèle. En générant des caractéristiques non linéaires telles que x1 fois x2 et x1 à la puissance 2 et x2 à la puissance 2 via des caractéristiques polynomiales, le modèle de régression logistique a pu produire une classification presque parfaite. Enfin, le One Hot Encoder est présenté comme une technique de transformation de texte ou de catégories en données numériques, utile pour prédire des classes de risque faible, moyen ou élevé.
  
  
• 00:50:00 Dans cette section, la vidéo explique comment gérer les catégories inconnues lors de l'utilisation de l'encodage one-hot avec la bibliothèque Scikit-learn. Le présentateur explique que si l'encodeur est invité à transformer des données qu'il n'a pas vues auparavant, cela entraînera une erreur de valeur. Cependant, cela peut être modifié en ajustant le paramètre "handle_unknown" sur "ignore". La vidéo présente également un site Web appelé "DrawData.xyz", qui permet aux utilisateurs de créer leurs propres ensembles de données pour s'entraîner au prétraitement et aux pipelines. L'intervenant souligne que les étapes de pré-traitement sont cruciales car elles peuvent fortement impacter le résultat du modèle. Enfin, la vidéo explique les avantages de l'utilisation d'une grille de recherche pour comparer plusieurs modèles et choisir le meilleur pour la prédiction, en utilisant un ensemble de données sur la fraude par carte de crédit comme exemple.
  
  
• 00:55:00 Dans cette section, la vidéo explique l'importance de choisir la bonne métrique et comment Scikit-learn la gère. La vidéo utilise un ensemble de données de fonctionnalités anonymisées et de montants de transaction pour démontrer comment Scikit-learn peut être utilisé pour prédire avec précision les cas de fraude. Cependant, comme l'ensemble de données est déséquilibré avec plus de cas de fraude que de cas de non-fraude, le modèle ne parvient pas à converger avec le nombre d'itérations par défaut. Par conséquent, le nombre maximal d'itérations est augmenté et le paramètre de poids de classe est ajusté pour doubler le poids des cas de fraude afin d'améliorer la détection de fraude du modèle. La vidéo présente également GridSearchCV pour trouver la meilleure valeur pour le paramètre de poids de classe.

• 01:00:00 Dans cette section, l'instructeur explique comment utiliser la recherche par grille pour trouver les meilleurs paramètres de modèle pour la régression logistique dans scikit-learn. En définissant une grille de valeurs de paramètres, l'instructeur montre comment parcourir ces hyper-paramètres et les tester à l'aide de la validation croisée. L'objet grid renvoie un dictionnaire de résultats, y compris le poids et les scores de la classe. Le modèle de régression logistique a une méthode liée appelée score, qui est utilisée pour déterminer le meilleur modèle. L'instructeur présente ensuite deux métriques du module de métriques scikit-learn, la précision et le score de rappel, et explique comment les inclure dans la recherche de grille à l'aide d'un dictionnaire de notation.
  
  
• 01:05:00 Dans cette section, l'orateur ajoute les scores de précision du test et de rappel du test et définit un indicateur qui permettra l'ajout de scores de train aux résultats de la validation croisée. Ils augmentent ensuite le nombre de validations croisées et remplacent la plage de quatre par un espace linéaire numérique, en définissant une valeur plus élevée pour indiquer à l'algorithme de se concentrer sur les cas de fraude. Ils font des tableaux résumant les résultats, notant que se concentrer sur le rappel ou la précision aboutit à un résultat complètement différent. Ils décident alors de créer leur métrique, la précision de rappel min, qui calcule le minimum entre précision et rappel, et l'ajoute à la grille de recherche. Ils le font pour équilibrer les deux métriques et ont un modèle qui équilibre les scores de rappel et de précision.
  
  
• 01:10:00 , nous utilisons la fonction make_scorer dans la recherche de grille avec notre métrique personnalisée, min_precision_recall, qui accepte y_true et y_pred comme entrée. Cependant, la fonction make_scorer nécessite un estimateur, un ensemble de données X, y vrai et une certaine forme de pondération d'échantillon, de sorte qu'elle transforme notre fonction métrique en un objet marqueur de prédiction qui peut être utilisé dans la recherche de grille. Le poids de l'échantillon est une fonctionnalité supplémentaire qui peut être transmise aux modèles d'apprentissage automatique et nous permet de dire qu'une ligne particulière est plus importante qu'une autre. Au lieu d'utiliser la fonction make_scorer, nous pouvons passer directement l'estimateur et calculer les valeurs y prédites avec la fonction de prédiction.
  
  
• 01:15:00 Dans cette section, l'orateur discute de l'utilisation du poids de l'échantillon dans la détection de la fraude et montre comment il peut être ajouté à une fonction de stabilité numérique. Ils démontrent également l'effet de l'ajout du poids de l'échantillon sur le modèle algorithmique. L'orateur propose ensuite d'utiliser un algorithme de détection des valeurs aberrantes pour détecter la fraude, et montre comment adapter les métriques pour cette approche. Ils remplacent la régression logistique par un algorithme de forêt d'isolement et démontrent comment cela affecte les scores de précision et de rappel. Enfin, l'orateur écrit sa variante des fonctions métriques pour transformer la prédiction des valeurs aberrantes en prédictions d'étiquettes de fraude.
  
  
• 01:20:00 Dans cette section, le narrateur discute de la flexibilité de l'API de Scikit-learn et de la possibilité d'utiliser des algorithmes de détection de valeurs aberrantes comme s'il s'agissait de classificateurs en transmettant des étiquettes y dans des métriques personnalisées. Cela peut être utile pour juger si un modèle de valeur aberrante serait utile dans un problème de classification. Cependant, le narrateur prévient qu'il est important de se préoccuper de la qualité des étiquettes car cela peut avoir un impact significatif sur les mesures du modèle. De plus, le narrateur souligne certains paramètres de personnalisation pour les métriques, comme spécifier si plus est meilleur et la nécessité d'une mesure de probabilité pour certaines métriques. Enfin, le narrateur mentionne la capacité de Scikit-learn à travailler avec des méta-modèles.
  
  
• 01:25:00 Dans cette section, l'instructeur explique le fonctionnement des pipelines scikit-learn et les limites de l'utilisation exclusive de pipelines scikit-learn pour les modèles d'apprentissage automatique. L'instructeur suggère d'utiliser des méta-estimateurs pour contourner les limites des pipelines afin d'ajouter des étapes supplémentaires et des outils de post-traitement à un modèle. L'instructeur fournit un exemple de méta-estimateur, le classificateur de vote, et comment il peut être utilisé pour équilibrer différents modèles pour un ensemble de données en attribuant des poids à chaque estimateur.
  
  
• 01:30:00 Dans cette section, l'instructeur montre l'utilisation d'un classificateur de vote avec scikit-learn, qui peut combiner différents modèles qui fonctionnent de différentes manières pour produire des prédictions plus précises. De plus, ce modèle peut être utilisé comme entrée par d'autres estimateurs, augmentant ainsi la flexibilité et l'expressivité. L'instructeur introduit également l'idée d'ajuster la valeur de seuil dans un modèle de régression logistique pour échanger la précision contre le rappel ou vice versa en utilisant le méta-modèle de seuil. Ceci est démontré par un exemple d'utilisation du modèle de seuil dans une recherche de grille. En utilisant ces techniques fournies par scikit-learn, on peut ajuster les paramètres du modèle et obtenir de meilleures performances.
  
  
• 01:35:00 Dans cette section, l'intervenant parle de l'utilisation d'une grille de recherche pour régler le seuil d'un classificateur binaire. Ils montrent que les courbes de précision et de rappel changent lorsque le seuil change, mais la précision reste relativement constante. L'orateur explique que ce type d'étape de post-traitement est mieux implémenté sous la forme d'un méta-modèle qui accepte un autre modèle en entrée. L'orateur montre ensuite un exemple de construction d'un méta-modèle avec les classes Pipeline et Group( byRegressor de Scikit-learn pour regrouper les données par régime alimentaire, puis utilise un modèle de régression linéaire différent pour chaque groupe. Ils expliquent que ce type de regroupement peut être utile pour situations où l'effet d'une variable catégorique pourrait ne pas simplement être un changement constant.
  
  
• 01:40:00 Dans cette section, la vidéo explique une tâche de série chronologique et montre comment la modéliser à l'aide d'un prédicteur groupé et d'un régresseur factice. Il note que la prévision est bonne pour l'année intermédiaire mais sous-évaluée ces dernières années et dépassée dans le passé. Pour améliorer le modèle, la vidéo suggère de se concentrer sur les données les plus récentes et d'oublier les données passées. Il introduit le concept de poids d'échantillon, qui permet à l'utilisateur de spécifier la quantité à peser pour un point de données particulier. La vidéo montre ensuite comment ajouter une décroissance au modèle, ce qui rend les points de données récents plus importants que les anciens. Ce faisant, le modèle devient plus expressif et fonctionne mieux sur les données récentes tout en ignorant l'historique lointain. Cependant, cette astuce peut entraîner une situation dans laquelle les données d'entraînement ont de moins bonnes performances que les données de test.
  
  
• 01:45:00 Dans cette section, le conférencier présente un outil appelé Human Learn, un projet open-source conçu pour offrir des outils compatibles scikit-learn qui aident à construire et comparer des systèmes basés sur des règles. L'orateur explique que, dans le passé, il était plus courant de faire appel à des experts humains pour élaborer des règles métier et des systèmes de classification des données plutôt que des algorithmes d'apprentissage automatique. Cependant, les modèles d'apprentissage automatique ne sont pas parfaits et peuvent présenter un comportement problématique ou inefficace. L'objectif de Human Learn est de construire des systèmes basés sur des règles qui peuvent être facilement comparés à des modèles d'apprentissage automatique tout en étant combinés avec eux. L'orateur montre comment construire un système basé sur des règles à l'aide de l'ensemble de données Titanic et explique comment Human Learn peut faciliter l'intégration de ces systèmes dans votre flux de travail quotidien.
  
  
• 01:50:00 Dans cette section de la vidéo, l'orateur présente l'outil FunctionClassifier dans scikit-learn qui prend une fonction définie par l'utilisateur et la transforme en un classificateur compatible scikit-learn. L'outil permet également d'optimiser la recherche de grille de tous les paramètres définis dans la fonction de l'utilisateur. L'orateur montre comment utiliser l'outil FunctionClassifier pour effectuer une recherche de grille sur un paramètre de seuil avec un ensemble de données lié à la catastrophe du Titanic. La flexibilité de l'outil permet aux utilisateurs de créer n'importe quelle fonction Python avec une logique personnalisée en tant que modèle de classificateur et d'ajouter des comportements tels que la détection des valeurs aberrantes.
  
  
• 01:55:00 Dans cette section, l'instructeur explique comment les valeurs aberrantes peuvent être gérées dans des modèles d'apprentissage automatique préexistants. En ajoutant une logique devant le modèle, une valeur aberrante peut être identifiée et affectée d'une étiquette différente. Le package permet de construire des systèmes basés sur des règles à l'aide de modèles d'apprentissage automatique préexistants, en trouvant un équilibre entre l'intelligence naturelle et l'intelligence artificielle. L'instructeur utilise le package scikit-lego et la fonction load penguins pour illustrer la prédiction efficace de l'espèce d'un pingouin en fonction de ses propriétés. La fonction utilise un graphique interactif et l'instructeur dessine des polygones autour des points de données à classer. L'algorithme point-in-poly est ensuite utilisé pour classer les points de données. Un classificateur interactif permet de définir un modèle compatible scikit-learn à partir du blob json. Ensuite, des ensembles de données x et y peuvent être générés à partir d'une trame de données, et le modèle peut être utilisé comme n'importe quel modèle de cycleur.

• 02:00:00 Dans cette section, l'orateur met l'accent sur les propriétés et les avantages des modèles d'apprentissage automatique dessinés. En utilisant une fonctionnalité de graphique dans Matplotlib, il montre comment les modèles dessinés prédisent les classifications pour les nouveaux exemples et gèrent efficacement les données manquantes. De plus, l'orateur montre comment le même dessin peut être utilisé comme système de détection des valeurs aberrantes en vérifiant si les points sont à l'extérieur des polygones. Il montre également comment le mécanisme de dessin peut être utilisé pour attribuer des étiquettes aux points de données, même lorsque les étiquettes ne sont pas facilement disponibles, ce qui en fait une étape de prétraitement utile.
  
  
• 02: 05: 00 Dans cette section, l'orateur discute de l'API Interactive Charts, qui est relativement expérimentale et peut agir soit comme un transformateur scikit-learn, soit dans un pipeline pandas pour ajouter deux nouvelles colonnes avec des décomptes concernant l'apparence du point de données dans un polygone. L'orateur recommande d'utiliser des algorithmes d'apprentissage automatique parallèlement aux règles métier pour créer des systèmes basés sur des règles. En outre, l'orateur suggère plusieurs ressources telles que freeCodeCamp, la chaîne YouTube pi data et la page de documentation scikit-learn pour en savoir plus sur l'apprentissage automatique et scikit-learn.

[MetaQuotes]

PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique - Cours complet (parties 1 à 4)

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

Partie 1

• 00:00:00 Dans cette section de la vidéo, l'instructeur, Daniel Bourke, présente aux téléspectateurs le cours PyTorch et définit les attentes pour le didacticiel vidéo adapté aux débutants. Le cours se concentrera sur la mise en œuvre de concepts d'apprentissage automatique dans PyTorch, un framework basé sur Python, où les téléspectateurs apprendront en écrivant du code. Bourke mentionne que le cours couvrira des sujets importants tels que l'apprentissage par transfert, le déploiement de modèles et le suivi des expériences, et si les téléspectateurs veulent en savoir plus sur PyTorch, des ressources supplémentaires sont disponibles sur learn pytorch.io. Enfin, Bourke définit l'apprentissage automatique comme le processus de transformation des données en nombres et de recherche de modèles à l'aide d'algorithmes et de mathématiques, et explique que le cours se concentre sur l'écriture de code, mais les téléspectateurs peuvent trouver des ressources supplémentaires s'ils veulent approfondir les mathématiques. derrière le code.
  
  
• 00:05:00 Dans cette section, la différence entre la programmation traditionnelle et l'apprentissage automatique est expliquée. La programmation traditionnelle implique l'écriture de règles pour une tâche, tandis que les algorithmes d'apprentissage automatique déterminent les règles en fonction des données d'entrée et de sortie. La raison d'utiliser l'apprentissage automatique plutôt que la programmation traditionnelle est pour des problèmes complexes où il devient fastidieux d'écrire toutes les règles manuellement. L'apprentissage automatique peut être utilisé pour n'importe quoi tant qu'il peut être converti en nombres, mais la règle numéro un de l'apprentissage automatique de Google est d'essayer d'abord de construire un système simple basé sur des règles avant de se tourner vers l'apprentissage automatique.
  
  
• 00:10:00 Dans cette section, l'instructeur explique à quoi sert l'apprentissage en profondeur et à quoi il ne sert pas. L'apprentissage en profondeur est utile pour résoudre les problèmes qui nécessitent de longues listes de règles, gérer des environnements en constante évolution et découvrir des informations dans de grands ensembles de données. Cependant, l'apprentissage en profondeur n'est pas idéal pour les tâches qui nécessitent une explicabilité, car les modèles appris par un modèle d'apprentissage en profondeur sont généralement ininterprétables par les humains. De plus, si un système simple basé sur des règles peut résoudre le problème en cours, il peut être préférable de l'utiliser au lieu d'un apprentissage en profondeur.
  
  
• 00:15:00 Dans cette section du cours complet sur PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique, l'instructeur compare l'apprentissage automatique et l'apprentissage en profondeur. Les techniques d'apprentissage automatique traditionnelles, telles que les machines boostées par gradient telles que xg boost, sont les meilleures pour les données structurées en lignes et en colonnes. Pour les données non structurées, comme le langage naturel ou les images, l'apprentissage en profondeur est généralement un meilleur choix. Les modèles d'apprentissage en profondeur sont probabilistes, ce qui signifie qu'ils font un pari sur le résultat, tandis que les systèmes basés sur des règles produisent des résultats prévisibles. De plus, les modèles d'apprentissage en profondeur nécessitent une grande quantité de données pour produire d'excellents résultats, mais il existe des techniques pour obtenir de bons résultats avec moins de données.
  
  
• 00:20:00 Dans cette section, l'instructeur explique la différence entre les données structurées et non structurées et les algorithmes utilisés pour chaque type d'apprentissage automatique et d'apprentissage en profondeur. Les données structurées fonctionnent bien avec des algorithmes superficiels tels que les forêts aléatoires et les machines boostées par gradient, tandis que les données non structurées nécessitent des réseaux de neurones. L'instructeur se penche ensuite sur les types de réseaux de neurones tels que les réseaux de neurones entièrement connectés, les réseaux de neurones convolutionnels, les réseaux de neurones récurrents et les transformateurs. L'instructeur conseille qu'une fois les éléments de base des réseaux de neurones appris, les autres styles de réseaux de neurones deviennent plus faciles à comprendre. La section se termine avec l'instructeur encourageant le spectateur à rechercher et à former sa propre définition des réseaux de neurones avant la prochaine vidéo.
  
  
• 00:25:00 Dans cette section du cours PyTorch, l'instructeur donne un aperçu des réseaux de neurones et de leur anatomie. Les réseaux de neurones se composent d'une couche d'entrée, dans laquelle les données d'entrée sont transformées en nombres, de plusieurs couches cachées, qui manipulent et apprennent des modèles dans les données, et d'une couche de sortie, qui produit les représentations apprises. Le nombre de nœuds dans les couches cachées peut être personnalisé et le réseau neuronal apprend lui-même les représentations, également appelées caractéristiques ou pondérations. Différents types de réseaux de neurones peuvent être utilisés pour différents problèmes, tels que les CNN pour les images et les transformateurs pour le traitement du langage naturel. Une fois que le réseau de neurones produit ses représentations, elles peuvent être converties dans un format compréhensible par l'homme. L'anatomie d'un réseau de neurones peut également être personnalisée, le nombre de couches allant de quelques à plus d'une centaine.
  
  
• 00:30:00 Dans cette section, l'anatomie d'un réseau de neurones est expliquée. Les réseaux de neurones se composent d'une couche d'entrée, d'une ou plusieurs couches cachées, chacune avec de nombreux neurones ou unités cachées, et d'une couche de sortie. Les modèles et les ensembles de données sont transformés en données numériques grâce à l'utilisation de fonctions linéaires et non linéaires. Les motifs sont dessinés à l'aide d'une combinaison de fonctions linéaires et non linéaires pour produire un résultat souhaité. Différents paradigmes d'apprentissage sont discutés, y compris l'apprentissage supervisé, où les données et les étiquettes sont utilisées ensemble, et l'apprentissage non supervisé, où seules les données sont utilisées. Les algorithmes d'apprentissage auto-supervisé utilisent des données pour trouver des modèles, tandis que l'apprentissage par transfert implique l'utilisation de modèles qui ont déjà été appris dans un modèle différent.
  
  
• 00:35:00 Dans cette section, l'instructeur aborde les différents paradigmes de l'apprentissage automatique, en particulier l'apprentissage supervisé, l'apprentissage par transfert et l'apprentissage par renforcement. Bien que l'accent soit mis sur l'apprentissage supervisé et l'apprentissage par transfert dans ce cours, l'instructeur encourage les apprenants à explorer l'apprentissage par renforcement à leur propre rythme. De plus, l'instructeur fournit des exemples d'utilisation de l'apprentissage en profondeur, tels que les systèmes de recommandation, la traduction, la reconnaissance vocale et la vision par ordinateur. La polyvalence de l'apprentissage automatique est soulignée, car tout ce qui peut être converti en nombres et programmé pour trouver des modèles peut être utilisé dans des algorithmes d'apprentissage automatique.
  
  
• 00: 40: 00 Dans cette section de la vidéo, l'instructeur discute des applications potentielles de l'apprentissage en profondeur, telles que la détection d'objets à l'aide de la vision par ordinateur pour capturer les incidents de délit de fuite afin d'identifier la voiture du coupable. L'instructeur explique le concept de traitement du langage naturel et comment il est utilisé dans la détection de spam. La vidéo aborde ensuite les fondements de PyTorch, le framework d'apprentissage en profondeur de recherche le plus populaire qui permet un apprentissage en profondeur rapide en Python, l'accès à des modèles prédéfinis et des performances GPU accélérées. Le site Web PyTorch est identifié comme une ressource nécessaire pour le cours.
  
  
• 00: 45: 00 Dans cette section, l'instructeur discute de PyTorch, qui, selon lui, est le cadre de recherche d'apprentissage en profondeur le plus populaire. Il cite Papers with Code, qui suit les articles d'apprentissage automatique qui ont du code, pour démontrer la popularité de PyTorch, montrant que 58 % des 65 000 articles suivis par le site sont implémentés avec PyTorch. En outre, il fournit diverses raisons de la popularité de PyTorch, notamment son utilisation par des entreprises telles que Facebook/Meta, Tesla, Microsoft et OpenAI, ainsi que sa capacité à normaliser les méthodologies de recherche. L'instructeur met également en avant le tweet de François Chale, qui loue PyTorch comme un outil que n'importe qui peut utiliser pour résoudre des problèmes sans nécessiter d'investissements importants ni une équipe d'ingénieurs. Dans l'ensemble, l'instructeur conclut que PyTorch est un favori de la recherche avec un écosystème diversifié et un taux d'adoption élevé parmi les poids lourds de l'industrie.
  
  
• 00:50:00 Dans cette section du cours PyTorch for Deep Learning & Machine Learning, l'instructeur aborde les différentes applications de PyTorch, telles que l'agriculture et les plateformes de médias sociaux comme Facebook et Microsoft. De plus, il explique comment PyTorch permet aux utilisateurs d'exécuter du code d'apprentissage automatique sur des GPU, qui sont très efficaces pour effectuer des calculs numériques, en particulier dans le traitement parallèle. PyTorch exploite CUDA pour permettre au code d'apprentissage automatique de s'exécuter sur les GPU NVIDIA, et bien que les TPU soient disponibles, les GPU ont tendance à être plus populaires lors de l'exécution du code PyTorch. De plus, il laisse la question "Qu'est-ce qu'un tenseur?" au public de faire des recherches, avec la section suivante pour couvrir le sujet en profondeur.
  
  
• 00: 55: 00 Dans cette section, l'instructeur explique que les tenseurs sont le bloc de construction fondamental de PyTorch et qu'ils peuvent être tout ce qui représente des nombres. Les données d'entrée sont codées numériquement pour les transformer en un tenseur, qui peut être une image ou un million d'images. Le ou les tenseurs d'entrée sont ensuite transmis à un réseau de neurones qui les manipule via des opérations mathématiques et génère un autre tenseur, qui est ensuite reconverti dans un format compréhensible par l'homme. La raison d'utiliser PyTorch et de rechercher des réponses aux questions en ligne est soulignée, ainsi qu'une introduction à des sujets spécifiques qui seront abordés dans le cours.

Partie 2

• 01:00:00 Dans cette section, l'instructeur met en évidence les sujets abordés dans le cours PyTorch. Le cours commence par les bases de PyTorch, en se concentrant sur les tenseurs et les opérations de tenseurs, puis passe au prétraitement des données, à la construction et à l'utilisation de modèles d'apprentissage en profondeur pré-formés, à l'ajustement d'un modèle à un ensemble de données, à la réalisation de prédictions et à l'évaluation des prédictions du modèle. L'instructeur explique le flux de travail, y compris la préparation des données, le choix d'un modèle pré-formé, la sélection d'une fonction de perte et d'un optimiseur, la création d'une boucle de formation, l'ajustement du modèle et l'amélioration du modèle par l'expérimentation. Enfin, l'instructeur met l'accent sur l'importance de coder, d'explorer et d'expérimenter le code tout en reliant les ressources parascolaires pour en savoir plus sur la théorie derrière le code.
  
  
• 01:05:00 Dans cette section, l'instructeur du cours PyTorch for Deep Learning & Machine Learning conseille aux apprenants d'aborder le cours avec l'esprit d'un scientifique et d'un chef. Il souligne l'importance de l'expérimentation et de la visualisation pour comprendre les données en apprentissage profond. De plus, l'instructeur encourage les apprenants à poser des questions et à faire les exercices fournis, ainsi qu'à partager leur travail avec d'autres pour aider à leur propre apprentissage et à celui des autres. Enfin, il conseille aux apprenants d'éviter de trop réfléchir et de dire qu'ils ne peuvent pas apprendre, les exhortant à éviter que leur cerveau ne s'enflamme. Enfin, il dirige les apprenants vers les ressources fondamentales requises pour le cours, y compris un référentiel GitHub avec tout le matériel requis.
  
  
• 01:10:00 Dans cette section, l'orateur explique les ressources disponibles pour le cours et comment les utiliser efficacement. Les supports de cours, y compris le code et les blocs-notes, sont disponibles sur GitHub, tandis que les questions et réponses du cours se trouvent dans l'onglet discussions du même référentiel. De plus, un livre en ligne est disponible sur learnpytorch.io. Pour les questions liées à PyTorch qui ne sont pas spécifiques au cours, les forums et le site Web PyTorch sont fortement recommandés. L'orateur présente ensuite Google Colab, qui sera le principal outil utilisé tout au long du cours, et encourage les utilisateurs à coder en y accédant via colab.research.google.com.
  
  
• 01:15:00 Dans cette section, l'instructeur explique comment utiliser Google Colab pour créer un nouveau bloc-notes et écrire du code PyTorch. Google Colab offre des avantages tels que la possibilité d'utiliser l'accélération GPU ou TPU pour un temps de calcul plus rapide, ainsi que PyTorch préinstallé et d'autres packages de science des données Python courants. L'instructeur établit un lien vers un bloc-notes de ressources sur learnpytorch.io et fournit un référentiel GitHub où les apprenants peuvent poser des questions liées au cours. L'instructeur mentionne également que s'il utilise la version payante de Google Colab, la version gratuite est suffisante pour suivre le cours.
  
  
• 01:20:00 Dans cette section, la vidéo présente comment configurer PyTorch à l'aide de Google Colab ou en se référant au document de configuration pour la configuration locale. La configuration recommandée pour suivre le cours est PyTorch 1.10 et CUDA 11.3. La vidéo suggère également d'utiliser une approche de fenêtre fractionnée pour suivre et créer un cahier pour la pratique. L'objectif principal de la vidéo est une introduction aux tenseurs, le principal élément de base de l'apprentissage en profondeur, fournissant des exemples de création d'un tenseur scalaire rempli du nombre sept, et comment accéder à la documentation de PyTorch pour torch.tensor.
  
  
• 01:25:00 Dans cette section, l'instructeur explique les bases des tenseurs PyTorch, en commençant par la création de tenseurs à l'aide de torch.dot.tensor. Il encourage les apprenants à parcourir la documentation PyTorch pour en savoir plus sur la bibliothèque. Ensuite, l'instructeur explique les attributs des scalaires, des vecteurs et des matrices. Il précise qu'un scalaire n'a pas de dimensions et n'est qu'un seul nombre, tandis qu'un vecteur a une dimension, généralement représentée par une magnitude et une direction. Une matrice est la prochaine étape et a deux dimensions représentées par deux paires de crochets. Il explique la différence entre dimension et forme, et comment trouver la forme d'un vecteur en fonction de ses dimensions.
  
  
• 01:30:00 Dans cette section, l'instructeur présente les tenseurs dans PyTorch et explique qu'ils sont les éléments fondamentaux des réseaux de neurones d'apprentissage en profondeur. L'instructeur montre comment créer des tenseurs avec différentes dimensions, allant d'un scalaire à une matrice à un tenseur avec trois paires de crochets. L'instructeur explique que le nombre de dimensions est indiqué par le nombre de paires de crochets et que la forme est déterminée par le nombre d'éléments dans chaque dimension. De plus, l'instructeur note que bien qu'il soit fastidieux d'écrire des tenseurs à la main, il est important de comprendre comment ils fonctionnent puisque PyTorch les utilise abondamment.
  
  
• 01:35:00 Dans cette section, l'instructeur discute de l'importance des tenseurs aléatoires dans PyTorch pour l'apprentissage automatique et l'apprentissage en profondeur. Commencer avec des tenseurs remplis de nombres aléatoires, puis les ajuster pour mieux représenter les données est un concept clé dans les réseaux de neurones. Pour créer un tenseur aléatoire dans PyTorch, l'instructeur montre comment utiliser la fonction torch.rand et explique que "taille" et "forme" sont deux versions différentes de la même chose. La convention de dénomination des variables dans l'apprentissage en profondeur, telles que les scalaires et les vecteurs en minuscules et les matrices et les tenseurs en majuscules, est également brièvement discutée.
  
  
• 01:40:00 Dans cette section, l'instructeur montre comment créer des tenseurs aléatoires à l'aide de PyTorch et explique que divers types de données, y compris des images, peuvent être représentés au format tenseur. L'instructeur explique que PyTorch simplifie le processus de création de tenseurs et, dans de nombreux cas, gère le processus dans les coulisses. Ils montrent comment créer un tenseur aléatoire avec une forme similaire à celle d'un tenseur d'image et expliquent que les images sont généralement représentées sous forme de tenseurs avec des canaux de couleur, une hauteur et une largeur. L'instructeur souligne que presque tous les types de données peuvent être représentés sous forme de tenseur, ce qui fait de PyTorch un outil puissant pour les applications d'apprentissage en profondeur et d'apprentissage automatique.
  
  
• 01:45:00 Dans cette section, l'instructeur explique comment créer des tenseurs de zéros et de uns, et comment créer une plage de tenseurs. Le tenseur de tous les zéros est utile pour créer un masque de tenseur, qui peut mettre à zéro certaines colonnes d'un tenseur. Le tenseur de tous les uns peut aussi être utile dans certaines situations. L'instructeur explique comment utiliser torch.range, mais avertit qu'il peut être obsolète dans certaines versions de PyTorch et suggère d'utiliser une fonction de plage à la place.
  
  
• 01:50:00 Dans cette section, la fonctionnalité PyTorch de création de tenseurs à l'aide d'une plage et de ceux ayant la même forme qu'un autre tenseur est expliquée. La plage de tenseurs est créée à l'aide de torch.arange() où start, stop et step peuvent être définis. De même, torch.zeros_like() est utilisé pour créer un tenseur de zéros avec la même forme que le tenseur d'entrée. La section présente ensuite les types de données tenseur dans PyTorch, en spécifiant que le type par défaut est float 32, même si aucun n'est spécifié.
  
  
• 01:55:00 Dans cette section, nous découvrons les paramètres importants lors de la création de tenseurs dans PyTorch, tels que le type de données, l'appareil et le niveau requis. Nous découvrons que le type de données fait référence au niveau de précision dans le calcul et interagit généralement avec les tenseurs à virgule flottante 32 bits et 16 bits. La simple précision est de 32 bits et la demi-précision est de 16 bits, 32 bits étant le type de tenseur par défaut dans PyTorch. La note sur les types de données tensorielles est essentielle car c'est l'une des trois erreurs importantes que nous pouvons rencontrer lors de l'utilisation de PyTorch et de l'apprentissage en profondeur. Les deux autres erreurs incluent des tenseurs n'ayant pas la bonne forme et ne se trouvant pas sur le bon appareil.

Partie 3

• 02:00:00 Dans cette section, l'instructeur explique l'importance de maintenir la forme et l'appareil corrects lorsque vous travaillez avec des tenseurs dans PyTorch. Si les tenseurs ont des formes différentes ou sont situés sur différents appareils (CPU ou GPU), des erreurs peuvent se produire. De plus, l'instructeur explique le rôle du paramètre "grad" dans le suivi des gradients lors des calculs numériques. La leçon comprend un défi pour les spectateurs de créer des tenseurs de différents types de données et de tester l'impact de la multiplication des tenseurs de différents types. L'instructeur avertit que si certaines opérations peuvent ne pas entraîner d'erreurs, d'autres peuvent entraîner des problèmes de type de données, en particulier lors de la formation de grands réseaux de neurones.
  
  
• 02:05:00 Dans cette section de la vidéo, l'instructeur explique comment dépanner les opérations de tenseur et s'assurer que les tenseurs ont le type et la forme de données corrects pour une utilisation dans les modèles d'apprentissage automatique. Ils montrent comment vérifier le type de données, la forme et le périphérique d'un tenseur à l'aide de PyTorch, à l'aide des commandes tensor.Dtype, tensor.shape et tensor.device. L'instructeur note également que PyTorch peut générer des erreurs si les tenseurs ne sont pas dans le type ou la forme de données corrects, et montre comment modifier le type de données si nécessaire. Enfin, ils comparent les commandes de taille et de forme et notent qu'elles sont interchangeables, l'une étant une fonction et l'autre un attribut.
  
  
• 02:10:00 Dans cette section, l'instructeur passe en revue la manipulation des tenseurs dans PyTorch, en particulier les opérations de tenseurs telles que l'addition, la soustraction, la multiplication, la division et la multiplication matricielle. Ces opérations sont importantes pour la construction de réseaux de neurones car elles aident à résoudre les problèmes les plus courants liés à la construction de modèles d'apprentissage en profondeur. De plus, les réseaux de neurones combinent ces fonctions de diverses manières pour analyser et ajuster les nombres d'un tenseur aléatoire pour représenter un ensemble de données. L'instructeur montre comment effectuer les opérations tensorielles de base d'addition, de multiplication et de multiplication matricielle à l'aide d'exemples de code PyTorch.
  
  
• 02:15:00 Dans cette section, l'instructeur couvre les opérations tensorielles à l'aide de PyTorch et introduit le concept de multiplication matricielle. Ils montrent comment effectuer une multiplication, une addition et une soustraction élément par élément à l'aide d'opérateurs Python ainsi que des fonctions intégrées de PyTorch. L'instructeur lance un défi aux téléspectateurs pour rechercher et comprendre la multiplication matricielle avant de plonger dedans. Ils expliquent qu'il existe deux manières principales d'effectuer la multiplication dans les réseaux de neurones, la multiplication élément par élément et la multiplication matricielle, également appelée produit scalaire. L'instructeur fournit des exemples des deux types de multiplication à l'aide de matrices et souligne que la multiplication matricielle est l'une des opérations de tenseur les plus courantes dans les réseaux de neurones.
  
  
• 02:20:00 Dans cette section, l'instructeur explique la différence entre la multiplication par élément et la multiplication par produit scalaire dans PyTorch. Pour démontrer le concept, l'instructeur passe par un processus étape par étape de multiplication de deux matrices, soulignant comment chaque élément est multiplié et ajouté pour obtenir le résultat final. Ensuite, l'instructeur montre comment effectuer une multiplication élément par élément à l'aide d'un exemple rudimentaire, suivi d'une multiplication matricielle à l'aide de la fonction torche dot mat mall. La section explique également comment effectuer une multiplication matricielle à l'aide d'une boucle for et explique la différence de performances entre les deux méthodes.
  
  
• 02:25:00 Dans cette section, la vidéo explique les avantages de la vectorisation par rapport aux boucles for dans PyTorch, en utilisant l'exemple de la multiplication matricielle. La méthode de la torche torch dot matmore s'avère 10 fois plus rapide que l'utilisation d'une boucle for pour les petits tenseurs. Cependant, la vidéo avertit que deux règles principales doivent être satisfaites pour les tenseurs plus grands afin d'éviter les erreurs de forme dans la multiplication matricielle. La première règle est que les dimensions intérieures des deux tenseurs doivent correspondre.
  
  
• 02:30:00 Dans cette section, l'instructeur explique les règles de la multiplication matricielle et comment éviter les erreurs de forme courantes lors de la multiplication des tenseurs. La première règle est que les dimensions intérieures de la matrice doivent correspondre. Pour le démontrer, l'instructeur crée un tenseur de taille 3x2 et tente de le multiplier par un autre tenseur qui n'a pas les mêmes dimensions intérieures, ce qui entraîne une erreur. La deuxième règle est que la matrice résultante a la forme des dimensions extérieures. L'instructeur donne des exemples de multiplication de matrices avec différentes formes et dimensions de tenseurs, et comment elles aboutissent à différentes formes de matrices. L'instructeur encourage les téléspectateurs à utiliser un site Web pour pratiquer la multiplication matricielle comme un défi avant la prochaine vidéo.
  
  
• 02:35:00 Dans cette section, l'instructeur traite des erreurs de forme dans les réseaux de neurones, qui sont l'une des erreurs les plus courantes dans l'apprentissage en profondeur. Étant donné que les réseaux de neurones sont composés de plusieurs opérations de multiplication matricielle, même une légère erreur de forme du tenseur peut entraîner une erreur de forme. L'instructeur crée ensuite deux tenseurs, le tenseur a et le tenseur b, et essaie d'effectuer une multiplication matricielle entre eux, ce qui entraîne une erreur de forme. Pour corriger cette erreur, l'instructeur introduit le concept de transposition, qui change les axes ou les dimensions d'un tenseur donné, et montre comment il peut être utilisé pour ajuster la forme des tenseurs dans le code PyTorch.
  
  
• 02:40:00 Dans cette section, l'instructeur explique le concept de transposition des tenseurs et son importance dans la multiplication matricielle. La transposition réorganise les éléments d'un tenseur sans changer ses données sous-jacentes, et elle est notée "point t". L'instructeur montre également comment fonctionne une opération de multiplication matricielle lorsque le tenseur b est transposé et souligne l'importance de cette opération dans les réseaux de neurones et l'apprentissage en profondeur. Le processus de transposition des tenseurs est illustré visuellement et l'instructeur fournit des exemples de code étape par étape pour aider les étudiants à comprendre et à mettre en pratique le concept.
  
  
• 02:45:00 Dans cette section, l'instructeur explique la multiplication matricielle à l'aide de PyTorch et d'un site Web appelé Matrix Multiplication. Il a créé deux tenseurs, le tenseur a et le tenseur b, et a montré que leur multiplication aboutit à un nouveau tenseur avec une forme de sortie spécifique. Il défie les téléspectateurs de transposer le tenseur a au lieu du tenseur b et de voir les résultats. Ensuite, l'instructeur couvre l'agrégation de tenseurs, montrant comment trouver le minimum, le maximum, la moyenne et la somme d'un tenseur à l'aide des méthodes PyTorch. Il explique également comment l'agrégation de tenseurs aide à réduire le nombre d'éléments dans un tenseur.
  
  
• 02:50:00 Dans cette section du didacticiel PyTorch, l'instructeur explique comment résoudre l'une des erreurs les plus courantes dans PyTorch, à savoir le mauvais type de données. Il le démontre en créant un tenseur de type de données long, qui empêche l'utilisation de la fonction moyenne de la torche. Il explique ensuite comment convertir le tenseur en flottant 32, ce qui est requis par la fonction moyenne, en utilisant la méthode x.type(). En plus de trouver le min, le max, la moyenne et la somme du tenseur, l'instructeur lance également un défi pour trouver le min et le max positionnels, qui seront couverts dans la vidéo suivante.
  
  
• 02:55:00 Dans cette section, l'utilisation des fonctions argmin et argmax dans PyTorch pour trouver la position min et max d'un tenseur a été expliquée. La fonction argmin renvoie la position dans le tenseur qui a la valeur minimale, tandis que la fonction argmax renvoie la position dans le tenseur qui a la valeur maximale. Ces fonctions sont utiles lorsqu'il n'est pas nécessaire de définir les valeurs minimales ou maximales d'un tenseur, mais uniquement la position de ces valeurs. De plus, les concepts de remodelage, d'empilement, de compression et de décompression des tenseurs ont été introduits, qui sont utiles pour gérer les inadéquations de forme dans l'apprentissage automatique et l'apprentissage en profondeur.

Partie 4

• 03:00:00 Dans cette section, l'instructeur explique les différentes méthodes de manipulation des tenseurs dans PyTorch, telles que remodeler, afficher, empiler, presser, décompresser et permuter. Reshape modifie la forme d'un tenseur d'entrée, view renvoie une vue d'un tenseur avec une forme différente, l'empilement combine plusieurs tenseurs ensemble verticalement ou horizontalement, squeeze supprime toutes les dimensions égales à 1 et unsqueeze ajoute une nouvelle dimension avec une taille de 1. Enfin, permute permute les dimensions d'un tenseur. L'instructeur fournit des exemples de code pour démontrer chacune de ces méthodes et souligne l'importance de la manipulation de la forme du tenseur dans l'apprentissage automatique et l'apprentissage en profondeur.
  
  
• 03:05:00 Dans cette section, le didacticiel vidéo explore comment remodeler et afficher les tenseurs PyTorch. Le remodelage nécessite la compatibilité avec la taille d'origine et peut être effectué à l'aide des fonctions 'reshape' ou 'view'. Il est important de noter que 'view' partage la même mémoire avec le tenseur d'origine. De plus, la fonction 'stack' concatène les tenseurs le long d'une nouvelle dimension, et la dimension par défaut est zéro. Il est conseillé aux utilisateurs d'enregistrer fréquemment leur travail car des erreurs peuvent survenir lors de l'utilisation de Google CoLab ou de toute autre forme de Jupyter Notebooks.
  
  
• 03:10:00 Dans cette section, l'instructeur présente les concepts de compression et de décompression dans PyTorch. Pour s'entraîner à utiliser ces méthodes, le spectateur est encouragé à consulter la documentation et à les essayer. L'instructeur démontre la méthode de compression où des dimensions uniques sont supprimées d'un tenseur cible. Pour visualiser les modifications apportées aux tenseurs lors de ces opérations, le formateur propose d'imprimer chaque modification et de vérifier la taille du tenseur. De plus, l'instructeur insiste sur l'importance de pratiquer ces concepts plusieurs fois pour se familiariser avec eux.
  
  
• 03:15:00 Dans cette section, l'instructeur explique le concept d'ajout et de suppression de dimensions dans les tenseurs PyTorch à l'aide des méthodes "squeeze" et "unsqueeze". Il démontre les effets de ces méthodes en ajoutant et en supprimant des dimensions des tenseurs et en imprimant leurs formes. L'instructeur présente également la méthode "permuter", qui réorganise les dimensions d'un tenseur cible dans un ordre spécifié. Il fournit un exemple de la façon dont le permute peut être utilisé avec des images et discute de l'importance de transformer les données en représentations numériques dans l'apprentissage en profondeur.
  
  
• 03:20:00 Dans cette section, l'instructeur enseigne comment permuter un tenseur en réorganisant ses dimensions à l'aide de la méthode permute() dans PyTorch. L'exemple donné est un tenseur d'image où la dimension du canal couleur est déplacée vers le premier indice. L'instructeur explique qu'un tenseur permuté n'est qu'une vue et partage la même mémoire que le tenseur d'origine, démontré en mettant à jour une valeur dans le tenseur d'origine et en voyant la même valeur copiée dans le tenseur permuté. La section couvre également l'indexation dans PyTorch et comment elle est similaire à l'indexation avec NumPy, une autre bibliothèque de calcul numérique populaire.
  
  
• 03:25:00 Dans cette section, l'instructeur explique comment importer une torche et montre comment créer une petite plage et la remodeler de manière compatible. Le didacticiel se penche ensuite sur l'indexation avec des tenseurs et montre comment indexer sur les première et deuxième dimensions. Le didacticiel révèle également la fonctionnalité d'utilisation d'un point-virgule pour sélectionner l'ensemble d'une dimension cible. La section se termine par un défi pour réorganiser le code pour obtenir le numéro neuf.
  
  
• 03:30:00 Dans cette section, l'instructeur montre comment sélectionner des valeurs spécifiques à partir d'un tenseur à l'aide de PyTorch. Les exemples impliquent la sélection d'éléments de différentes dimensions du tenseur en spécifiant les valeurs d'indice appropriées. L'instructeur met ensuite les téléspectateurs au défi d'essayer d'indexer le tenseur pour renvoyer des valeurs spécifiques. Dans la section suivante, l'instructeur explique comment les tenseurs PyTorch interagissent avec la bibliothèque de calcul numérique scientifique populaire, NumPy. Puisque PyTorch l'exige, il existe une fonctionnalité intégrée pour permettre une transition facile entre les tableaux NumPy et les tenseurs PyTorch.
  
  
• 03:35:00 Dans cette section, la vidéo explique comment convertir des données de NumPy en tenseurs PyTorch et vice versa. Pour passer de NumPy à PyTorch, la méthode torch.fromNumPy est utilisée sur le tableau NumPy, mais il convient de noter que le type de données par défaut de PyTorch est float32 tandis que la valeur par défaut de NumPy est float64. Par conséquent, il peut être nécessaire de spécifier le type de données lors de la conversion. Il est également important de noter que lors de la modification de la valeur du tableau NumPy d'origine, cela ne modifie pas la valeur du tenseur PyTorch s'il a été créé à l'aide de la méthode fromNumPy. Pour passer de PyTorch à NumPy, la méthode torch.tensor.numpy() peut être utilisée.
  
  
• 03:40:00 Dans cette section, la vidéo explique comment passer de PyTorch à NumPy et les types de données par défaut de chacun. Le type de données par défaut de PyTorch est float32, tandis que le type de données par défaut de NumPy est float64, et si vous modifiez le type de données dans PyTorch, le tenseur NumPy reflétera le type de données d'origine. La vidéo couvre également le concept de reproductibilité dans les réseaux de neurones et l'utilisation de graines aléatoires pour réduire le caractère aléatoire des expériences. En définissant une graine aléatoire, le caractère aléatoire est aromatisé et l'ordinateur devient plus déterministe, permettant des résultats plus reproductibles.
  
  
• 03:45:00 Dans cette section, l'instructeur introduit le concept d'aléatoire et de reproductibilité dans PyTorch. Deux tenseurs aléatoires sont créés à l'aide de la fonction torch.rand, et leurs valeurs sont imprimées et comparées. L'instructeur explique le concept de graine aléatoire, qui est utilisé pour créer un caractère aléatoire reproductible dans PyTorch. La valeur de départ aléatoire peut être définie sur une valeur numérique de choix, telle que 42, puis utilisée dans diverses fonctions aléatoires pour obtenir un caractère aléatoire aromatisé. Il est important de noter que si la fonction torch.manual_seed est utilisée, elle ne fonctionne généralement que pour un bloc de code dans un notebook.
  
  
• 03:50:00 Dans cette section de la vidéo, l'importance de la reproductibilité dans l'apprentissage automatique et l'apprentissage en profondeur est soulignée, et le concept de graine aléatoire est expliqué. La graine manuelle est un moyen de parfumer le caractère aléatoire des tenseurs aléatoires PyTorch et de les rendre reproductibles. Le document de reproductibilité PyTorch est recommandé comme une excellente ressource pour en savoir plus sur la reproductibilité. La section traite également de l'exécution d'objets PyTorch sur des GPU pour des calculs plus rapides et de la manière d'accéder aux GPU, notamment en utilisant Google Colab pour un GPU gratuit, Google Colab Pro pour des GPU plus rapides et une durée d'exécution plus longue, et Google Colab Pro Plus pour des avantages plus avancés.
  
  
• 03:55:00 Dans cette section, l'instructeur explique différentes manières d'accéder aux GPU pour les tâches d'apprentissage en profondeur et d'apprentissage automatique. Les options sont d'utiliser Google Colab, de passer à Colab Pro, d'utiliser votre propre GPU ou d'utiliser des services de cloud computing comme GCP, AWS ou Azure. L'instructeur recommande de commencer par Google Colab, qui est facile et gratuit à utiliser. Cependant, si vous avez besoin de plus de ressources ou si vous souhaitez exécuter des expériences plus importantes, vous pouvez mettre à niveau ou utiliser votre propre GPU ou cloud computing. L'instructeur montre également comment obtenir un GPU dans Google Colab en modifiant le type d'exécution et en vérifiant l'accès au GPU avec PyTorch.

[MetaQuotes]

PyTorch pour Deep Learning & Machine Learning - Cours complet (description pour les parties 5-9)

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

Partie 5

• 04:00:00 Dans cette section, l'instructeur explique comment vérifier l'accès GPU avec PyTorch et configurer le code indépendant de l'appareil. En utilisant la commande "torch.cuda.is_available()", l'utilisateur peut vérifier si PyTorch peut accéder au GPU. De plus, pour exécuter PyTorch, la variable de périphérique doit être définie pour utiliser le GPU, si disponible, ou par défaut sur le CPU. Il est également important de configurer un code indépendant de l'appareil, qui permet à PyTorch de s'exécuter sur le CPU ou le GPU, selon ce qui est disponible, en configurant "args.device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')" dans les scripts Python. L'instructeur souligne que la configuration d'un code indépendant de l'appareil est une bonne pratique lorsque vous travaillez avec PyTorch, car cela permet au code d'être exécuté sur différents appareils.
  
  
• 04:05:00 Dans cette section, l'instructeur explique comment l'utilisation de GPU peut accélérer les calculs et être bénéfique pour les modèles d'apprentissage automatique qui fonctionnent avec des calculs numériques comme les opérations de tenseur. Pour utiliser le GPU, les tenseurs et les modèles doivent y être transférés, et PyTorch facilite cette opération avec la méthode "to". Le code peut être rendu indépendant de l'appareil afin qu'il s'exécute indépendamment du fait qu'un GPU soit disponible ou non. De même, les tenseurs peuvent également être déplacés vers le CPU si nécessaire, et la méthode `cpu()` peut être utilisée pour cela. L'instructeur souligne que les problèmes d'appareil sont la troisième erreur la plus courante dans PyTorch et qu'il est recommandé de garder à l'esprit le type d'appareil sur lequel les tenseurs et les modèles sont stockés.
  
  
• 04:10:00 Dans cette section, l'instructeur aborde les principes fondamentaux du travail avec PyTorch sur le GPU. Il explique comment basculer entre CPU et GPU et comment éviter les erreurs lors de l'utilisation de calculs NumPy avec des tenseurs sur le GPU. Il encourage également les apprenants à mettre en pratique ce qu'ils ont appris grâce à un ensemble d'exercices et de programmes supplémentaires disponibles sur learn.pytorch.io. Les exercices sont basés sur ce qui a été couvert dans les sections précédentes, et les apprenants sont encouragés à utiliser la documentation PyTorch pour les compléter. Enfin, l'instructeur fournit des conseils sur la façon d'aborder ces exercices dans Colab en configurant deux écrans et en important la torche.
  
  
• 04:15:00 Dans cette section, l'instructeur discute des exercices et du programme supplémentaire du cours PyTorch. Les exercices sont basés sur du code et incluent des modèles pour chacun des exercices. Le programme supplémentaire est basé sur la lecture, et l'instructeur recommande de passer une heure à parcourir le didacticiel de base de PyTorch, les sections de démarrage rapide et de tenseur, ainsi que de regarder le "Qu'est-ce qu'un tenseur?" vidéo. L'instructeur décrit également le flux de travail PyTorch, qui comprend la préparation des données et leur transformation en tenseurs, la sélection ou la construction d'un modèle pré-formé, la sélection d'une fonction de perte et son optimisation, la construction d'une boucle de formation, l'ajustement du modèle, l'évaluation du modèle, l'expérimentation et améliorer, sauvegarder et recharger le modèle entraîné. L'instructeur encourage les apprenants à suivre le code et la documentation, à rechercher des ressources, à réessayer et à poser des questions dans les forums PyTorch.
  
  
• 04:20:00 Dans cette section de la vidéo, l'instructeur commence par ouvrir un nouveau bloc-notes dans Colab et l'intitule "01 PyTorch Workflow". Il explique qu'ils se concentreront sur le codage ensemble et la création d'un flux de travail PyTorch de bout en bout, ce qui implique la préparation et le chargement des données, la création d'un modèle d'apprentissage automatique dans PyTorch, la formation du modèle, l'évaluation du modèle et l'enregistrement/le chargement du modèle. . L'instructeur mentionne également qu'il utilisera le module nn dans PyTorch, qui contient tous les blocs de construction de PyTorch pour les réseaux de neurones.
  
  
• 04:25:00 Dans cette section, l'instructeur aborde l'utilisation de torch.nn dans PyTorch en explorant les blocs de construction de base des graphes informatiques, qui sont utilisés dans les réseaux de neurones. La combinaison de ces blocs de construction permet aux scientifiques des données et aux ingénieurs en apprentissage automatique de créer différents types de réseaux de neurones. L'instructeur souligne l'importance de la première étape du flux de travail PyTorch, qui consiste à préparer et à charger les données dans une représentation numérique pour que le modèle apprenne des modèles. Le type de représentation numérique utilisé pour coder les données dépend du type de données. La deuxième étape consiste à construire un réseau de neurones pour apprendre les modèles dans la représentation numérique, puis à utiliser les modèles appris pour des tâches spécifiques telles que la reconnaissance d'images ou la classification des spams.
  
  
• 04:30:00 Dans cette section, l'instructeur présente le jeu en deux parties de l'apprentissage automatique, qui consiste à convertir des données en représentation numérique et à construire un modèle pour trouver des modèles dans cette représentation. L'instructeur crée ensuite des données connues à l'aide de la formule de régression linéaire pour illustrer ce processus. Le poids et le biais de la formule sont utilisés comme paramètres qu'un modèle apprendra en examinant différents exemples. Le code en Python est utilisé pour créer une plage de nombres, attribuer une valeur à la variable X et créer une formule Y égale au poids multiplié par X plus le biais. La longueur et la valeur de X et Y sont visualisées, et les dix premières valeurs de X et Y sont affichées.
  
  
• 04:35:00 Dans cette section, l'instructeur explique l'importance de diviser les données en ensembles d'entraînement et de test dans l'apprentissage automatique. Il utilise l'analogie des cours universitaires et des examens pour expliquer le concept. L'ensemble de formation s'apparente à tous les supports de cours, l'ensemble de validation est comme un examen pratique et l'ensemble de test est l'examen final. L'objectif est de parvenir à une généralisation, afin que le modèle puisse s'adapter à des données inédites. L'instructeur insiste sur le fait que le fractionnement correct des données est essentiel pour créer un modèle précis.
  
  
• 04:40:00 Dans cette section du cours complet PyTorch, l'instructeur discute de l'importance de la généralisation dans les modèles d'apprentissage automatique et des trois ensembles de données couramment utilisés dans la formation et les tests : ensembles de formation, de validation et de test. Il explique également les répartitions en pourcentage communes utilisées pour chacun de ces ensembles, l'ensemble d'apprentissage ayant généralement 60 à 80 % des données et l'ensemble de test ayant 10 à 20 %. L'instructeur montre ensuite comment créer un ensemble d'entraînement et de test à l'aide d'un ensemble de données d'échantillon avec des valeurs X et Y en utilisant l'indexation pour sélectionner le nombre approprié d'échantillons pour chaque fractionnement. Enfin, il explique que s'il existe souvent un cas d'utilisation pour un ensemble de validation dans des ensembles de données plus complexes, les ensembles d'apprentissage et de test sont les plus couramment utilisés.
  
  
• 04:45:00 Dans cette section, l'instructeur insiste sur l'importance de visualiser les données en écrivant une fonction appelée "prédictions de tracé" qui sera utilisée pour comparer les données d'entraînement et de test. La fonction prend le train X, le train Y, le test X, le test Y et les prédictions comme paramètres, puis trace les données de formation en bleu à l'aide d'un nuage de points avec la bibliothèque matplotlib. Les données de test sont ensuite tracées en vert en utilisant la même fonction de dispersion. La fonction vérifie également s'il existe des prédictions et, le cas échéant, les trace également à l'aide de la fonction de dispersion. En visualisant les données, il devient plus facile à comprendre et à interpréter.
  
  
• 04:50:00 Dans cette section de la vidéo, l'instructeur discute du processus de formation et d'évaluation des modèles d'apprentissage automatique. Ils expliquent que l'objectif est d'entraîner le modèle sur les données d'apprentissage afin de prédire avec précision les valeurs des données de test. Ils le démontrent à l'aide d'un simple ensemble de données linéaires, avec les données de formation tracées en bleu et les données de test en vert. L'instructeur introduit ensuite le concept de régression linéaire et prépare le terrain pour la section suivante, où il construira un modèle PyTorch pour la régression linéaire. Ils fournissent également des conseils de dépannage pour Google Colab.
  
  
• 04:55:00 Dans cette section de la vidéo, nous apprenons à créer un modèle de régression linéaire à l'aide de PyTorch pur. L'instructeur explique que PyTorch est construit au-dessus du nn.module, qui ressemble aux briques de construction Lego des modèles PyTorch. Presque tout dans PyTorch hérite de nn.module, et les modules peuvent contenir d'autres modules, ce qui facilite la construction de réseaux de neurones complexes. L'instructeur nous guide ensuite à travers le processus de création d'un constructeur avec la fonction init, la création d'un paramètre de pondération à l'aide de nn.parameter et sa définition de paramètres aléatoires à l'aide de torch.rand. L'instructeur explique également comment définir requirements_grad et dtype.

Partie 6

• 05:00:00 Dans cette section, l'instructeur explique comment créer un modèle de régression linéaire à l'aide de PyTorch. Ils commencent par créer une classe pour le modèle et l'initialisent avec des paramètres pour les poids et le biais, qui sont automatiquement ajoutés à la liste des paramètres lorsqu'ils sont affectés à un attribut de module. Ils créent ensuite une méthode directe pour définir le calcul dans le modèle, qui est basé sur la formule de régression linéaire. L'objectif du modèle est de mettre à jour les paramètres aléatoires pour représenter le modèle des données d'entraînement par descente de gradient, qui est la prémisse de l'apprentissage automatique.
  
  
• 05:05:00 Dans cette section, l'instructeur décrit le processus d'ajustement des valeurs aléatoires pour mieux représenter les valeurs souhaitées de poids et de biais dans les données, ce qui est accompli à l'aide de deux algorithmes principaux : la descente de gradient et la rétropropagation. L'utilisation de "nécessite grad égal vrai" est expliquée comme le suivi des gradients via des calculs effectués à l'aide du modèle, poussant l'algorithme dans la bonne direction. L'importance de la programmation orientée objet et le rôle de PyTorch dans la mise en œuvre de ces algorithmes sont soulignés, avec des ressources supplémentaires suggérées pour aider à acquérir une intuition pour le code. L'instructeur souligne également le fait que si le modèle actuel traite des ensembles de données simples avec des paramètres connus, les ensembles de données plus complexes ont souvent des paramètres définis par des modules de nn pour nous.
  
  
• 05:10:00 Dans cette section, l'instructeur explique les principaux points à retenir de la création du premier modèle PyTorch. Chaque modèle dans PyTorch hérite de nn.modgable et doit remplacer la méthode directe pour définir le calcul qui se produit à l'intérieur du modèle. De plus, lorsque le modèle apprend, il met à jour ses poids et ses valeurs de biais via la descente de gradient et la rétropropagation à l'aide du module torch.auto grad. L'instructeur recommande de consulter deux vidéos liées dans la transcription pour une compréhension complète de ce concept. De plus, l'instructeur présente certains éléments essentiels de la construction de modèles PyTorch, tels que le module torch.nn qui contient tous les blocs de construction nécessaires aux réseaux de neurones.
  
  
• 05:15:00 Dans cette section, l'instructeur explique les modules fondamentaux de PyTorch, notamment torch.nn, torch.nn.module, torch.optim et torch.utils.dataset. Le torch.nn.module est la classe de base pour tous les modules de réseau neuronal et nécessite que la méthode directe soit écrasée, ce qui définit ce qui se passe dans le calcul direct. Torch.optim contient des algorithmes pour optimiser les valeurs du modèle, qui commence par des valeurs aléatoires et s'ajuste pour mieux représenter les valeurs idéales. L'instructeur mentionne également la feuille de triche PyTorch comme une ressource utile pour une exploration plus approfondie de la bibliothèque.
  
  
• 05:20:00 Dans cette section, l'instructeur ajoute de la couleur et du code au flux de travail PyTorch et couvre les modules PyTorch importants utilisés pour créer des ensembles de données, créer et former des modèles, optimiser les paramètres du modèle, évaluer le modèle et l'améliorer par l'expérimentation. L'instructeur montre ensuite comment vérifier le contenu d'un modèle PyTorch en créant une instance du modèle de régression linéaire et en utilisant des paramètres de points pour voir le tenseur des valeurs. L'instructeur définit également une valeur de départ aléatoire pour créer les paramètres avec des valeurs cohérentes.
  
  
• 05:25:00 , nous avons appris comment les modèles d'apprentissage en profondeur sont initialisés avec des valeurs aléatoires pour les poids et les paramètres de biais. Nous avons également appris l'importance d'utiliser des valeurs de départ aléatoires pour la reproductibilité. Le principe fondamental de l'apprentissage en profondeur est d'ajuster ces valeurs aléatoires pour qu'elles soient aussi proches que possible des valeurs idéales par descente de gradient et rétropropagation, à l'aide de données d'apprentissage. Dans la section suivante, la vidéo couvrira la réalisation de prédictions avec les valeurs de paramètres aléatoires du modèle.
  
  
• 05:30:00 cette section, la vidéo explique le processus de test de la puissance prédictive d'un modèle PyTorch. La méthode directe du modèle prend les données d'entrée X et les transmet à travers le modèle pour faire des prédictions. La vidéo montre comment tester la puissance prédictive du modèle en entrant X test, qui se compose de 10 variables, et en observant la sortie du modèle Y pred. La vidéo traite également d'une erreur courante qui peut survenir lors de la création d'un modèle PyTorch et fournit un correctif.
  
  
• 05:35:00 Dans cette section, nous voyons les prédictions du modèle en exécutant les données de test à l'aide de la méthode Ford définie précédemment. Les prédictions semblent être étonnamment loin des prédictions idéales. Le code introduit également le mode d'inférence torche, qui est un gestionnaire de contexte utilisé pour désactiver le suivi de gradient lors de la réalisation de prédictions, permettant à PyTorch de suivre moins de données et de faire des prédictions plus rapidement. Alors que torch no grad peut faire quelque chose de similaire, le mode d'inférence présente certains avantages par rapport à no grad, comme expliqué dans la documentation PyTorch et un fil Twitter fourni dans la vidéo. Par conséquent, le mode d'inférence est actuellement le moyen préféré de faire de l'inférence.
  
  
• 05:40:00 cette section, la vidéo explique l'importance d'utiliser le gestionnaire de contexte torch.inference_mode lors de la réalisation de prédictions dans PyTorch, car il garantit que le modèle est en mode inférence au lieu du mode formation. La vidéo souligne également que l'initialisation d'un modèle avec des paramètres aléatoires peut entraîner des performances médiocres et propose certaines options d'initialisation, telles que l'utilisation de valeurs nulles ou le transfert de paramètres à partir d'un autre modèle. L'objectif principal de la vidéo, cependant, est de former un modèle en passant de paramètres inconnus à des paramètres connus à l'aide d'une fonction de perte, qui mesure la mauvaise performance des prédictions du modèle. La vidéo note que les termes « fonction de perte », « fonction de coût » et « critère » sont souvent utilisés de manière interchangeable dans l'apprentissage automatique.
  
  
• 05:45:00 Dans cette section, l'instructeur présente le concept d'une fonction de perte, qui est utilisée pour mesurer à quel point les prédictions d'un modèle sont erronées par rapport aux sorties idéales. L'instructeur utilise l'exemple de la mesure de la distance entre les points rouges et verts pour expliquer comment une fonction de perte peut être calculée. La vidéo couvre également l'importance d'un optimiseur, qui prend en compte la perte d'un modèle et ajuste ses paramètres, tels que les valeurs de poids et de biais, pour améliorer la fonction de perte. La section conclut en expliquant que les principes d'une fonction de perte et d'un optimiseur restent les mêmes, qu'il s'agisse de modèles à deux paramètres ou de modèles à millions de paramètres, et qu'il s'agisse de modèles de vision par ordinateur ou de modèles simples comme ceux qui prédisent des points sur une ligne droite.
  
  
• 05:50:00 Dans cette section du cours PyTorch for Deep Learning & Machine Learning, l'instructeur explique l'importance d'utiliser un optimiseur pour pousser les paramètres d'un modèle vers des valeurs qui réduisent la fonction de perte afin d'améliorer la précision de la prédictions. PyTorch a une fonctionnalité intégrée pour implémenter des fonctions de perte et des optimiseurs, et l'instructeur se concentre sur la perte L1, également connue sous le nom d'erreur absolue moyenne, qui mesure la différence absolue entre les valeurs prédites et réelles. L'instructeur fournit un graphique coloré pour illustrer l'erreur absolue moyenne et montre comment implémenter la fonction de perte à l'aide du module NN de PyTorch. L'objectif de la formation d'un modèle sera de minimiser les distances entre les valeurs prédites et réelles et, à son tour, de minimiser la valeur globale de l'erreur absolue moyenne.
  
  
• 05:55:00 Dans cette section, l'instructeur discute du rôle de l'optimiseur dans l'apprentissage automatique, qui fonctionne en tandem avec la fonction de perte pour ajuster les paramètres du modèle, comme le poids et le biais, afin de minimiser la perte. PyTorch a torch.optim, où divers algorithmes d'optimisation sont disponibles, tels que Stochastic Gradient Descent (SGD) et Adam. Ils ajustent tous les deux de manière aléatoire les paramètres du modèle pour minimiser les pertes, mais il s'agit de choisir le plus approprié pour un problème spécifique. La plupart optent pour SGD, qui commence par des ajustements aléatoires, puis continue de s'ajuster dans la direction qui minimise les pertes jusqu'à ce qu'aucun autre ajustement ne puisse être effectué. L'optimiseur nécessite deux arguments, params, ou quels paramètres l'optimiseur doit optimiser, et le taux d'apprentissage (LR), l'hyperparamètre le plus important à définir lors de l'optimisation.

Partie 7

• 06:00:00 Dans cette section, l'instructeur explique ce que sont les paramètres de modèle et les hyperparamètres et leur rôle dans le processus d'apprentissage en profondeur. Les paramètres de modèle sont des valeurs définies par le modèle, tandis que les hyper-paramètres sont des valeurs définies par le scientifique des données ou l'ingénieur en apprentissage automatique. Le taux d'apprentissage est un hyper paramètre, et sa valeur détermine l'ampleur de la modification des paramètres lors de l'optimisation. Un petit taux d'apprentissage entraîne de petits changements tandis qu'un grand taux d'apprentissage entraîne de grands changements. L'instructeur parle également de l'importance de choisir la fonction de perte et l'optimiseur appropriés pour le problème spécifique. Enfin, l'instructeur poursuit en expliquant le processus de création d'une boucle de formation dans PyTorch.
  
  
• 06:05:00 Dans cette section, l'instructeur décrit les étapes nécessaires pour créer une boucle de formation et une boucle de test dans PyTorch. La première étape consiste à boucler les données plusieurs fois pour améliorer les prévisions et minimiser les pertes en effectuant des passages en avant dans le modèle. L'instructeur explique que la passe vers l'avant se produit lorsque les données passent par les fonctions vers l'avant du modèle et que la perte est calculée en comparant les prédictions du modèle aux étiquettes de vérité terrain. L'instructeur présente ensuite l'optimiseur et explique que la passe arrière calcule les gradients de chaque paramètre par rapport à la perte, permettant à l'optimiseur d'ajuster les paramètres du modèle pour améliorer la perte par descente de gradient. L'instructeur souligne que PyTorch implémente la rétropropagation et les mathématiques de la descente de gradient, ce qui facilite l'apprentissage de l'apprentissage automatique pour ceux qui ont des connaissances mathématiques limitées.
  
  
• 06:10:00 Dans cette section, l'instructeur introduit le concept de descente de gradient, qui est utilisé pour optimiser les paramètres du modèle dans l'apprentissage automatique. En utilisant l'exemple d'une colline, l'instructeur explique comment le modèle doit se déplacer vers la direction où la pente est la moins raide pour atteindre le bas de la colline, ce qui représente une perte nulle. L'instructeur passe ensuite à l'écriture d'un code pour exécuter la descente de gradient, ce qui implique de définir le nombre d'époques et de définir le modèle en mode d'entraînement à l'aide du paramètre "requires grad equals true". L'instructeur mentionne également que différents modes sont disponibles pour les modèles pytorch et encourage les téléspectateurs à expérimenter différents paramètres.
  
  
• 06:15:00 Dans cette section de la vidéo, l'instructeur discute de la mise en œuvre de la passe avant pour la formation d'un modèle PyTorch. La passe avant consiste à transmettre des données via la fonction avant du modèle pour faire des prédictions, qui sont ensuite comparées aux valeurs d'apprentissage réelles à l'aide de la fonction de perte MAE. La fonction optimiser.zero_grad() est également introduite, qui définit tous les gradients sur zéro avant de calculer la perte en arrière et de mettre à jour les paramètres du modèle à l'aide de la descente de gradient. Ces étapes sont cruciales pour comprendre comment un modèle apprend et sera encore optimisé et fonctionnalisé dans les sections ultérieures du cours.
  
  
• 06:20:00 Dans cette section, l'instructeur passe en revue les cinq étapes principales d'une boucle d'entraînement dans PyTorch, qui comprend le passage vers l'avant, le calcul de la perte, la mise à zéro des gradients de l'optimiseur, la rétro-propagation et la progression de l'optimiseur dans la descente de gradient . L'instructeur note que l'ordre de ces étapes peut parfois être ambigu, mais il est important de conserver l'étape d'optimisation après la rétropropagation. L'instructeur explique également pourquoi les gradients de l'optimiseur doivent être mis à zéro à chaque itération pour éviter l'accumulation dans les boucles. L'instructeur suggère de pratiquer l'écriture d'une boucle de formation pour mieux comprendre ces étapes et fournit une chanson et des ressources supplémentaires pour un apprentissage plus approfondi.
  
  
• 06:25:00 Dans cette section de la vidéo, le présentateur récapitule les étapes d'une boucle d'entraînement dans PyTorch, qui implique un passage vers l'avant, le calcul de la valeur de perte, la mise à zéro des gradients d'optimisation et la rétropropagation sur la fonction de perte. La boucle de formation aide le modèle à apprendre des modèles sur les données de formation, tandis que la boucle de test évalue les modèles sur des données invisibles. Le présentateur explique également pourquoi nous mettons à zéro les gradients de l'optimiseur et introduit le concept de rétropropagation, qui calcule le gradient de la fonction de perte.
  
  
• 06:30:00 Dans cette section, l'instructeur explique le concept de gradients et de courbes de fonction de perte dans l'apprentissage en profondeur PyTorch. En définissant "nécessite grad" comme vrai pour les paramètres, PyTorch est capable de suivre les gradients de chaque paramètre et de créer une courbe de fonction de perte pour chacun d'eux. L'objectif de la rétropropagation et de la descente de gradient subséquente est de calculer le point le plus bas de la courbe, qui représente la perte minimale. L'instructeur explique le concept de gradients dans l'apprentissage automatique et comment la descente de gradient fonctionne avec des points d'étape. En optimisant la perte de zéro grad vers l'arrière, en optimisant l'étape et en nécessitant un grad, PyTorch fait une grande partie de ce travail dans les coulisses, en suivant automatiquement les gradients et en trouvant le bas de la courbe.
  
  
• 06:35:00 Dans cette section, l'instructeur discute de l'optimiseur et du taux d'apprentissage. L'optimiseur prend les paramètres du modèle et crée des courbes pour chaque paramètre à l'aide d'un mécanisme appelé torche autograd pour le calcul automatique du gradient afin de se rapprocher du bas de la courbe. Le taux d'apprentissage décide de la taille ou de la taille avec laquelle l'optimiseur modifie les paramètres à chaque étape, avec des étapes plus petites prises à mesure que nous nous rapprochons de la convergence. De plus, l'instructeur aborde les cinq étapes impliquées dans la formation d'un modèle, qui comprend l'initialisation du modèle, la définition de l'optimiseur, le taux d'apprentissage, le calcul de la passe avant, la propagation vers l'arrière et l'étape de l'optimiseur. Enfin, l'instructeur mentionne que cette boucle peut être transformée en une fonction, ce qui permet d'éviter les répétitions de codes.
  
  
• 06:40:00 Dans cette section du "PyTorch pour l'apprentissage en profondeur et l'apprentissage automatique - Cours complet", l'instructeur souligne l'importance d'écrire la boucle de formation dans PyTorch, car c'est ainsi que le modèle apprend les modèles et les données. La vidéo fournit également des ressources supplémentaires sur la rétropropagation et la descente de gradient pour ceux qui s'intéressent au contexte mathématique. L'instructeur explique que le choix de la fonction de perte et de l'optimiseur sera spécifique à chaque problème et recommande la perte MAE et la perte L1 pour les problèmes de régression et la perte d'entropie croisée binaire pour les problèmes de classification. La section se termine par une démonstration de la boucle d'apprentissage utilisant un modèle avec seulement deux paramètres et une seule époque.
  
  
• 06:45:00 Dans cette section, l'instructeur poursuit la formation du modèle d'apprentissage automatique à l'aide de PyTorch et montre comment la fonction de perte diminue à mesure que les paramètres du modèle sont mis à jour via la descente de gradient. L'instructeur souligne qu'une valeur de perte inférieure indique une meilleure progression du modèle et que les petites différences de valeurs dues au caractère aléatoire de l'apprentissage automatique ne devraient pas être préoccupantes. L'instructeur met ensuite le spectateur au défi d'exécuter le code pendant 100 époques et de faire des prédictions pour voir à quel point il peut obtenir la valeur de perte. Enfin, l'instructeur discute de l'importance des tests et taquine la vidéo suivante sur l'écriture de code de test.
  
  
• 06:50:00 Dans cette section, l'instructeur explique l'importance de rechercher et d'apprendre de nouveaux sujets à l'aide de ressources externes telles que Google et la documentation. Ils encouragent les apprenants à essayer d'exécuter le code de formation pendant 100 époques et à examiner les valeurs et les prédictions de pondération et de biais. L'instructeur poursuit ensuite en expliquant le code de test et le but de la fonction model.eval() , qui désactive les paramètres du modèle non nécessaires pour les tests, tels que les couches de norme d'abandon et de lot. Ils discutent également de l'objectif de torch.no_grad() et de la manière dont il désactive le suivi du gradient pendant les tests, car aucun apprentissage ne se produit à ce stade. Enfin, la section se termine par l'écriture de la passe avant du modèle en mode test.
  
  
• 06:55:00 Dans cette section, la vidéo explique comment créer des prédictions de test et calculer la perte de test à l'aide du modèle zéro dans PyTorch. Les prédictions de test sont faites sur l'ensemble de données de test, que le modèle n'a jamais vu auparavant, tout comme évaluer ses connaissances sur des matériaux qu'il n'a jamais vus auparavant. La vidéo explique l'importance de ne pas laisser le modèle voir l'ensemble de données de test avant de l'évaluer pour éviter d'obtenir de mauvais résultats. Le code imprime la perte et ce qui se passe toutes les 10e époques pendant que le modèle s'entraîne pendant 100 époques, et la perte diminue à chaque époque. La vidéo aborde également le concept de précision du modèle, qui peut être imprimé ultérieurement.

Partie 8

• 07:00:00 Dans cette section, l'instructeur passe en revue la vidéo précédente, dans laquelle il a entraîné un modèle et effectué des prédictions sur un ensemble de données simple. Ils mettent ensuite le spectateur au défi de trouver des moyens d'améliorer la capacité du modèle à aligner les points rouges prédits avec les points verts réels, éventuellement en entraînant le modèle plus longtemps. L'instructeur réexécute ensuite le code pour 100 époques supplémentaires et montre une amélioration significative de la perte de test et des prédictions du modèle. L'instructeur souligne que ce processus de formation et d'évaluation des modèles est fondamental pour l'apprentissage en profondeur avec PyTorch et sera utilisé dans le reste du cours. Ils discutent également de l'importance du suivi de la progression du modèle à l'aide d'une liste vide pour stocker des valeurs utiles.
  
  
• 07:05:00 Dans cette section, l'instructeur explique pourquoi il est important de suivre les valeurs de perte et comment nous pouvons les utiliser pour surveiller les progrès de notre modèle et les améliorer dans les expériences futures. L'extrait de code présenté ajoute le nombre d'époques, la valeur de perte actuelle et la valeur de perte de test actuelle à différentes listes afin qu'elles puissent être tracées ultérieurement. L'instructeur présente un tracé des courbes de perte générées à partir des listes et explique leur signification. Une courbe de perte idéale devrait commencer à un niveau élevé et diminuer avec le temps, représentant une valeur de perte décroissante.
  
  
• 07:10:00 Dans cette section, l'instructeur explique comment convertir les valeurs de perte de PyTorch en NumPy pour les tracer dans Matplotlib. Il montre que les convertir en NumPy est nécessaire puisque Matplotlib ne fonctionne qu'avec NumPy. Il explique également comment suivre les courbes de perte d'entraînement et de perte de test et mentionne que si elles correspondent étroitement à un moment donné, cela signifie que le modèle converge et que la perte se rapproche le plus possible de zéro. L'instructeur parcourt ensuite la boucle de test et explique qu'il est nécessaire de transmettre les données de test à travers le modèle, de calculer la valeur de perte de test et d'imprimer ce qui se passe pendant la formation pour garder une trace des valeurs de ce qui se passe. Enfin, il suggère de mettre toutes ces étapes dans une fonction et fournit une chanson de boucle d'optimisation PyTorch non officielle pour se souvenir des étapes.
  
  
• 07:15:00 découvrez dans cette section - les trois principales méthodes d'enregistrement et de chargement de modèles dans PyTorch. La première méthode, torch.save, vous permet d'enregistrer un objet PyTorch au format pickle de Python. La deuxième méthode, torch.load, vous permet de charger un objet PyTorch enregistré. Et la troisième méthode, torch.nn.module.loadStateDict, vous permet de charger le dictionnaire enregistré d'un modèle ou d'enregistrer le dictionnaire d'état, que nous allons explorer dans la vidéo suivante. Ces méthodes sont essentielles pour enregistrer et réutiliser des modèles, en particulier lorsque vous travaillez avec des modèles plus volumineux ou lorsque vous devez partager des modèles avec d'autres.
  
  
• 07:20:00 Dans cette section, l'instructeur explique le concept des dictionnaires d'état et leur importance dans PyTorch. PyTorch stocke les paramètres importants d'un modèle dans un dictionnaire, appelé dictionnaire d'état, qui contient l'état du modèle, y compris les paramètres apprenables tels que les poids et les biais. L'instructeur montre comment enregistrer et charger le modèle PyTorch en enregistrant son dictionnaire d'état à l'aide des méthodes torch.save et torch.load. De plus, l'instructeur fournit un défi supplémentaire à l'utilisateur pour lire et comprendre les avantages et les inconvénients de l'enregistrement de l'intégralité du modèle plutôt que du simple dictionnaire d'état. Enfin, l'instructeur partage le code PyTorch pour enregistrer le modèle et créer un dossier appelé models.
  
  
• 07:25:00 Dans cette section de la vidéo, l'instructeur montre comment enregistrer un modèle PyTorch en utilisant la méthode recommandée d'enregistrement du dict d'état. Le modèle reçoit un nom et le chemin est créé à l'aide de la bibliothèque pathlib. Une fois que le chemin est prêt, le dict d'état du modèle est enregistré à l'aide de la fonction torch.save(), où le premier paramètre est l'objet et le second est le chemin où le modèle doit être enregistré. L'instructeur montre comment la commande LS est utilisée pour vérifier si le modèle est enregistré dans le répertoire des modèles. La vidéo fournit également un guide pour télécharger le modèle enregistré sur une machine locale ou sur Google Drive. De plus, l'instructeur encourage le spectateur à se mettre au défi en lisant à l'avance la documentation et en utilisant la fonction torch.load() pour apprendre à charger un modèle enregistré.
  
  
• 07:30:00 Dans cette section, l'instructeur explique comment charger un modèle PyTorch et comment utiliser la méthode de chargement de points de torche. Le dictionnaire de paramètres précédemment enregistré de la classe à partir d'un modèle sera chargé en tant que jeu d'états, et cette section montre comment créer une nouvelle instance de la classe de modèle de régression linéaire et y charger le jeu d'états enregistré. La méthode load state deck du module torch nn permet de charger le dictionnaire d'état directement dans l'instance de modèle, tandis que la méthode de chargement de points torche prend F et le transmet au chemin de sauvegarde du modèle où le deck d'état précédent est enregistré.
  
  
• 07:35:00 Dans cette section, l'instructeur passe en revue l'enregistrement et le chargement d'un modèle dans PyTorch. Ils testent le modèle chargé en faisant de nouvelles prédictions avec les données de test et en les comparant aux prédictions du modèle d'origine à l'aide de la fonction équivalente égale égale. L'instructeur dépanne les modèles qui ne sont pas équivalents en créant un nouvel ensemble de prédictions de modèles et en testant à nouveau l'équivalence. Ils couvrent les principaux aspects de l'enregistrement et du chargement d'un modèle, mais suggèrent de consulter des didacticiels pour plus de détails. L'instructeur prévoit de rassembler toutes les étapes couvertes jusqu'à présent dans les prochaines vidéos.
  
  
• 07:40:00 Dans cette section de la vidéo, l'instructeur passe par l'ensemble du flux de travail d'apprentissage en profondeur à l'aide de PyTorch, y compris l'importation de PyTorch, l'enregistrement et le rechargement de modèles et la création de code indépendant de l'appareil, ce qui permet au code d'utiliser le GPU si disponible, ou le CPU par défaut sinon. L'instructeur encourage les téléspectateurs à faire une pause et à essayer de recréer le code par eux-mêmes, tout en offrant des conseils et des conseils utiles. La vidéo explique également comment créer des ensembles de données factices et tracer des points de données, qui seront utilisés pour créer un modèle qui apprendra à prédire les points verts à partir des points bleus.
  
  
• 07:45:00 Dans cette section, l'instructeur montre comment créer des données à l'aide de la formule de régression linéaire où y est égal au poids multiplié par les caractéristiques plus le biais. Ils expliquent que les principes de construction d'un modèle pour estimer ces valeurs restent les mêmes, et ils procèdent à la création des caractéristiques x et y, qui seront utilisées pour prédire les valeurs d'apprentissage et de test. Ils divisent également les données en ensembles d'apprentissage et de test et tracent les données pour visualiser les modèles dans les données.
  
  
• 07:50:00 Dans cette section, l'instructeur présente le concept de construction d'un modèle linéaire PyTorch pour les données factices linéaires données. Ils sous-classent nn.module pour créer un modèle de régression linéaire et initialiser les paramètres à l'aide de couches. La couche nn.Linear prend les entités en entrée et en sortie, et applique une transformation linéaire aux données entrantes en utilisant la même formule que le modèle de régression linéaire. Les formes d'entrée et de sortie du modèle dépendent des données, et l'instructeur souligne que différents exemples d'entités d'entrée et de sortie seront vus tout au long du cours.
  
  
• 07:55:00 Dans cette section, l'instructeur explique comment utiliser la couche linéaire dans PyTorch en tant que couche préexistante pour créer un modèle. La couche linéaire est une forme de régression linéaire y est égal à x, a transposé plus b, dans les caractéristiques, hors des caractéristiques. En sous-classant nn.module, nous pouvons créer une couche linéaire et remplacer la méthode avant pour transmettre les données à travers la couche linéaire, qui effectue le calcul avant prédéfini. La puissance de torch.nn de PyTorch est qu'il crée les paramètres pour nous dans les coulisses, et nous n'avons pas à les initialiser manuellement. De plus, l'instructeur discute des différents noms de la couche linéaire, tels que la transformation linéaire, la couche de sondage, la couche entièrement connectée, la couche dense et le flux intensif.

Partie 9

• 08:00:00 Dans cette section, l'instructeur aborde les différentes couches disponibles dans torch.nn, y compris convolutionnelle, mise en commun, remplissage, normalisation, récurrente, transformateur, linéaire et abandon. Des implémentations prédéfinies de ces couches sont fournies par PyTorch pour les tâches courantes d'apprentissage en profondeur. La section passe ensuite à la formation du modèle linéaire PyTorch précédemment construit à l'aide des fonctions de perte et d'optimisation. L'optimiseur optimisera les paramètres de pondération et de biais du modèle pour minimiser la fonction de perte, qui mesure à quel point le modèle est erroné. L'instructeur configure la fonction de perte L1 et l'optimiseur SGD pour cette tâche.
  
  
• 08:05:00 Dans cette section de la vidéo, l'instructeur explique l'importance de choisir un taux d'apprentissage approprié pour l'optimiseur, car un pas trop petit ou trop grand peut avoir un impact négatif sur les performances du modèle. Les étapes impliquées dans l'écriture d'une boucle d'apprentissage sont également expliquées, ce qui comprend la réalisation d'une passe vers l'avant, le calcul de la valeur de perte, la mise à zéro de l'optimiseur, la rétropropagation et l'ajustement des pondérations et des biais. De plus, l'instructeur suggère d'utiliser torch.manual_seed() pour garantir des résultats reproductibles et fournit un code pour imprimer la perte d'entraînement et la perte de test toutes les 10 époques.
  
  
• 08:10:00 Dans cette section du cours PyTorch, l'instructeur explique comment écrire du code indépendant de l'appareil pour les données, en soulignant qu'il est crucial d'avoir tous les calculs sur le même appareil pour éviter les erreurs. Le modèle et les données doivent se trouver sur le même appareil, qui peut être CPU ou CUDA. En plaçant les données d'entraînement et de test sur l'appareil cible à l'aide du train X et du train Y, cela crée un code indépendant de l'appareil, qui fournit des résultats plus précis lors de l'entraînement du modèle. L'instructeur explique également comment évaluer le modèle à l'aide de l'état ponté, démontrant que les paramètres estimés sont proches de la valeur idéale. La section se termine par un défi pour les utilisateurs de faire et d'évaluer des prédictions et de les tracer sur les données d'origine.
  
  
• 08:15:00 Dans cette section, l'instructeur explique l'importance de transformer le modèle PyTorch en mode d'évaluation et de faire des prédictions sur les données de test que le modèle n'a jamais vues auparavant. Ils apportent la fonction de prédictions de tracé pour visualiser les prédictions du modèle, mais ils rencontrent une erreur de type lorsqu'ils tentent de convertir le tenseur de type d'appareil CUDA en NumPy car Matplotlib fonctionne avec NumPy, pas PyTorch. Ils résolvent cette erreur en utilisant le processeur de points de tenseur pour copier d'abord le tenseur dans la mémoire hôte. L'instructeur encourage également les spectateurs à enregistrer et à charger leur modèle formé à l'aide du module de chemin, qu'ils illustrent en créant un répertoire de modèles et en définissant le chemin du modèle vers celui-ci.
  
  
• 08:20:00 Dans cette section, l'instructeur explique comment enregistrer et charger des modèles PyTorch à l'aide du module path lib de Python. Tout d'abord, un chemin de sauvegarde du modèle est créé avec l'extension .PTH pour PyTorch. Le dictionnaire d'état du modèle est ensuite enregistré à l'aide de la méthode d'enregistrement de la torche. L'instructeur note que l'affichage explicite du jeu d'états peut ne pas être viable pour les modèles comportant de nombreux paramètres. Pour charger le modèle enregistré, le dictionnaire d'état enregistré est chargé dans une nouvelle instance du modèle de régression linéaire V2 à l'aide de la méthode pontée de l'état de chargement et en transmettant le chemin du fichier de l'objet PyTorch enregistré. L'utilisation de la couche linéaire prédéfinie de PyTorch et son appel dans la méthode directe sont également abordés.
  
  
• 08:25:00 Dans cette section, l'instructeur termine en vérifiant que le modèle chargé a les mêmes paramètres que le modèle enregistré en l'évaluant à l'aide du mode d'inférence de la torche. Ils félicitent ensuite l'utilisateur d'avoir terminé le flux de travail PyTorch en créant un modèle, en l'entraînant et en l'enregistrant pour le réutiliser. L'instructeur souligne ensuite que les utilisateurs peuvent trouver les exercices et le programme supplémentaire dans la version livre du matériel de cours sur learnpytorch.io. Ils fournissent également des modèles de cahiers d'exercices numérotés par section et peuvent être trouvés sur le référentiel GitHub d'apprentissage en profondeur PyTorch sous extras et exercices.
  
  
• 08:30:00 Dans cette section, l'instructeur fournit des informations sur la manière de réaliser les exercices de flux de travail et de trouver des ressources supplémentaires pour le cours PyTorch. Il insiste sur l'importance d'essayer les exercices par vous-même avant de regarder des exemples de solutions. La section se termine par un résumé du flux de travail PyTorch couvert, qui comprend la préparation des données, leur transformation en tenseurs, la construction ou la sélection d'un modèle, le choix d'une fonction de perte et d'un optimiseur, la formation du modèle, la réalisation de prédictions et l'évaluation du modèle. La section suivante se concentre sur la classification des réseaux de neurones avec PyTorch, qui est l'un des plus gros problèmes de l'apprentissage automatique. L'instructeur fournit des ressources pour obtenir de l'aide tout au long du cours, y compris la page de discussions GitHub du cours et la documentation PyTorch. Il explique également ce que sont les problèmes de classification et donne des exemples tels que prédire si un e-mail est un spam ou non.
  
  
• 08:35:00 Dans cette section du cours PyTorch, l'instructeur aborde différents types de problèmes de classification dans l'apprentissage en profondeur. La classification binaire, c'est quand il n'y a que deux options, comme spam ou pas spam. La classification multi-classes se produit lorsqu'il existe plus de deux options, comme la classification d'une image en tant que sushi, steak ou pizza. La classification multi-étiquettes se produit lorsqu'un exemple peut avoir plus d'une étiquette, comme l'attribution de balises à un article de Wikipedia. L'instructeur fournit des exemples concrets et explique les concepts en détail. Il fait également la distinction entre la classification binaire et multi-classes avec des exemples de classification d'images de chiens et de chats dans un problème de classification binaire et de classification d'images de différents animaux dans un problème de classification multi-classes.
  
  
• 08:40:00 Dans cette section, l'instructeur explique l'architecture d'un modèle de classification de réseau neuronal et les formes d'entrée et de sortie d'un modèle de classification. Il souligne l'importance des entrées numériques pour les modèles d'apprentissage automatique et explique comment les entrées numériques se présentent souvent sous différentes formes en fonction des données. Il aborde également le processus de création de données personnalisées pour l'ajustement et la prédiction et couvre les étapes impliquées dans la modélisation pour la classification des réseaux neuronaux. En outre, l'instructeur explique comment configurer une fonction de perte et un optimiseur pour un modèle de classification, créer des boucles d'entraînement et d'évaluation, enregistrer et charger des modèles, exploiter la non-linéarité et évaluer des modèles de classification. Il conclut en donnant un exemple de la façon de représenter numériquement des photos d'aliments et de sa prédiction à l'aide d'un algorithme d'apprentissage automatique.
  
  
• 08:45:00 Dans cette section, l'instructeur du cours PyTorch for Deep Learning & Machine Learning fournit des détails sur le processus d'encodage numérique et le format de sortie. Les entrées de l'algorithme d'apprentissage automatique sont des images codées numériquement, qui ont des sorties associées dans les probabilités de prédiction. L'instructeur note que plus la probabilité de prédiction est proche de un, plus le modèle est confiant dans sa sortie. Cette sortie provient de l'examen de plusieurs échantillons, et il est possible d'ajuster l'algorithme et les données pour améliorer ces prédictions. Les sorties codées doivent être remplacées par des étiquettes compréhensibles pour les humains. De plus, l'instructeur discute de la forme des tenseurs, y compris la taille du lot, les canaux de couleur et la hauteur/largeur. Une taille de lot de 32 est une pratique courante et la forme peut varier en fonction du problème à résoudre.
  
  
• 08:50:00 Dans cette section, l'instructeur explique l'architecture d'un modèle de classification, qui est le schéma de ce qu'est un réseau de neurones. La forme de la couche d'entrée est déterminée par le nombre d'entités, qui doivent être codées sous forme de représentation numérique, et la couche de sortie est souvent une probabilité de prédiction pour une certaine classe. Il existe des hyperparamètres tels que le nombre de couches cachées, les neurones par couche cachée et la forme de la couche de sortie qui doivent être décidés par l'utilisateur. L'instructeur donne également des exemples de code pour créer des couches et des neurones à l'aide de PyTorch, et note que les formes varient en fonction du problème à résoudre.
  
  
• 08:55:00 Dans cette section, l'instructeur aborde les composants d'un problème de classification, y compris l'activation de la couche cachée, l'activation de la sortie, la fonction de perte et l'optimiseur, et fournit des exemples de chacun. L'instructeur présente ensuite un problème de classification multi-classes et explique comment l'architecture peut être construite pour avoir plusieurs fonctionnalités de sortie. Enfin, l'instructeur passe à l'écriture de code à l'aide de PyTorch sur Google CoLab, rappelant au public que tout le code sera enregistré sur un référentiel GitHub. L'instructeur insiste également sur l'importance de commencer tout problème d'apprentissage automatique avec des données.