Apprentissage Automatique et Réseaux Neuronaux - page 32

[MetaQuotes]

Série de conférenciers ETL : Ilya Sutskever, OpenAI

Série de conférenciers ETL : Ilya Sutskever, OpenAI

Dans une vidéo YouTube intitulée "ETL Speaker Series : Ilya Sutskever, OpenAI", Ilya Sutskever, co-fondateur et scientifique en chef d'OpenAI, aborde des sujets tels que les grands modèles de langage, les prémisses derrière les neurones artificiels, la conscience dans l'IA et la structure financière de organisations d'IA à but non lucratif. Sutskever souligne l'importance du progrès technique et de la bonne recherche pour le succès d'OpenAI et encourage les étudiants intéressés par l'IA et l'entrepreneuriat à explorer leurs idées uniques. Il prédit également que les améliorations apportées aux différentes couches de la pile d'apprentissage en profondeur et de la formation spécialisée auront un impact énorme à l'avenir. Enfin, les hôtes remercient Sutskever pour sa discussion perspicace et l'invitent à revenir pour de futurs événements, tout en dirigeant également les téléspectateurs vers le site Web du coin électronique de Stanford pour plus de ressources sur l'entrepreneuriat et l'innovation.

• 00:00:00 Dans cette section, Ravi Balani présente Ilya Sutskever, le co-fondateur et scientifique en chef d'OpenAI, qui est reconnu comme l'esprit fondateur derrière la sortie du grand modèle de langage génératif pré-formé Transformer 3 (GPT-3) et son produit d'accompagnement, Chat GBT. Balani explique les antécédents de Sutskever en tant qu'immigrant russo-israélien qui a étudié les mathématiques et l'informatique en Israël et a ensuite obtenu son doctorat à l'Université de Toronto. Sutskever est considéré comme l'instigateur d'AlexNet, qui s'est fait connaître pour avoir lancé la révolution de l'apprentissage en profondeur qui a conduit au paysage actuel de l'IA. Sutskever explique ensuite les prémisses du grand modèle de langage et comment il s'inspire des neurones biologiques du cerveau humain.
  
  
• 00:05:00 Dans cette section, Ilya Sutskever d'OpenAI discute du développement de l'algorithme de rétropropagation, l'équation mathématique que les réseaux de neurones utilisent pour apprendre de l'expérience. Il explique qu'un grand modèle de langage est un réseau neuronal formé pour deviner le mot suivant à partir des mots précédents dans le texte avec une grande précision, et que la compréhension est opérationnalisée grâce à l'optimisation de l'erreur de prédiction. Sutskever suggère que les neurones artificiels ne sont pas si différents des neurones biologiques, et si nous pouvons imaginer cela, nous pouvons voir que les humains sont capables de faire un assez bon travail pour deviner le mot suivant, tout comme les grands modèles de langage actuels. Cependant, il met en garde contre les comparaisons directes entre les humains et les réseaux de neurones artificiels, car notre compréhension de l'apprentissage humain est encore limitée.
  
  
• 00:10:00 Dans cette section, Ilya Sutskever, co-fondateur d'OpenAI, discute des différences entre la façon dont les réseaux de neurones apprennent et la façon dont les humains apprennent. Les réseaux de neurones sont solides en mathématiques ou en programmation ; cependant, ils ont besoin de beaucoup de données pour atteindre ce niveau d'expertise. D'un autre côté, les humains peuvent comprendre quelque chose en profondeur même s'ils n'ont lu qu'un petit nombre de documents. Lorsqu'il s'agit de discuter du point de singularité où les machines dépasseront l'apprentissage et l'adaptation humains, Sutskever ne sait pas quand ce point se produira. Des progrès doivent se produire et l'incertitude est élevée. Il est difficile de définir la conscience, mais c'est une fatalité qui doit être testée dans les systèmes d'IA.
  
  
• 00:15:00 Dans cette section, Ilya Sutskever, directeur scientifique d'OpenAI, discute du concept de conscience dans l'intelligence artificielle. Il suggère que la conscience est plus une question de degré qu'un concept binaire et que les animaux peuvent également avoir une forme de conscience réduite par rapport aux humains. Il passe ensuite à parler de la mission d'OpenAI et des questions éthiques entourant leur décision de passer d'une organisation à but non lucratif à une organisation à but lucratif étroitement liée à Microsoft. Il reconnaît sa responsabilité directe dans les progrès réalisés par OpenAI et comment l'éthique joue un rôle dans sa prise de décision.
  
  
• 00:20:00 Dans cette section, Ilya Sutskever discute des avantages et des inconvénients de l'IA open source par rapport à l'IA source fermée. Bien que l'IA open source empêche la concentration du pouvoir entre les mains de quelques-uns, ce qui est souhaitable du point de vue de l'équilibre des pouvoirs, elle peut ne pas être idéale à long terme, car les capacités de l'IA deviennent de plus en plus puissantes. À terme, la sécurité devrait devenir le moteur évident et immédiat pour ne pas ouvrir ces modèles. De plus, la décision d'opter pour une organisation à but non lucratif ou à but lucratif n'est pas simple compte tenu du coût important des centres de données, dont la majeure partie de l'argent du financement va aux fournisseurs de cloud.
  
  
• 00:25:00 Dans cette section, Ilya Sutskever, le co-fondateur d'OpenAI, explique la structure financière des organisations à but non lucratif comme la leur qui traitent de l'intelligence artificielle (IA). Ces entreprises ont besoin de fonds importants pour soutenir de grands réseaux de neurones, qui ne peuvent plus être pris en charge par les universités car leurs coûts sont devenus trop importants. Ainsi, des organisations à but non lucratif comme OpenAI financées par des dons offrent aux entreprises d'IA une possibilité de contribuer aux universitaires. La structure financière d'OpenAI est unique ; ce n'est pas une société à but lucratif mais une "société à but lucratif plafonné". L'équité dans OpenAI est une obligation avec une obligation finie envers les investisseurs. Une fois payé, OpenAI redevient une organisation à but non lucratif. Bien que cela puisse sembler fou, cette structure est essentielle car l'IA prend de plus en plus d'importance, et il peut être plus avantageux pour les entreprises d'IA de soutenir les investissements à but non lucratif. Microsoft est l'un des investisseurs d'OpenAI, et OpenAI tient des discussions AGI (Artificial General Intelligence) avec eux alors qu'ils comprennent le potentiel d'AGI et son impact sur le monde.
  
  
• 00:30:00 Dans cette section, Ilya Sutskever discute de l'obligation fiduciaire d'OpenAI et des risques potentiels pour les investisseurs. Il distingue OpenAI de DeepMind car OpenAI est détenu par une organisation à but non lucratif qui a un GP ou un LP dans la section à but lucratif. De plus, Sutskever partage ses réflexions sur la nécessité de réglementations gouvernementales et d'évaluations minutieuses pour des réseaux de neurones plus puissants afin de réaliser des progrès sensés et soigneusement vérifiés ou certifiés. Concernant les obligations éthiques, il reconnaît l'importance des obligations citoyennes, mais donne la priorité à l'épanouissement des États-Unis où il réside.
  
  
• 00:35:00 Dans cette section, l'intervieweur demande à Ilya Sutskever d'OpenAI quelles mesures ils suivent en tant que North Star pour leur succès. Sutskever dit que le principal KPI est le progrès technique et faire de bonnes recherches, comprendre les systèmes, mieux les former et mieux les contrôler. Il pense que la technologie de base est au cœur du succès d'OpenAI. Lorsqu'on lui a demandé si OpenAI serait une destination pour les gens ou utilisé dans le cadre de l'infrastructure back-end, Sutskever dit qu'il est difficile de répondre à la question car les choses changent si vite. En termes de conseils pour les étudiants intéressés par l'IA et l'entrepreneuriat, Sutskever recommande de se pencher sur ses prédispositions uniques et d'explorer ses propres idées.
  
  
• 00:40:00 Dans cette section, Ilya Sutskever parle de sa croyance en la confiance en l'intuition, particulièrement précieuse dans l'entrepreneuriat où des perspectives uniques peuvent être exploitées pour se concentrer sur de nouvelles opportunités. Interrogé sur l'avenir de l'apprentissage en profondeur dans les cinq à dix prochaines années, Sutskever prédit que des progrès continueront d'être réalisés sur le terrain, peut-être pas grâce à l'accent mis précédemment sur la mise à l'échelle, mais plutôt grâce à des améliorations dans diverses couches de la pile d'apprentissage en profondeur. . Il souligne également la valeur de l'identification de nouvelles frontières dans l'apprentissage en profondeur comme voie de contribution et prédit que la formation des spécialistes aura un impact énorme à l'avenir, mais seulement après qu'une formation généraliste des réseaux de neurones aura été établie.
  
  
• 00:45:00 Dans cette section, l'orateur discute de l'idée d'une formation spécialisée et de la façon dont cela se produit déjà dans une certaine mesure, en particulier dans la communauté open source, où les gens travaillent avec des modèles sous-alimentés et doivent obtenir autant de performances que possible. Il pense que l'avantage gagnant de l'IA sera une combinaison de plusieurs facteurs, notamment le fait d'avoir des ensembles de données propriétaires et un modèle de base performant. Lorsqu'il s'agit de diffuser la technologie de l'IA aux chercheurs et aux startups, il suggère que les approches intermédiaires, telles que l'accès aux modèles, peuvent être très productives pour étudier les réseaux de neurones qui ont une surface de comportement étendue et compliquée. Enfin, l'orateur partage que l'impact de l'intégration de l'IA chez OpenAI est une légère augmentation de la productivité, mais cela n'a pas conduit à un changement radical dans la dynamique d'équipe.
  
  
• 00:50:00 Dans cette section, les animateurs remercient Ilya Sutskever pour sa discussion perspicace sur l'intelligence artificielle et l'apprentissage en profondeur. Ils l'invitent à revenir pour de futurs événements et rappellent au public les prochaines sessions ETL mettant en vedette des leaders de l'industrie. Ils dirigent également les téléspectateurs vers le site Web du coin électronique de Stanford pour plus de ressources sur l'entrepreneuriat et l'innovation.

[MetaQuotes]

Ilya Sutskever (scientifique en chef OpenAI) - Construction d'AGI, alignement, espions, Microsoft et illumination

Ilya Sutskever (scientifique en chef OpenAI) - Construction d'AGI, alignement, espions, Microsoft et illumination

Le scientifique en chef d'OpenAI, Ilya Sutskever, couvre une gamme de sujets dans cette vidéo, y compris le potentiel d'utilisations illicites de GPT, l'importance de la fiabilité dans les systèmes d'IA, le rôle de la collaboration homme-machine dans la construction d'AGI, les limitations logicielles et matérielles d'AGI, et le potentiel de la recherche universitaire. Il pense qu'une combinaison d'approches sera nécessaire pour réduire la probabilité de désalignement dans la construction de l'IAG, et que les percées nécessaires pour une IA surhumaine ne se sentiront pas nécessairement comme des percées avec le recul. Il souligne également la valeur de l'apport humain dans les modèles d'enseignement et suggère que l'impact des modèles linguistiques peut aller au-delà du monde numérique.

• 00:00:00 Dans cette section, Ilya Sutskever discute du potentiel d'utilisations illicites du GPT et reconnaît qu'il est possible que des gouvernements étrangers l'utilisent déjà à des fins de propagande. Il note également que s'il est difficile de donner un calendrier exact pour la transition de l'IA à l'IAG, la valeur économique de l'IA continuera d'augmenter de manière exponentielle dans les années qui l'ont précédée. Sutskever utilise également la voiture autonome comme analogie pour l'état actuel de l'IA, notant que si les modèles peuvent sembler capables de tout faire, il reste encore du travail à faire pour assurer la fiabilité et la robustesse. Enfin, Sutskever admet qu'il est difficile de prédire quel pourcentage du PIB l'IA représentera d'ici 2030 et pourquoi il pourrait ne pas atteindre un pourcentage élevé.
  
  
• 00:05:00 Dans cette section, le scientifique en chef d'OpenAI, Ilya Sutskever, discute de l'importance de la fiabilité des systèmes d'IA et de la manière dont elle peut affecter la valeur économique qu'ils produisent. Il parle également du potentiel du paradigme actuel des modèles génératifs pour mener à l'IAG et que l'intégration de différentes idées du passé peut créer le prochain paradigme. Sutskever conteste l'affirmation selon laquelle la prédiction la plus proche ne peut pas surpasser la performance humaine et explique comment elle peut conduire à des idées sur des personnes hypothétiques avec une capacité mentale bien supérieure à la personne moyenne. Enfin, il confirme que la plupart des données pour l'apprentissage par renforcement proviennent déjà de l'IA plutôt que des humains et parle du potentiel des enseignants humains à collaborer avec l'IA pour s'améliorer sans intervention humaine.
  
  
• 00:10:00 Dans cette section, le scientifique en chef d'OpenAI, Ilya Sutskever, discute de l'importance de la collaboration homme-machine dans la construction de systèmes dotés de capacités de raisonnement avancées et de la nécessité d'une formation dédiée pour améliorer les capacités de raisonnement en plusieurs étapes dans les modèles d'apprentissage automatique. Il aborde également les préoccupations concernant la rareté des données et suggère que le passage au multimodal peut être une direction précieuse pour obtenir plus de données. Alors que la robotique n'était pas une direction possible pour OpenAI dans le passé en raison de la rareté des données, il y a peut-être plus de potentiel de progrès dans le domaine maintenant, mais cela nécessite un engagement et un dévouement forts à la tâche. Enfin, Sutskever exprime son enthousiasme pour les idées futures qui pourraient ne pas bien fonctionner avec les limitations matérielles actuelles.
  
  
• 00:15:00 Dans cette section, Ilya Sutskever discute des limitations matérielles pour la construction d'AGI et de ses perspectives sur la réalisation de l'alignement. Il pense qu'il n'y aura pas une seule définition mathématique de l'alignement, mais plutôt plusieurs définitions qui examinent l'alignement sous différents aspects, et qu'une combinaison d'approches sera nécessaire pour réduire la probabilité de désalignement. Sutskever mentionne également la possibilité d'un petit réseau de neurones bien compris pour vérifier le comportement d'un grand réseau de neurones. Interrogé sur les revenus prévus d'OpenAI d'un milliard de dollars en 2024, Sutskever explique que la manne pour une nouvelle technologie à usage général est difficile à estimer, mais attribue ce chiffre à la croissance potentielle des produits d'OpenAI.
  
  
• 00:20:00 Dans cette section de la vidéo, Ilya Sutskever, scientifique en chef d'OpenAI, explique comment les données jouent un rôle vital dans la détermination de l'avenir de l'IAG. Il souligne que faire des prédictions sans données conduira à une grande marge d'erreur. Il partage également ses réflexions sur l'avenir post-AGI, affirmant que l'AGI pourrait aider les humains à devenir plus éclairés et à interagir plus correctement avec le monde. Cependant, Sutskever souligne qu'il sera difficile pour les gens de comprendre ce qui se passe précisément et comment contribuer à la société à mesure qu'elle se transforme. En outre, il espère que l'AGI ne dictera pas la manière dont la société doit être gérée, et que les gens sont toujours libres de commettre leurs propres erreurs et d'en subir les conséquences, l'AGI fournissant davantage un filet de sécurité de base.
  
  
• 00:25:00 Dans cette section, le scientifique en chef d'OpenAI, Ilya Sutskever, discute du matériel dans l'IA et réfute l'idée que le TPU personnalisé de Google leur donne un avantage sur les GPU. Il explique que fondamentalement, l'architecture des TPU et des GPU est très similaire et que la seule chose qui compte pour le matériel est le coût par flop et le coût global des systèmes. Sutskever partage également des informations sur le travail nécessaire au développement de l'IA, qui implique de comprendre le système et les résultats, et pas seulement de proposer de nouvelles idées. Il parle également du partenariat d'OpenAI avec Microsoft et de la vulnérabilité de l'écosystème de l'IA aux revers tels qu'une catastrophe naturelle à Taïwan.
  
  
• 00:30:00 Dans cette section, Ilya Sutskever discute de la possibilité que le coût d'inférence devienne un obstacle à l'avancement des modèles d'IA. Il suggère que l'utilité du modèle déterminera si le coût est prohibitif ou non, notant que différents clients utilisent déjà différents réseaux de neurones de différentes tailles en fonction de leur cas d'utilisation. Il aborde également les préoccupations concernant les gouvernements étrangers qui tentent de se renseigner sur les modèles et l'importance de la fiabilité et de la contrôlabilité en tant que propriétés émergentes. Bien qu'il ne soit pas simple de prédire des capacités spécifiques, il pense que des progrès seront réalisés dans l'amélioration des modèles, les rendant plus fiables et mieux à même de résoudre les problèmes.
  
  
• 00:35:00 Dans cette section, Ilya Sutskever discute des lois d'échelle de l'IA et du lien entre la précision de la prédiction du mot suivant et la capacité de raisonnement. Bien qu'il considère que les lois d'échelle sont importantes, il pense que d'autres choses peuvent donner plus de raisonnement par unité d'effort. Il met également l'accent sur la valeur de l'apport humain dans l'enseignement des modèles, ainsi que sur la relation entre l'existence de données, de GPU et de transformateurs, suggérant que leur développement est étroitement lié. En outre, Sutskever exprime sa conviction que la révolution de l'apprentissage en profondeur aurait finalement eu lieu, quels que soient les pionniers, et admet la difficulté d'aligner des modèles qui pourraient potentiellement déformer leurs intentions.
  
  
• 00:40:00 Dans cette section, Ilya Sutskever discute du potentiel de la recherche universitaire pour fournir des informations importantes sur les capacités de l'IA, mais reconnaît qu'il semble actuellement plus facile pour les entreprises de réaliser ces capacités. Il note également que l'impact des modèles de langage peut s'étendre au-delà du monde des bits et dans le monde des atomes, selon les actions qu'ils suscitent. Sutskever pense que les percées nécessaires à l'IA surhumaine ne semblent pas nécessairement être des percées avec le recul, et qu'il peut être important d'être inspiré par les humains et le cerveau, mais aussi conscient des qualités non essentielles qui peuvent égarer la recherche.
  
  
• 00:45:00 Dans cette section, Ilya Sutskever répond à la dernière question sur la raison pour laquelle il existe une forte corrélation entre être le premier à la révolution de l'apprentissage en profondeur et être toujours l'un des meilleurs chercheurs. Il croit que la persévérance est une condition nécessaire mais pas suffisante pour réussir. Beaucoup de choses doivent être réunies et il faut avoir la bonne façon de voir les choses. C'est une question difficile à répondre, mais il a continué à essayer très fort, et cela s'est avéré avoir suffi jusqu'à présent.

[MetaQuotes]

Leçon 1 : Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 1 : Apprentissage en profondeur pratique pour les codeurs 2022

Dans cette vidéo YouTube "Leçon 1 : Apprentissage en profondeur pratique pour les codeurs 2022", l'instructeur présente le cours, en soulignant le rythme rapide des changements dans l'apprentissage en profondeur, et démontre la facilité de créer un système "oiseau ou pas oiseau" à l'aide de Python. Le cours vise à montrer aux gens comment construire et déployer des modèles d'abord, plutôt que de commencer par un examen de l'algèbre linéaire et du calcul, et couvrira une gamme de modèles d'apprentissage en profondeur, y compris des algorithmes basés sur des images qui peuvent classer les sons ou les mouvements de la souris. L'instructeur souligne l'importance de la création de blocs de données, de la compréhension des détecteurs de caractéristiques et de l'utilisation de modèles pré-formés pour réduire les exigences de codage. Le cours couvre également la segmentation et l'analyse tabulaire, avec fast.ai fournissant les meilleures pratiques qui aident à réduire le codage et à améliorer les résultats.

La vidéo fournit une introduction à l'apprentissage en profondeur et à ses applications dans divers domaines. Le présentateur aborde les bases de l'apprentissage automatique, y compris le processus d'entraînement du modèle et l'importance du calcul de la perte pour mettre à jour le poids du modèle pour de meilleures performances. La leçon couvre deux modèles : l'apprentissage tabulaire et le filtrage collaboratif. Le présentateur souligne également l'utilité des blocs-notes Jupyter dans la création et le partage de code, y compris des exemples de projets d'étudiants passés qui ont conduit à de nouvelles startups, des articles scientifiques et des offres d'emploi. Le principal point à retenir est que les futurs apprenants en profondeur devraient expérimenter et partager leur travail avec la communauté pour obtenir des commentaires et une expérience précieux.

• 00:00:00 Dans cette section, l'instructeur présente la première leçon de l'apprentissage approfondi pratique pour les codeurs version 5, en soulignant tout ce qui a changé depuis la dernière mise à jour du cours. Il utilise une bande dessinée humoristique XKCD de fin 2015 comme exemple de la rapidité avec laquelle les choses évoluent dans le domaine de l'apprentissage en profondeur. Par la suite, il démontre la création d'un système "oiseau ou pas oiseau" à l'aide de Python, qui implique le téléchargement et le redimensionnement d'images d'oiseaux et de forêts, la création d'un bloc de données à l'aide de fast.ai et l'affichage de certaines des images téléchargées. L'instructeur souligne que le cours fournira beaucoup plus de détails et que le but de cette section est de donner un aperçu rapide de haut niveau.
  
  
• 00:05:00 Dans cette section, le présentateur montre à quel point il est facile de créer un modèle de vision par ordinateur et d'identifier si une image contient un oiseau ou une forêt avec seulement 200 images de chacun. Ce qui était auparavant presque impossible est maintenant devenu facilement accessible grâce à l'apprentissage en profondeur, et le présentateur partage l'exemple de DALLꞏEꞏ2, un algorithme qui génère de nouvelles images à partir de texte brut. Ces avancées récentes en matière d'apprentissage en profondeur témoignent de la rapidité avec laquelle ce domaine évolue, et le présentateur note qu'il est accessible sans nécessiter beaucoup de code, de mathématiques ou autre chose qu'un ordinateur portable.
  
  
• 00:10:00 Dans cette section, l'orateur discute des capacités des modèles d'apprentissage en profondeur et de la manière dont ils exécutent des tâches que l'on croyait autrefois impossibles pour les ordinateurs. Ils mentionnent à quel point l'apprentissage en profondeur est utilisé dans les modèles d'art et de langage, tels que le modèle de langage des voies de Google qui peut expliquer la réponse à une blague. L'orateur reconnaît également la nécessité de considérations éthiques dans l'apprentissage en profondeur et recommande de suivre un cours sur l'éthique des données sur Ethics.fast.ai. Ils introduisent ensuite une version en ligne du système de gobelets colorés pour vérifier comment vont les étudiants et remercient Radek de l'avoir créé, qui vient d'annoncer qu'il a décroché le travail de ses rêves chez Nvidia AI.
  
  
• 00:15:00 Dans cette section de la vidéo, l'instructeur met l'accent sur l'importance du contexte dans l'apprentissage, en particulier dans le domaine de l'apprentissage en profondeur. Plutôt que de commencer par une révision de l'algèbre linéaire et du calcul, l'instructeur croit que les gens apprennent plus efficacement lorsqu'on leur donne un contexte en place. Il utilise l'analogie de l'apprentissage du sport, où l'on montre tout un jeu de sport, puis on assemble progressivement plus de pièces. C'est l'approche qu'il adopte dans ce cours, où l'on apprendra d'abord à construire et à déployer des modèles, puis à approfondir plus tard les cours les plus sophistiqués et techniquement détaillés. L'instructeur discute également de ses références et de son expérience en apprentissage automatique, y compris l'écriture du livre populaire "Deep Learning for Coders".
  
  
• 00:20:00 Dans cette section, l'instructeur explique l'approche historique de la vision par ordinateur avant l'introduction des réseaux de neurones. Il décrit comment les modèles d'apprentissage automatique précédents s'appuyaient sur des experts pour créer des fonctionnalités qui dictaient la façon dont l'algorithme identifierait les objets. L'instructeur oppose cela aux réseaux de neurones qui apprennent eux-mêmes ces fonctionnalités, permettant un développement et une formation beaucoup plus rapides des modèles. L'instructeur note que la capacité des réseaux de neurones à apprendre leurs propres fonctionnalités et à s'adapter aux nouvelles données est la clé du succès de l'apprentissage en profondeur ces dernières années.
  
  
• 00:25:00 Dans cette section, l'instructeur explique le concept de détecteurs de caractéristiques dans l'apprentissage en profondeur, qui sont des couches de réseaux de neurones capables d'identifier et d'extraire des caractéristiques spécifiques d'images sans intervention humaine. Il a illustré comment ces détecteurs de caractéristiques peuvent être combinés pour reconnaître des images plus complexes et sophistiquées. De plus, l'instructeur met l'accent sur la polyvalence des algorithmes basés sur l'image et sur la façon dont ils peuvent être utilisés pour classer les sons ou même les mouvements de la souris. Enfin, il démystifie le mythe selon lequel l'apprentissage en profondeur nécessite beaucoup de données, des ordinateurs coûteux et des mathématiques approfondies, affirmant que l'apprentissage par transfert permet un travail de pointe en utilisant un minimum de ressources.
  
  
• 00:30:00 Dans cette section, l'instructeur discute de la popularité de Pytorch par rapport à Tensorflow dans le monde de l'apprentissage en profondeur, Pytorch se développant rapidement et dépassant Tensorflow dans les référentiels de recherche et parmi les chercheurs. Cependant, il note que Pytorch peut nécessiter beaucoup de code pour des tâches relativement simples, c'est là que la bibliothèque fast.ai est utile. La bibliothèque fast.ai est construite sur Pytorch et fournit les meilleures pratiques qui aident à réduire la quantité de code nécessaire et à améliorer les résultats. L'instructeur présente également le bloc-notes Jupyter, une application Web largement utilisée dans l'industrie, le milieu universitaire et l'enseignement de la science des données, et mentionne des serveurs cloud comme Kaggle qui peuvent être utilisés pour exécuter des blocs-notes Jupyter.
  
  
• 00:35:00 Dans cette section de la vidéo, l'instructeur explique comment utiliser les notebooks Jupyter pour coder, expérimenter et explorer avec des exemples. Il explique comment modifier ou copier le bloc-notes de quelqu'un d'autre, démarrer un ordinateur virtuel pour exécuter des codes, utiliser des raccourcis clavier, écrire de la prose ou des annotations et insérer des images dans le bloc-notes. Le cours couvre également la dernière version de fast.ai et une petite quantité de code Python. Grâce aux notebooks Jupyter, les développeurs peuvent présenter leur code et rendre leur travail accessible à d'autres personnes de la communauté open source.
  
  
• 00:40:00 Dans cette section, l'orateur discute de l'utilisation de bibliothèques externes et présente certaines des bibliothèques fast.ai telles que "fastdownload" et "resize_images". Ils expliquent également l'importance de la commande de bloc de données, qui est utilisée pour obtenir les données dans le modèle. Le bloc de données a cinq paramètres principaux à spécifier, notamment le type d'entrée, le type de sortie, le type d'étiquette et les éléments à partir desquels nous devons nous entraîner. L'orateur souligne que la compréhension du bloc de données est cruciale pour les praticiens de l'apprentissage en profondeur, car la mise au point de l'architecture du réseau de neurones apparaît rarement dans la pratique, et ce cours est axé sur l'apprentissage en profondeur pratique.
  
  
• 00:45:00 Dans cette section, l'orateur explique les étapes de création d'un bloc de données, qui sont essentielles au succès d'un modèle d'apprentissage en profondeur. Le bloc de données est chargé de trouver des images sur lesquelles s'entraîner en utilisant une fonction qui récupère tous les fichiers image dans un chemin spécifié, en mettant de côté certaines données pour les tests et en redimensionnant les images à une taille standard. La création d'un bloc de données est suivie de la création de chargeurs de données, qui fournissent un flux de lots de données pouvant être traités par le modèle. Le conférencier introduit également le concept d'apprenant, qui combine le modèle et les données et qui est essentiel pour former un modèle d'apprentissage en profondeur.
  
  
• 00:50:00 Dans cette section, l'instructeur explique comment utiliser des modèles pré-formés dans fast.ai pour des tâches de vision par ordinateur à l'aide de la bibliothèque de modèles d'image pytorch (timm). La famille de modèles resnet est suffisante pour la plupart des cas d'utilisation, mais de nombreux autres modèles sont disponibles. L'instructeur montre comment affiner le modèle pour une tâche spécifique, telle que la reconnaissance d'images d'oiseaux dans une forêt, et comment déployer le modèle à l'aide de la méthode predict(). L'instructeur note également qu'il existe de nombreux autres types de modèles en plus de la vision par ordinateur, y compris la segmentation.
  
  
• 00:55:00 Dans cette section, l'orateur explique la segmentation, qui est utilisée pour colorer chaque pixel d'une image en fonction de ce qu'il représente. À l'aide d'une infime quantité de données et d'un code minimal, l'orateur montre comment un modèle peut être formé pour segmenter des images de scènes de route en différentes catégories telles que des voitures, des clôtures et des bâtiments en seulement 20 secondes, un modèle formé étant proche de la perfection après 2 minutes. L'orateur explique que des classes spéciales de chargeurs de données peuvent être utilisées pour le traitement des données, nécessitant encore moins de code pour les ensembles de données qui se produisent fréquemment. L'orateur passe ensuite à l'explication de l'analyse tabulaire et de la manière dont elle est largement utilisée dans des secteurs tels que la prédiction de colonnes de feuilles de calcul et de tableaux de données. En fournissant des informations similaires aux blocs de données et en utilisant l'envoi de type, vous pouvez utiliser fast.ai pour faire automatiquement ce qu'il faut pour vos données, quel que soit le type de données.
  
  
• 01:00:00 Dans cette section, la leçon couvre deux types de modèles : l'apprentissage tabulaire et le filtrage collaboratif. Les modèles tabulaires sont utilisés pour les données sans modèle pré-formé, où les tableaux de données varient considérablement. Le filtrage collaboratif est à la base de la plupart des systèmes de recommandation et fonctionne en trouvant des utilisateurs similaires en fonction des produits qu'ils aiment. Un ensemble de données de filtrage collaboratif aura un ID utilisateur, un ID produit (comme un film) et une note. La leçon montre ensuite comment créer des chargeurs de données de filtrage collaboratifs et discute des différences entre le réglage fin et l'ajustement d'un modèle.
  
  
• 01:05:00 Dans cette section, l'orateur parle de l'utilité des notebooks Jupyter en tant qu'outil de création et de partage de code, notamment du fait que toute la bibliothèque fast.ai est écrite dans des notebooks. De plus, le conférencier aborde l'état actuel de l'apprentissage en profondeur et ses applications dans divers domaines, notamment la PNL, la vision par ordinateur, la médecine, les systèmes de recommandation, les jeux et la robotique. L'orateur note que l'apprentissage en profondeur a été en mesure de briser les résultats de pointe dans de nombreux domaines, et qu'il est généralement bon pour les tâches qu'un humain peut faire raisonnablement rapidement.
  
  
• 01:10:00 Dans cette section, le présentateur explique l'idée de base de l'apprentissage automatique, en commençant par un programme normal dont les entrées et les résultats sont codés avec des conditions, des boucles et des variables. Le programme est ensuite remplacé par un modèle qui contient des poids aléatoires, et le modèle est une fonction mathématique qui prend des entrées et les multiplie par les poids. Le modèle est essentiellement inutile à moins que les poids ne soient choisis avec soin, il est donc nécessaire de calculer la perte, qui est un nombre qui mesure la qualité des résultats, et de mettre à jour les poids pour créer un nouvel ensemble légèrement meilleur que l'ensemble précédent. Ce processus est essentiel pour améliorer les performances du modèle.
  
  
• 01:15:00 Dans cette section, l'orateur explique le processus de formation d'un modèle en apprentissage automatique, qui consiste à répéter une simple séquence d'étapes qui utilisent des réseaux de neurones pour produire une sortie tout en remplaçant les négatifs par des zéros. En théorie, le modèle peut résoudre n'importe quelle fonction calculable s'il dispose de suffisamment de temps, de données et d'entrées, et le modèle formé peut être intégré dans n'importe quel programme en tant qu'autre morceau de code qui mappe les entrées aux résultats. Les programmeurs Python sont susceptibles de suivre facilement le processus, mais ceux qui ne sont pas familiers peuvent toujours expérimenter les cahiers Kaggle et essayer différentes choses comme modifier l'exercice d'oiseau ou de forêt, essayer trois ou quatre catégories et partager leur travail dans les forums. Le plus important est d'expérimenter et de lire le chapitre 1 du livre pour être prêt pour la prochaine leçon.
  
  
• 01:20:00 Dans cette section de la vidéo, l'instructeur partage plusieurs exemples de projets sur lesquels d'anciens étudiants ont travaillé dans le cours "Practical Deep Learning for Coders", qui ont conduit à de nouvelles startups, des articles scientifiques et des offres d'emploi. Ces projets incluent la classification de différents types de personnes en fonction de leur lieu de résidence, la création d'un classificateur de courgettes et de concombres, la classification précise des images satellite dans 110 villes différentes et la reconnaissance de l'état des bâtiments pour les efforts de résilience aux catastrophes. Certains étudiants ont même battu l'état de l'art dans leurs domaines respectifs, comme un classificateur sonore et le séquençage normal des tumeurs. L'instructeur encourage les étudiants actuels et futurs à commencer à créer des projets, quel que soit leur niveau d'expérience, et à les partager avec le forum pour obtenir des commentaires et des encouragements.

[MetaQuotes]

Lesson 2: Practical Deep Learning for Coders 2022

Lesson 2: Practical Deep Learning for Coders 2022

This YouTube video series provides an introduction to deep learning for coders. It covers topics such as data preparation, model creation, and deploying a machine learning model.

In this video, hacker Jeremy Howard teaches people how to create their own web apps using deep learning. He covers how to set up a project in Git, how to use the hugging face space to upload a model to be trained on, natural language processing, and how to recognize text.

• 00:00:00 This lesson covers practical deep learning for coders in 2022. New, cutting-edge techniques are being taught that will help students remember material better. The course goes with the book, and quizzes are available to help students test their progress.
  
  
• 00:05:00 This video covers the basics of deep learning for coding, including how to find data, data cleaning, and putting a model into production. The next video in the series will show how to do this.
  
  
• 00:10:00 In this video, Wes discusses how to train a model in deep learning using the ddg website. He shows how to search for objects, and how to resize images.
  
  
• 00:15:00 In this video, a technique for deep learning is introduced: RandomResizedCrop. This is used to improve the accuracy of recognition of images. Data augmentation is also discussed, and it is shown that if you want to train a deep learning model for more than five or ten epochs, you should use RandomResizedCrop and "aug_transforms."
  
  
• 00:20:00 This YouTube video demonstrates how to use a classifier interpretation object to determine where a loss is high in a data set. This information can then be used to clean up the data before it is used to train a model.
  
  
• 00:25:00 The video introduces data cleaning and practical deep learning for coders 2022. It covers data preparation with tools such as GPU-accelerated data cleaning and HuggingFace Spaces, followed by using Gradio for machine learning models in production.
  
  
• 00:30:00 This video covers how to use Git to manage your code and how to use a terminal to work on code. The video also goes over how to use VS Code to edit code.
  
  
• 00:35:00 This tutorial explains how to create a deep learning model using a few different methods, including a Kaggle example and a Colab example. Once the model is created, it can be downloaded and copied into the same directory as the code.
  
  
• 00:40:00 In this lesson, the author shows how to use a trained learner to predict whether an image is a dog or cat. The learner is frozen in time, and can be loaded and unloaded easily.
  
  
• 00:45:00 This video explains how to create a Gradio interface to convert images into classifications, and how to create a Python script to do this.
  
  
• 00:50:00 In this lesson, the instructor demonstrates how to create a simple PyTorch model and upload it to Gradio. He also provides instructions on how to use fastsetup to install PyTorch and Jupyter Notebooks on a computer.
  
  
• 00:55:00 This video provides instructions for installing python and some of the necessary libraries for deep learning, including Pytorch and Numpy. The author recommends using a conda-based python distribution, such as mambaforge, instead of the system python. Finally, the author recommends installing nbdev to use Jupyter Notebook.
  
  
• 01:00:00 In this lesson, the instructor demonstrates how to use Gradio, a free platform for training deep learning models, to create a website that predicts the names of cats and dogs. While streamlit is more flexible than Gradio, both platforms are free and easy to use.
  
  
• 01:05:00 This video explains how to create deep learning models using Javascript. The tutorial includes a multi-file version and an HTML version of the same model.
  
  
• 01:10:00 This video explains how to create a basic deep learning app using only Javascript and a browser. Once the app is created, you can use FastPages to create a website for it that looks like the app.
  
  
• 01:15:00 In this video, hacker Jeremy Howard teaches people how to create their own web apps using deep learning. He first discusses how to set up a simple project in Git, and then shows how to use the hugging face space to upload a model to be trained on. Next, he discusses natural language processing, explaining how models work under the hood. Finally, he demonstrates how deep learning can be used to recognize text.

[MetaQuotes]

Leçon 3 : Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 3 : Apprentissage en profondeur pratique pour les codeurs 2022

Cette vidéo fournit une introduction à l'apprentissage profond pratique pour les codeurs. Il couvre les bases de la multiplication matricielle et des gradients, et montre comment utiliser un modèle d'apprentissage en profondeur pour prédire la probabilité des races de chiens et de chats. Cette vidéo fournit une brève introduction à l'apprentissage en profondeur pour les codeurs, y compris une discussion sur la façon dont la multiplication matricielle peut prendre beaucoup de temps pour obtenir une sensation intuitive. La leçon suivante portera sur le traitement du langage naturel, qui consiste à prendre des données textuelles et à faire des prédictions basées sur sa prose.

• 00:00:00 Cette leçon couvre les multiplications matricielles et les gradients, et est destinée aux étudiants plus enclins aux mathématiques. Le cours comprend également une "Leçon zéro" sur la configuration d'une machine Linux à partir de zéro.
  
  
• 00:05:00 La vidéo de cette semaine présente cinq étudiants qui ont créé différents projets liés à l'apprentissage en profondeur. Un étudiant a créé un détecteur Marvel, un autre a créé un jeu où l'ordinateur perd toujours, un autre a créé une application pour prédire les températures moyennes, un autre a créé un classificateur de mouvement artistique et enfin, un étudiant a créé un détecteur de rédaction.
  
  
• 00:10:00 Cette vidéo couvre l'apprentissage en profondeur pratique pour les codeurs, y compris l'utilisation de différentes plates-formes et bibliothèques d'apprentissage en profondeur. Il explique comment former un modèle et le déployer dans un environnement de production.
  
  
• 00:15:00 Dans cette leçon, l'étudiant explique comment fonctionne l'apprentissage en profondeur et comment utiliser différents modèles d'apprentissage en profondeur. Il montre également comment utiliser un modèle d'apprentissage en profondeur pour prédire la probabilité des races de chiens et de chats.
  
  
• 00:20:00 Dans cette vidéo, un modèle d'apprentissage en profondeur est démontré. Le modèle se compose de couches, chacune contenant du code et des paramètres. Le modèle est flexible et peut être formé pour reconnaître des modèles dans les données.
  
  
• 00:25:00 Dans cette leçon, l'instructeur montre comment créer une fonction pour ajuster un ensemble de données en utilisant une application partielle d'une fonction. Il montre ensuite comment tracer la fonction et comment ajuster les coefficients de la fonction pour mieux l'adapter aux données.
  
  
• 00:30:00 Cette vidéo explique comment améliorer la capacité d'un ordinateur à prédire des valeurs à l'aide d'une fonction de perte. L'auteur montre comment procéder en déplaçant les curseurs sur un modèle graphique basé sur des curseurs et en vérifiant la fonction de perte pour voir si elle s'améliore ou s'aggrave. Pytorch peut calculer automatiquement le gradient pour vous, ce qui rend le processus rapide et facile.
  
  
• 00:35:00 Dans cette vidéo, le programmeur Pytorch explique comment utiliser la fonction gradient pour ajuster les coefficients d'une équation quadratique. La fonction de gradient renvoie le négatif de la pente de la courbe à laquelle elle est appliquée.
  
  
• 00:40:00 Cette vidéo explique comment créer un modèle d'apprentissage en profondeur à l'aide de Pytorch. Le modèle est optimisé à l'aide de la descente de gradient et les coefficients finaux sont déterminés par la fonction mathématique rectified_linear().
  
  
• 00:45:00 Dans cette vidéo, Jeremy explique comment utiliser la descente de gradient pour optimiser les paramètres dans les modèles d'apprentissage en profondeur. C'est la même technique qui est utilisée pour former les modèles dans la vraie vie.
  
  
• 00:50:00 Cette vidéo YouTube couvre l'apprentissage en profondeur pratique pour les codeurs et comment s'y prendre pour former des modèles de précision et de rapidité. Il conseille de commencer avec un modèle bien réglé et précis et d'ajouter progressivement plus de données pour voir si la précision s'améliore.
  
  
• 00:55:00 Dans cette vidéo, l'auteur explique comment calculer le gradient d'une fonction à l'aide de dérivées. L'auteur recommande de multiplier le gradient par un petit nombre, appelé taux d'apprentissage, afin d'éviter de sauter trop loin le long du gradient et de diverger.
  
  
• 01:00:00 Dans cette leçon, l'instructeur montre comment effectuer une multiplication matricielle afin d'effectuer des calculs d'apprentissage en profondeur sur des données réelles. Il fournit un site Web qui fournit un moyen facile de le faire.
  
  
• 01:05:00 L'orateur explique comment utiliser l'apprentissage en profondeur pour prédire si les passagers du vrai Titanic ont survécu ou non. Ils suppriment d'abord les colonnes qui ne sont pas pertinentes pour la prédiction, puis multiplient chaque ligne par un coefficient correspondant à la variable dépendante. Ensuite, ils créent une colonne intitulée "ont-ils embarqué à Southampton?" et une autre colonne intitulée « se sont-ils embarqués à Cherbourg ? et les convertir en variables catégorielles binaires. Enfin, ils prennent la moyenne de tous les coefficients et l'utilisent pour prédire la variable dépendante.
  
  
• 01:10:00 Cette leçon explique comment appliquer l'apprentissage en profondeur aux problèmes de codage à l'aide d'une régression linéaire. Tout d'abord, les données sont normalisées et transformées en journal pour les rendre plus uniformément réparties. Ensuite, les coefficients sont calculés à l'aide d'une fonction SumProduct dans Excel. Enfin, la descente de gradient est utilisée pour optimiser la fonction de perte.
  
  
• 01:15:00 Dans cette vidéo, un modèle d'apprentissage en profondeur est créé à partir de zéro à l'aide de Microsoft Excel. Le modèle fonctionne mieux qu'une régression pour prédire les taux de survie, mais il est plus lent et plus pénible à exécuter. la multiplication matricielle est utilisée pour accélérer le processus.
  
  
• 01:20:00 Cette vidéo fournit une brève introduction à l'apprentissage en profondeur pour les codeurs, y compris une discussion sur la façon dont la multiplication matricielle peut prendre beaucoup de temps pour obtenir une sensation intuitive. La leçon suivante portera sur le traitement du langage naturel, qui consiste à prendre des données textuelles et à faire des prédictions basées sur sa prose.
  
  
• 01:25:00 Cette vidéo fournit un guide étape par étape sur la façon d'utiliser l'apprentissage en profondeur pour la classification dans des langues autres que l'anglais.
  
  
• 01:30:00 Dans cette vidéo, le présentateur discute de l'importance des ensembles de validation et des métriques dans l'apprentissage en profondeur.

[MetaQuotes]

Leçon 4 : Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 4 : Apprentissage en profondeur pratique pour les codeurs 2022

Cette vidéo explique comment créer un modèle de deep learning pour le concours Coders 2022. L'auteur explique comment créer un ensemble de validation, comment utiliser les données de la concurrence pour tester les performances de votre modèle et comment éviter le surajustement dans les paramètres du monde réel. Dans cette vidéo, Jeremy explique comment utiliser le coefficient de corrélation de Pearson pour mesurer la relation entre deux variables, et comment utiliser Pytorch pour former un modèle qui se comporte comme un apprenant fast.ai. Il discute également d'un problème avec les prédictions générées par les techniques NLP, et comment il peut être résolu en utilisant une fonction sigmoïde.

• 00:00:00 Cette vidéo explique comment affiner un modèle de traitement du langage naturel pré-entraîné à l'aide d'une bibliothèque différente de fast.ai.
  
  
• 00:05:00 Cette vidéo couvre l'algorithme d'apprentissage profond pratique pour les codeurs 2022, ULMFiT. ULMFiT était un algorithme d'apprentissage automatique qui a été présenté pour la première fois dans un cours fast.ai. ULMFiT a ensuite été transformé en un article académique par l'auteur. Après une formation sur les critiques de films Wikipedia et IMDB, l'algorithme a pu prédire le sentiment d'une critique avec une précision de 70 %.
  
  
• 00:10:00 Dans cette leçon, Jeremy a expliqué les bases de l'approche du modèle de langage masqué de Transformers pour l'apprentissage automatique. Il a noté que cette approche est plus populaire que l'approche ULMFiT et qu'il y a cinq couches dans le modèle de transformateur. John a posé une question sur la façon de passer d'un modèle qui prédit le mot suivant à un modèle qui peut être utilisé pour la classification. Jeremy a dit que vous auriez besoin de détecteurs de bord et de détecteurs de gradient dans les premières couches et que la dernière couche aurait des activations pour chaque catégorie que vous prédisez. Il a dit que vous pouvez former ce modèle en ajoutant progressivement une nouvelle matrice aléatoire à la fin.
  
  
• 00:15:00 Le concours Kaggle "US Patent Phrase to Phrase Matching Competition" nécessite un modèle capable de déterminer automatiquement quelles paires ancre et cible parlent de la même chose. Dans cette vidéo, le présentateur propose de transformer les données en un problème de classification pour utiliser les techniques de la PNL.
  
  
• 00:20:00 Cette vidéo explique comment utiliser l'apprentissage en profondeur pour la classification de manière pratique, en travaillant avec un ensemble de données qui est déjà stocké dans un format de valeurs séparées par des virgules (CSV). La vidéo explique également comment utiliser les pandas pour lire les données.
  
  
• 00:25:00 Cette vidéo couvre l'utilisation de quatre bibliothèques pour l'apprentissage en profondeur : numpy, matplotlib, pandas et pytorch. L'auteur recommande de lire "Python for Data Analysis" de Wes McKinney si vous n'êtes pas familier avec ces bibliothèques. La première étape de la formation d'un réseau de neurones consiste à tokeniser les données, et la deuxième étape consiste à former le réseau.
  
  
• 00:30:00 Dans cette vidéo, le présentateur explique comment segmenter un texte en jetons et numériser les jetons pour créer un "ensemble de données" Hugging Face. Le présentateur recommande d'utiliser un modèle pré-formé pour la tokenisation et décrit certains des différents modèles disponibles.
  
  
• 00:35:00 Dans cette vidéo, le présentateur explique comment utiliser un tokenizer pour tokeniser une phrase et comment transformer les jetons en nombres. L'ensemble de données sera le même que l'ensemble de données d'origine, mais l'ensemble de données tokenisé sera différent en raison du tokenizer.
  
  
• 00: 40: 00 La vidéo explique comment transformer des chaînes de texte en chiffres pour permettre un apprentissage en profondeur et explique qu'il n'est pas nécessaire de suivre un format défini, tant que les informations sont fournies. Si un champ est particulièrement long, il peut être utile d'utiliser une approche de transformateur.
  
  
• 00:45:00 Dans cette vidéo, l'auteur explique l'importance d'avoir des ensembles de formation, de validation et de test séparés pour l'apprentissage automatique. Ils montrent comment tracer une régression polynomiale et illustrent la différence entre sous-ajustement et surajustement.
  
  
• 00:50:00 La vidéo explique comment créer un bon ensemble de validation pour un modèle d'apprentissage en profondeur et comment utiliser les données de la concurrence pour tester les performances de votre modèle. Il explique également comment éviter le surajustement dans des contextes réels.
  
  
• 00:55:00 Dans cette vidéo, nous découvrons l'apprentissage en profondeur et comment créer des modèles pour les compétitions Coders 2022. Nous apprenons qu'un ensemble de validation est un ensemble d'images qui ne sont pas utilisées pour former le modèle, et qu'un ensemble de test est un autre ensemble de validation utilisé pour mesurer la précision. Nous apprenons également qu'il existe deux ensembles de test - celui qui est affiché sur le classement pendant la compétition, et un deuxième ensemble de test qui n'est affiché qu'après la fin de la compétition.
  
  
• 01:00:00 Le "coefficient de corrélation de Pearson" est une mesure largement utilisée de la similarité de deux variables. Si vos prédictions sont très similaires aux valeurs réelles, le "coefficient de corrélation de Pearson" sera élevé.
  
  
• 01:05:00 Cette vidéo d'une minute explique comment utiliser le coefficient de corrélation de Pearson pour mesurer la relation entre deux variables. Le coefficient de corrélation est une mesure de l'étroitesse de la relation entre deux variables et peut être utilisé pour évaluer la force d'une relation entre deux variables. Le coefficient de corrélation peut être visualisé à l'aide d'un nuage de points et peut être utile pour évaluer l'ensemble de données pour lequel il est utilisé.
  
  
• 01:10:00 Dans cette vidéo, le présentateur explique comment former correctement un modèle d'apprentissage en profondeur. Ils couvrent des sujets tels que la corrélation, les valeurs aberrantes et la façon de diviser correctement les données. Ils montrent ensuite comment former le modèle avec un « apprenant » dans fast.ai et comment utiliser la « taille de lot » et les « époques » pour contrôler le nombre de lignes traitées à la fois.
  
  
• 01:15:00 Les transformateurs Hugging Face fournissent une variété de taux d'apprentissage pour différentes tâches et fournissent un modèle approprié pour classer les séquences à partir d'un modèle pré-formé. Il peut également identifier les valeurs aberrantes dans les données.
  
  
• 01:20:00 Dans cette leçon, l'instructeur explique comment utiliser Pytorch pour former un modèle qui se comporte comme un apprenant fast.ai. Il note que, bien que les valeurs aberrantes ne doivent jamais être supprimées, elles peuvent être étudiées et, si nécessaire, corrigées.
  
  
• 01:25:00 L'apprentissage en profondeur est une technologie puissante utilisée dans de multiples domaines d'application. Il est relativement convivial pour les débutants et le domaine du traitement du langage naturel (TAL) est celui où se trouvent les plus grandes opportunités. Une utilisation possible de la PNL d'apprentissage en profondeur est de créer une prose adaptée au contexte pour les médias sociaux, ce qui pourrait avoir des implications sur la façon dont les gens voient le monde.
  
  
• 01:30:00 Dans cette vidéo, John explique comment les techniques NLP, telles que l'apprentissage automatique, peuvent être utilisées pour générer un texte biaisé en faveur d'un point de vue particulier. La vidéo aborde également un problème avec les prédictions générées par les techniques NLP, et comment il peut être résolu en utilisant une fonction sigmoïde.

[MetaQuotes]

Leçon 5 : Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 5 : Apprentissage en profondeur pratique pour les codeurs 2022

Cette vidéo fournit un didacticiel sur la création et l'entraînement d'un modèle linéaire à l'aide de l'apprentissage en profondeur. La vidéo commence par discuter des opérations sur place, qui modifient les valeurs des variables dans une fonction donnée. Ensuite, la vidéo montre comment calculer la perte pour un modèle linéaire en utilisant la descente de gradient vers l'arrière. Enfin, la vidéo fournit une fonction qui initialise et met à jour les coefficients dans un modèle linéaire. La vidéo se termine en montrant comment exécuter la fonction et imprimer la perte. Cette vidéo explique comment calculer la meilleure répartition binaire pour une colonne donnée dans un ensemble de données. Ceci est particulièrement utile pour les compétitions d'apprentissage automatique, car il fournit un modèle de base pour la comparaison.

• 00:00:00 Cette leçon couvre le modèle linéaire et le réseau de neurones à partir de zéro à l'aide de Jupyter Notebook. L'objectif est de comprendre la logique derrière le code et d'obtenir la sortie attendue.
  
  
• 00:05:00 La vidéo traite de l'apprentissage approfondi pratique pour les codeurs, couvrant des sujets tels que l'installation de Kaggle et l'utilisation de sa variable d'environnement, la lecture de fichiers CSV avec des pandas et l'imputation des valeurs manquantes. Il couvre également les concepts de base des pandas tels que le mode et l'utilisation des méthodes et des réductions pour remplir les dataframes.
  
  
• 00:10:00 Dans cette leçon, Jeremy explique comment imputer les valeurs manquantes dans un ensemble de données à l'aide de la méthode fillna() dans pandas. Il explique que dans la plupart des cas, cette méthode "stupide" sera suffisante et qu'il est important de connaître les bases de notre ensemble de données afin que les méthodes courantes ne soient pas expliquées plusieurs fois. Javier pose des questions sur les avantages et les inconvénients de supprimer des champs qui ne sont pas utilisés dans le modèle.
  
  
• 00:15:00 Dans cette leçon, l'instructeur présente le concept de "variables fictives" et comment elles peuvent être utilisées pour représenter des données catégorielles de manière plus sensée. Il montre également comment décrire toutes les variables numériques et non numériques dans les données.
  
  
• 00:20:00 Dans cette vidéo, l'instructeur montre comment transformer une colonne d'une trame de données en tenseur et comment utiliser ces tenseurs pour former un modèle linéaire et un réseau de neurones. Il montre également comment utiliser Pytorch au lieu de Python simple lors de la multiplication matricielle et élémentaire.
  
  
• 00:25:00 Dans cette vidéo, l'instructeur explique comment effectuer un produit matrice-vecteur en Python. Il donne un exemple de multiplication d'une matrice par un vecteur et explique que le résultat est intéressant car les mathématiciens peuvent effectuer la même opération en utilisant l'algèbre matricielle. Il explique également que le démarrage d'une séquence pseudo-aléatoire est important afin de produire des résultats reproductibles.
  
  
• 00:30:00 Dans cette vidéo, l'auteur explique comment fonctionne la diffusion et pourquoi elle est utile. La diffusion est une technique qui permet de multiplier plusieurs valeurs ensemble, en tenant compte de la taille de chaque valeur. Cela permet un code plus concis et plus rapide à exécuter sur GPU.
  
  
• 00:35:00 Cette vidéo explique comment optimiser les modèles d'apprentissage en profondeur en calculant la perte de descente de gradient. L'auteur montre comment procéder en créant une fonction pour calculer la perte, puis en important la fonction dans une session Pytorch.
  
  
• 00:40:00 Cette vidéo YouTube propose un didacticiel sur la création et l'entraînement d'un modèle linéaire à l'aide de l'apprentissage en profondeur. La vidéo commence par discuter des opérations sur place, qui modifient les valeurs des variables dans une fonction donnée. Ensuite, la vidéo montre comment calculer la perte pour un modèle linéaire en utilisant la descente de gradient vers l'arrière. Enfin, la vidéo fournit une fonction qui initialise et met à jour les coefficients dans un modèle linéaire. La vidéo se termine en montrant comment exécuter la fonction et imprimer la perte.
  
  
• 00:45:00 Cette vidéo d'une minute explique comment créer une fonction de précision pour un modèle d'apprentissage en profondeur qui prédit qui a survécu au Titanic. La fonction est basée sur la fonction sigmoïde, qui est une fonction mathématique asymptote à un lorsque les nombres deviennent trop grands ou trop petits.
  
  
• 00:50:00 Dans cette vidéo, John explique comment optimiser un réseau neuronal en utilisant une fonction sigmoïde. Il explique également comment gérer les variables dépendantes des blocs de catégorie à l'aide de fast.ai.
  
  
• 00:55:00 Dans cette vidéo, l'auteur explique comment créer un modèle à partir de zéro en Python à l'aide de Pytorch et comment soumettre le modèle à Kaggle. L'auteur mentionne que l'opérateur "matrice-multiplier" signifie matrice-multiplier, mais que Python ne vient pas avec une implémentation de l'opérateur.
  
  
• 01:00:00 Dans cette vidéo, le présentateur explique comment créer un réseau de neurones à l'aide de Pytorch. La première étape consiste à créer une matrice avec les sommes des coefficients de la première colonne. Cette matrice est ensuite multipliée par le vecteur de données d'apprentissage. La deuxième étape consiste à créer une deuxième matrice avec les activations cachées. Cette matrice est ensuite multipliée par les coefficients de la première colonne. La dernière étape consiste à centraliser les vecteurs et à former le réseau de neurones.
  
  
• 01:05:00 Dans cette vidéo, Jeremy explique comment entraîner un réseau de neurones à l'aide du deep learning. Il explique que, pour entraîner le réseau, il doit d'abord calculer les gradients et initialiser les coefficients. Ensuite, il exécute update_coeffs(), qui soustrait les coefficients des gradients. Enfin, il entraîne le réseau et compare les résultats à un modèle linéaire.
  
  
• 01:10:00 Cette vidéo explique comment initialiser les modèles d'apprentissage en profondeur, comment mettre à jour les coefficients et comment parcourir toutes les couches. Il explique également pourquoi l'apprentissage en profondeur peut ne pas être aussi efficace sur de petits ensembles de données et comment obtenir de bons résultats avec des modèles d'apprentissage en profondeur.
  
  
• 01:15:00 Dans cette leçon, l'auteur enseigne comment utiliser un cadre d'apprentissage en profondeur et montre à quel point c'est beaucoup plus facile que de le faire à partir de zéro. L'auteur fournit également un tutoriel sur l'ingénierie des fonctionnalités avec Pandas.
  
  
• 01:20:00 Dans cette vidéo, le formateur montre comment utiliser la bibliothèque fastai pour recommander un taux d'apprentissage pour un modèle d'apprentissage en profondeur. Il montre comment exécuter plusieurs époques et compare les prédictions du modèle avec les prédictions de deux autres modèles. Enfin, il montre comment utiliser la fonction d'ensemble pour créer un ensemble de cinq prédictions dont la moyenne est calculée sur les lignes.
  
  
• 01:25:00 Dans cette vidéo, John explique comment fonctionnent les forêts aléatoires et pourquoi elles sont un algorithme d'apprentissage automatique populaire. Il montre également comment utiliser un raccourci pratique pour importer tous les modules nécessaires.
  
  
• 01:30:00 Dans cette vidéo, Pandas explique comment fonctionne l'apprentissage en profondeur et comment l'appliquer aux problèmes de codage. L'algorithme de forêt aléatoire est introduit et il est montré que cette technique peut être utilisée pour améliorer la précision des prédictions faites à l'aide d'une variable catégorique.
  
  
• 01:35:00 Ce résumé en 1 paragraphe explique comment marquer une division binaire en utilisant une méthode simple d'addition des scores d'écart type des deux groupes de données. Le meilleur point de partage est trouvé en calculant le plus petit indice dans la liste des points de partage avec le plus petit score.
  
  
• 01:40:00 Dans cette leçon, l'instructeur explique comment calculer la meilleure division binaire pour une colonne donnée dans un ensemble de données. Ceci est particulièrement utile pour les compétitions d'apprentissage automatique, car il fournit un modèle de base pour la comparaison.

[MetaQuotes]

Leçon 6 : Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 6 : Apprentissage en profondeur pratique pour les codeurs 2022

Cette vidéo YouTube fournit un guide sur la façon de démarrer avec l'apprentissage en profondeur pour les codeurs. L'accent est mis sur l'apprentissage approfondi pratique pour les codeurs, avec des conseils sur la façon de mettre en place un concours, d'obtenir un ensemble de validation et d'itérer rapidement. La vidéo traite également de l'importance des diagrammes d'importance des caractéristiques et de dépendance partielle, et de la manière de les créer à l'aide d'un modèle d'apprentissage automatique.

Cette vidéo donne un aperçu de la façon d'utiliser l'apprentissage en profondeur pour améliorer la précision des projets de codage. Il explique que les ensembles de données peuvent souvent avoir une grande variété de tailles d'entrée et de rapports d'aspect, ce qui rend difficile la création de représentations précises avec des rectangles. Il suggère d'utiliser à la place des représentations carrées, qui se sont révélées efficaces dans la plupart des cas.

• 00:00:00 Dans cette leçon, les auteurs montrent comment créer un arbre de décision pour prédire quels mâles survivent au Titanic.
  
  
• 00:05:00 La vidéo explique comment créer un classificateur d'arbre de décision avec au plus quatre nœuds feuilles. L'arbre peut être généré automatiquement et le code pour calculer le coefficient de Gini est fourni. L'erreur absolue moyenne de l'arbre de décision est calculée à 0,407.
  
  
• 00:10:00 Cette vidéo explique comment créer un arbre de décision pour prédire les classifications tarifaires des passagers à l'aide des données d'un concours Kaggle. Les arbres de décision sont efficaces et ne nécessitent pas de prétraitement, ce qui en fait une bonne option pour les données tabulaires.
  
  
• 00:15:00 La technique de "bagging" de Leo Breiman est utilisée pour créer un grand nombre de modèles impartiaux qui sont meilleurs que n'importe quel modèle individuel. Cela se fait en sélectionnant au hasard un sous-ensemble de données chaque fois qu'un arbre de décision est construit et en utilisant ces données pour former le modèle.
  
  
• 00:20:00 Dans cette leçon, nous avons appris à créer une forêt aléatoire, un algorithme d'apprentissage automatique simple à mettre en œuvre et qui fonctionne bien sur de petits ensembles de données. Nous avons également montré comment utiliser les diagrammes d'importance des caractéristiques pour nous aider à déterminer quelles caractéristiques sont les plus importantes dans les données d'apprentissage.
  
  
• 00:25:00 Dans cette vidéo, John couvre les bases de l'apprentissage en profondeur, y compris le fonctionnement des forêts aléatoires et pourquoi l'augmentation du nombre d'arbres conduit toujours à un meilleur taux d'erreur. Jeremy poursuit ensuite en expliquant comment les forêts aléatoires peuvent être utilisées pour prédire les résultats de grands ensembles de données sans avoir besoin d'un ensemble de validation.
  
  
• 00:30:00 La vidéo explique comment calculer l'erreur Out-of-Bag ou erreur OOB, qui est une mesure de la précision des prédictions faites sur des données non utilisées dans la formation d'un modèle d'apprentissage automatique. Il note que si l'erreur OOB est élevée, cela suggère que le modèle ne prédit pas correctement les données.
  
  
• 00:35:00 La vidéo traite de l'importance de l'importance des caractéristiques et des diagrammes de dépendance partielle, et de la manière de les créer à l'aide d'un modèle d'apprentissage automatique.
  
  
• 00:40:00 Dans cette vidéo, Jeremy explique comment fonctionnent les modèles Random Forest et comment interpréter leurs diagrammes d'importance des caractéristiques. Il mentionne également que les modèles Random Forest sont plus fiables que les autres techniques d'explicabilité.
  
  
• 00:45:00 Random Forests est un algorithme d'apprentissage automatique particulièrement efficace pour faire des prédictions. Cependant, ajouter plus d'arbres rendra le modèle plus précis, et le surajustement n'est pas un problème. Gradient Boosting est un algorithme d'apprentissage automatique similaire aux forêts aléatoires, mais au lieu d'ajuster un arbre encore et encore, il adapte de très petits arbres qui entraînent une faible division des données.
  
  
• 00:50:00 La vidéo explique comment une machine de renforcement de gradient (GBM) est plus précise qu'une forêt aléatoire, mais que vous pouvez suradapter avec un GBM. La procédure pas à pas montre comment choisir une compétition Kaggle et atteindre la première place.
  
  
• 00:55:00 Cette vidéo YouTube fournit un guide sur la façon de démarrer avec l'apprentissage en profondeur pour les codeurs. L'accent est mis sur l'apprentissage approfondi pratique pour les codeurs, avec des conseils sur la façon de mettre en place un concours, d'obtenir un ensemble de validation et d'itérer rapidement.
  
  
• 01:00:00 Cette vidéo explique comment utiliser FastKaggle pour former des modèles d'apprentissage en profondeur. Il explique que vous devez être prudent lorsque vous travaillez avec des images car la taille peut changer en fonction du rapport d'aspect. La vidéo montre également comment redimensionner les images à l'aide d'une fonction appelée "squish".
  
  
• 01:05:00 Dans cette vidéo, l'instructeur explique comment utiliser la bibliothèque d'IA rapide show_batch() pour voir rapidement à quoi ressemblent les données pour les modèles d'apprentissage automatique. Il recommande d'utiliser resnet26d pour des performances et une précision d'entraînement rapides.
  
  
• 01:10:00 La vidéo montre comment soumettre un modèle d'apprentissage en profondeur à Kaggle en moins d'une minute en utilisant un chargeur de données et un fichier CSV qui inclut les prédictions et les étiquettes du modèle.
  
  
• 01:15:00 Le présentateur partage sa stratégie pour créer des blocs-notes publics sur Kaggle, qui consiste à dupliquer et à renommer les blocs-notes selon les besoins afin de les garder organisés. Il note que cette approche low-tech fonctionne bien pour lui et qu'il ne soumet généralement qu'un seul bloc-notes à la fois.
  
  
• 01:20:00 Le présentateur donne un bref aperçu des différentes méthodes d'apprentissage en profondeur, y compris les frameworks AutoML et les forêts aléatoires. Il recommande d'utiliser un outil de recherche de taux d'apprentissage pour éviter de surentraîner les modèles et recommande d'utiliser des GPU pour un apprentissage en profondeur si possible.
  
  
• 01:25:00 Dans cette leçon, l'auteur explique comment accélérer une itération sur un concours Kaggle en utilisant une architecture de réseau neuronal convolutif (CNN) différente. Il montre également comment utiliser une règle empirique pour choisir la bonne taille de CNN.
  
  
• 01:30:00 Dans cette vidéo, le présentateur explique comment améliorer les performances d'un modèle d'apprentissage en profondeur en utilisant différentes techniques de prétraitement, notamment le recadrage et le rembourrage. Il note également que l'augmentation du temps de test (TTA) peut améliorer les performances d'un modèle en faisant la moyenne de plusieurs versions d'une image.
  
  
• 01:35:00 Dans cette vidéo, Jeremy explique comment améliorer la précision d'un modèle de vision par ordinateur à l'aide de l'apprentissage en profondeur. Il note que la précision du modèle peut être améliorée en faisant varier les images sur lesquelles il est formé, et donne un exemple de la façon de procéder en utilisant des pandas. Il explique également à quelle vitesse fonctionnent les algorithmes d'apprentissage en profondeur et comment utiliser le TTA, ou l'augmentation du temps de test, pour accélérer le processus de formation. Enfin, il fournit un résumé des questions posées par Victor et John.
  
  
• 01:40:00 Dans cette vidéo, Jeremy explique comment l'apprentissage en profondeur peut être utilisé pour améliorer la précision des projets de codage. Il note que les ensembles de données peuvent souvent avoir une grande variété de tailles d'entrée et de rapports d'aspect, ce qui rend difficile la création de représentations précises avec des rectangles. Il suggère d'utiliser plutôt des représentations carrées, qui se sont révélées efficaces dans la plupart des cas.

[MetaQuotes]

Leçon 7 : Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 7 : Apprentissage en profondeur pratique pour les codeurs 2022

Dans la leçon 7 de Practical Deep Learning for Coders 2022, Jeremy explique comment faire évoluer les modèles d'apprentissage en profondeur en réduisant la mémoire nécessaire pour les modèles plus grands. Il démontre une astuce appelée accumulation de gradient, qui consiste à ne pas mettre à jour les poids à chaque boucle de chaque mini-lot, mais à le faire de temps en temps, ce qui permet d'utiliser des tailles de lots plus importantes sans avoir besoin de GPU plus grands. De plus, Jeremy discute de la validation croisée k-fold et de la création d'un modèle d'apprentissage en profondeur qui prédit à la fois le type de riz et la maladie présente dans l'image en utilisant une fonction de perte différente appelée perte d'entropie croisée. Dans l'ensemble, la vidéo fournit des conseils et astuces pratiques pour créer des modèles d'apprentissage en profondeur plus complexes.

Dans cette vidéo, le conférencier explore la création de systèmes de recommandation utilisant le filtrage collaboratif et le produit scalaire dans PyTorch. Il décrit la prédiction par multiplication matricielle des classements de films et calcule la fonction de perte, une mesure de la correspondance entre les classements prédits et les classements réels. Il introduit le concept de plongement, qui permet d'accélérer les multiplicateurs matriciels avec des variables fictives. L'orateur explique ensuite comment ajouter un biais et une régularisation à la matrice pour différencier les évaluations des utilisateurs et éviter le surajustement. Enfin, le sujet de la recherche d'hyperparamètres est abordé, en soulignant le besoin de données granulaires pour des recommandations précises. Dans l'ensemble, la vidéo décompose les concepts complexes d'apprentissage en profondeur pour créer une compréhension pratique pour les téléspectateurs.

• 00:00:00 Dans cette section, l'instructeur présente une astuce simple pour agrandir davantage les modèles, qui consiste à réduire la mémoire nécessaire pour les modèles plus grands. Lorsque des modèles plus grands sont utilisés, plus de paramètres signifient qu'ils peuvent trouver des caractéristiques plus complexes, ce qui les rend plus précis. Cependant, les modèles plus grands ont un inconvénient car leurs activations ou gradients qui doivent être calculés consomment beaucoup de mémoire GPU, et si la mémoire disponible est insuffisante, cela entraîne un message d'erreur. L'instructeur explique comment contourner ce problème et utiliser un modèle x-large même sur le GPU 16 Gig de Kaggle.
  
  
• 00:05:00 Dans cette section de la vidéo, Jeremy discute des aspects pratiques de l'exécution de modèles d'apprentissage en profondeur sur Kaggle et de la manière d'utiliser des méthodes de hacky rapides pour déterminer l'utilisation de la mémoire des modèles. Il démontre une astuce appelée accumulation de gradient qui peut être utilisée si le modèle se bloque avec une "erreur de manque de mémoire cuda" pour éviter d'avoir à acheter un GPU plus grand. En ajustant la taille du lot et le nombre d'images, on peut s'assurer que le modèle utilise le minimum de mémoire possible sans affecter les taux d'apprentissage.
  
  
• 00:10:00 Dans cette section, l'orateur discute du concept d'accumulation de gradient, qui est l'idée de ne pas mettre à jour les poids à chaque boucle pour chaque mini-lot, mais de le faire à plusieurs reprises à la place. Cela permet d'utiliser des tailles de lots plus importantes sans avoir besoin de GPU plus grands, car le gradient peut être accumulé sur plusieurs lots plus petits. Les résultats sont numériquement identiques pour les architectures qui n'utilisent pas la normalisation par lots, mais peuvent introduire plus de volatilité pour celles qui le font. Dans l'ensemble, l'accumulation de gradient est une idée simple avec des implications importantes pour la formation de modèles plus grands.
  
  
• 00:15:00 Dans cette section, Jeremy discute des questions du forum concernant lr_find() et l'accumulation de gradient. Il explique que lr_find() utilise la taille de lot des chargeurs de données et que l'accumulation de gradient permet d'expérimenter avec différents lots pour trouver la taille optimale pour différentes architectures. Jeremy recommande de choisir la plus grande taille de lot pouvant tenir dans votre GPU, mais mentionne qu'il n'est pas toujours nécessaire d'utiliser la plus grande taille de lot. La règle d'or est de diviser la taille du lot par deux et de diviser le taux d'apprentissage par deux. Enfin, Jeremy montre comment utiliser l'accumulation de gradient dans fastai en divisant la taille du lot par la valeur d'accumulation souhaitée et en transmettant le rappel GradientAccumulation lors de la création de l'apprenant, lui permettant de former plusieurs modèles sur une carte de 16 Go.
  
  
• 00:20:00 Dans cette section, le présentateur discute de l'utilisation de modèles de transformateurs pré-formés vit, swinv2 et swin, qui ont des tailles fixes. Pour contourner ce problème, la taille finale doit être carrée et de la taille requise. Le présentateur utilise un dictionnaire d'architectures et de détails de prétraitement, en rebasculant le chemin de formation pour utiliser toutes les images et en parcourant chaque architecture et taille de transformation pour former chaque modèle. Le script de formation renvoie les prédictions tta, qui sont ajoutées à une liste qui est ensuite moyennée via la mise en sac pour créer une liste d'index pour chaque maladie. En soumettant régulièrement des candidatures, le présentateur a amélioré ses résultats et a pu s'assurer une place de choix dans le classement.
  
  
• 00:25:00 Dans cette section, Jeremy discute du concept de validation croisée k-fold et comment il est similaire à ce qu'il a fait avec les modèles d'assemblage. Il explique que la validation croisée k-fold est l'endroit où les données sont divisées en cinq sous-ensembles, et les modèles sont formés sur chaque sous-ensemble avec des ensembles de validation sans chevauchement, qui sont ensuite regroupés. Bien que cela puisse potentiellement être meilleur que sa méthode, Jeremy préfère l'assemblage car il permet d'ajouter et de supprimer facilement des modèles. Jeremy discute également de l'accumulation de gradient et du fait qu'il n'y a pas de réels inconvénients ou de pièges potentiels, et recommande d'acheter des cartes graphiques moins chères avec moins de mémoire plutôt que des cartes chères. Enfin, il mentionne que Nvidia est le seul jeu en ville pour les GPU, et les cartes RTX grand public sont tout aussi bonnes que les cartes d'entreprise coûteuses.
  
  
• 00:30:00 Dans cette section, Jeremy discute des avantages d'investir dans un GPU pour l'apprentissage en profondeur et reconnaît qu'ils peuvent être coûteux en raison de leur utilisation dans le cloud computing. Il aborde également la façon de former un modèle plus petit pour produire les mêmes activations qu'un plus grand, ce qui sera couvert dans la partie 2. Le reste de la vidéo se concentre sur la construction d'un modèle qui prédit à la fois la maladie et le type de riz d'une image. , qui nécessite un chargeur de données avec deux variables dépendantes. Jeremy explique comment utiliser le DataBlock pour créer un chargeur avec plusieurs variables dépendantes et montre comment différencier les catégories d'entrée et de sortie.
  
  
• 00:35:00 Dans cette section, l'instructeur explique comment créer un modèle d'apprentissage en profondeur qui prédit à la fois le type de riz et la maladie présente dans l'image. Pour ce faire, la fonction get_y doit prendre un tableau avec deux étiquettes différentes. L'un est le nom du répertoire parent, car il indique la maladie, et le second est la variété. L'enseignant crée une fonction qui prend l'emplacement dans le bloc de données du nom de fichier et renvoie la colonne de variété. Enfin, ils créent un modèle qui prédit 20 choses : la probabilité de chacune des 10 maladies et de chacune des 10 variétés. La métrique du taux d'erreur doit être modifiée pour gérer trois choses au lieu de deux pour fonctionner avec le nouvel ensemble de données.
  
  
• 00:40:00 Dans cette section, l'orateur explique la nécessité d'une fonction de perte différente appelée perte d'entropie croisée lorsque la variable dépendante est une catégorie. Alors que vision_learner de fastai a deviné et utilisé la perte d'entropie croisée plus tôt, l'orateur explique maintenant comment cela fonctionne en détail à l'aide d'une feuille de calcul. En commençant par la sortie d'un modèle comportant cinq catégories, l'orateur montre comment convertir les sorties du modèle en probabilités à l'aide de la fonction softmax. Une fois que les sorties sont des probabilités, la fonction de perte d'entropie croisée est utilisée pour mesurer la différence entre les probabilités prédites et les probabilités réelles, et déterminer les performances du modèle.
  
  
• 00:45:00 Dans cette section, nous découvrons softmax et comment il est utilisé pour prédire une chose spécifique à partir de catégories choisies à l'avance. La formule utilisée pour calculer la perte d'entropie croisée implique la multiplication des probabilités et des valeurs cibles réelles, puis la somme. Le log de softmax est utilisé pour accélérer les calculs. Le résultat est une valeur de probabilité unique qui est ensuite additionnée pour chaque ligne afin de calculer la perte d'entropie croisée.
  
  
• 00:50:00 Dans cette section, l'instructeur explique la fonction de perte d'entropie croisée binaire et comment l'utiliser avec plusieurs cibles. Il note que pytorch a deux versions des fonctions de perte, une classe et une fonction, et montre comment les utiliser. Lors de la création d'un modèle multi-cibles, l'apprenant de la vision a besoin de vingt sorties, dont dix prédisent la maladie et dix prédisent la variété. L'instructeur montre comment créer ce modèle, puis le forme. Dans l'ensemble, ce modèle est identique au modèle précédent, à l'exception de l'ajout du deuxième ensemble d'objectifs.
  
  
• 00:55:00 Dans cette section, nous apprenons comment un modèle sait ce qu'il prédit grâce à sa fonction de perte. Les dix premières colonnes de valeurs d'entrée prédisent la probabilité de maladie et les dix secondes représentent la probabilité de variété. En utilisant l'entropie croisée, nous prenons en compte à la fois les valeurs cibles de la maladie et de la variété pour créer une fonction de perte basée sur la prédiction de ces deux valeurs. La fonction de perte diminue lorsque les dix premières colonnes font de bonnes prédictions de maladies et les dix secondes pour la variété, ce qui rend les coefficients plus efficaces pour utiliser chaque colonne efficacement. Nous calculons et suivons les taux d'erreur pour les prédictions de maladies et de variétés tout au long de la période de formation. Un entraînement plus long à l'aide d'un modèle multi-cible peut parfois entraîner une meilleure prédiction de la maladie qu'un modèle à cible unique en raison de certaines caractéristiques aidant à reconnaître différentes cibles.
  
  
• 01:00:00 Dans cette section de la vidéo, l'orateur discute des avantages de la construction de modèles qui prédisent plusieurs choses et encourage les téléspectateurs à expérimenter avec des modèles sur de petits ensembles de données. Il présente également le bloc-notes Collaborative Filtering Deep Dive, qui utilise un ensemble de données de classifications de films pour enseigner le concept de systèmes de recommandation. Il explique que ce type de données est courant dans des industries telles que les systèmes de recommandation et fournit un exemple de tableau croisé pour mieux comprendre l'ensemble de données. L'orateur fait ensuite une pause avant de plonger dans le cahier suivant.
  
  
• 01:05:00 Dans cette section, l'intervenant explique comment combler les lacunes d'un ensemble de données de filtrage collaboratif. Le filtrage collaboratif permet de recommander un produit à un utilisateur en utilisant les données collectées auprès de nombreux utilisateurs. Pour déterminer si un utilisateur pourrait aimer un film particulier, l'orateur propose une méthode de multiplication des valeurs correspondantes des préférences de l'utilisateur et du type de film par analyse vectorielle. Cependant, comme nous ne disposons d'aucune information sur les utilisateurs ou les films, l'orateur suggère de créer des facteurs latents pour combler les points de données manquants. En utilisant des facteurs latents supposés, l'orateur propose d'utiliser SGD pour trouver la corrélation et générer des hypothèses.
  
  
• 01:10:00 Dans cette section, la vidéo décrit comment utiliser la multiplication matricielle pour prédire les classements des films pour les utilisateurs en fonction de leurs classements historiques. Le didacticiel attribue des valeurs aléatoires aux facteurs latents pour les films et les utilisateurs et exécute le produit scalaire pour prédire les classements. Une fonction de perte est ensuite calculée et l'optimisation est effectuée à l'aide de l'outil Data Solver. La vidéo montre que les notes prévues se sont améliorées en les comparant aux notes réelles après optimisation. La technique de complétion matricielle et le filtrage collaboratif, où les utilisateurs ayant des goûts similaires se voient recommander des films similaires, sont également introduits.
  
  
• 01:15:00 Dans cette section, la vidéo traite de l'utilisation du filtrage collaboratif et des produits scalaires dans PyTorch. Le cosinus de l'angle entre deux vecteurs peut se rapprocher de la corrélation, et ils sont les mêmes une fois normalisés. Excel est utilisé pour expliquer les calculs nécessaires dans PyTorch. La vidéo note également que les intégrations, souvent considérées comme un outil mathématique complexe, sont en fait des tableaux qui sont utilisés pour rechercher des éléments. La vidéo tente de décomposer le jargon déroutant pour rendre l'apprentissage en profondeur plus facile à comprendre pour tout le monde.
  
  
• 01:20:00 Dans cette section, Jeremy explique comment utiliser les chargeurs de données de filtrage collaboratifs dans PyTorch pour travailler avec les données d'évaluation des films. Il fusionne la table des films avec la table des classements pour obtenir l'identifiant et le nom du film. La fonction CollabDataLoaders est utilisée pour charger les données du bloc de données avec les notes, l'ID utilisateur et les colonnes de titre de l'élément. Ensuite, il crée des facteurs utilisateur et vidéo à l'aide d'une matrice de nombres aléatoires, où leur nombre de colonnes est égal au nombre de facteurs qu'il souhaite créer. Il mentionne également qu'il utilise une formule prédéterminée pour déterminer le nombre de facteurs, qui est dérivée de son intuition et testée en ajustant une fonction.
  
  
• 01:25:00 Dans cette section, l'orateur explique qu'un vecteur codé à chaud peut être utilisé pour rechercher un numéro d'index dans le vecteur, ce qui revient à prendre le produit scalaire d'un vecteur codé à chaud avec quelque chose. Les incorporations sont ensuite introduites comme un raccourci de calcul pour multiplier quelque chose par un vecteur codé à chaud, permettant une accélération de la création de multiplicateurs matriciels avec des variables fictives. L'orateur présente également la création d'un modèle Pytorch, qui est une classe qui comprend une superclasse appelée Module qui donne des fonctionnalités supplémentaires. L'objet produit scalaire est utilisé comme exemple de création d'un modèle, qui appelle la méthode dunder init et crée des incorporations d'utilisateurs par facteurs et de films par vecteurs.
  
  
• 01:30:00 Dans cette section, l'instructeur explique comment utiliser PyTorch pour appeler une méthode appelée "forward" pour calculer le modèle. L'objet lui-même et les données calculées sont passés en "forward". L'utilisation du produit scalaire et la transmission des données via PyTorch sont beaucoup plus rapides que l'utilisation d'Excel. Cependant, le modèle ne fonctionne pas bien puisque, par exemple, il prédit des valeurs supérieures à la valeur la plus élevée possible alors que personne n'a évalué un film en dessous d'un. L'instructeur y remédie en utilisant la fonction sigmoïde pour écraser la prédiction dans une plage comprise entre zéro et 5,5. Malgré ce changement, la perte ne s'améliore pas considérablement, mais l'instructeur introduit une nouvelle observation de certains utilisateurs ayant des notes élevées, suggérant que l'implication d'un biais utilisateur pourrait améliorer le modèle.
  
  
• 01:35:00 Dans cette section, l'orateur montre comment ajouter un biais à la matrice utilisée dans le modèle de recommandation de films. En ajoutant ces biais, il est possible de différencier les utilisateurs qui ont tendance à donner des notes inférieures ou supérieures. L'orateur explique également comment éviter le surajustement en utilisant la décroissance du poids ou la régularisation L2. L'orateur explique que cela peut être réalisé en ajoutant la somme des poids au carré à la fonction de perte. Dans l'ensemble, la section fournit une introduction utile au sujet des biais et de la régularisation dans les modèles d'apprentissage en profondeur.
  
  
• 01:40:00 Dans cette section, la vidéo traite de l'utilisation de la perte de poids comme forme de régularisation pour éviter le surajustement dans les modèles d'apprentissage en profondeur. En trouvant la bonne combinaison de poids qui ne sont pas trop élevés, mais suffisamment élevés pour être utiles lors de la prédiction, le modèle peut obtenir la valeur la plus faible possible de la fonction de perte. Le coefficient de décroissance du poids peut être transmis à la méthode d'ajustement et les valeurs par défaut conviennent normalement aux applications de vision, mais pour le filtrage tabulaire et collaboratif, les utilisateurs doivent essayer quelques multiples de 10 pour voir ce qui donne le meilleur résultat. La régularisation consiste à rendre le modèle pas plus complexe qu'il ne devrait l'être, les valeurs plus élevées de la décroissance du poids réduisant le surajustement mais réduisant également la capacité du modèle à faire de bonnes prédictions.
  
  
• 01:45:00 Dans cette section, Jeremy et John discutent du sujet de la recherche d'hyperparamètres et de la façon dont elle est souvent utilisée dans la construction de modèles individuels. Cependant, il n'y a pas de règles autres que la règle empirique de Jeremy lorsqu'il s'agit d'effectuer une exploration des hyperparamètres. En réponse à une question de savoir si les systèmes de recommandation peuvent être construits sur la base des notes moyennes de l'expérience des utilisateurs au lieu du filtrage collaboratif, Jeremy explique qu'il ne serait pas idéal si tout ce que l'on a est l'historique des achats. Au lieu de cela, des données granulaires telles que des informations démographiques sur les utilisateurs et des métadonnées sur les produits sont nécessaires pour faire des recommandations précises.

[MetaQuotes]

Leçon 8 - Apprentissage en profondeur pratique pour les codeurs 2022

Leçon 8 - Apprentissage en profondeur pratique pour les codeurs 2022

Cette vidéo couvre les bases de l'apprentissage en profondeur pour les codeurs. Il explique comment créer des paramètres pour les modèles d'apprentissage en profondeur à l'aide de la bibliothèque Pytorch, comment utiliser l'ACP pour réduire le nombre de facteurs dans un ensemble de données et comment utiliser un réseau de neurones pour prédire le prix de vente aux enchères d'équipements lourds industriels.

Cette vidéo YouTube donne un aperçu de l'apprentissage en profondeur pour les programmeurs. L'orateur explique que la ténacité est importante dans ce domaine et conseille que si vous voulez réussir, vous devez continuer jusqu'à ce que quelque chose soit terminé. Il recommande également d'aider d'autres débutants sur forums.fast.ai.

• 00:00:00 Dans cette leçon, Pytorch s'occupe de créer et de gérer les paramètres d'un réseau de neurones, en s'assurant automatiquement que les coefficients et les poids sont correctement initialisés. Cela évite à l'utilisateur d'avoir à se souvenir de ces informations ou d'écrire du code pour le faire.
  
  
• 00:05:00 Cette vidéo explique comment créer des paramètres pour des modèles d'apprentissage en profondeur à l'aide de la bibliothèque Pytorch. Pytorch initialisera automatiquement ces paramètres en fonction d'une distribution générée aléatoirement.
  
  
• 00:10:00 Cette vidéo montre comment créer une couche d'intégration Pytorch à partir de zéro, en utilisant le même code et les mêmes concepts que l'original. La vidéo montre ensuite comment la couche prédit les préférences de film en examinant les préférences de film passées.
  
  
• 00:15:00 La vidéo montre comment utiliser l'application d'apprentissage collaboratif fast.ai pour prédire quel film un utilisateur pourrait aimer. L'application utilise des facteurs latents (films et facteurs) pour calculer le biais d'un utilisateur, qui est ensuite utilisé pour prédire quel film l'utilisateur pourrait aimer.
  
  
• 00:20:00 Cette vidéo explique comment utiliser l'ACP pour réduire le nombre de facteurs dans un ensemble de données. Il couvre également le problème d'amorçage, qui consiste à savoir comment recommander de nouveaux produits aux clients lorsque vous n'avez aucun antécédent avec eux.
  
  
• 00:25:00 Cette vidéo couvre les bases de l'apprentissage en profondeur pour les codeurs, y compris un modèle séquentiel, comment utiliser les fonctionnalités de Pytorch pour créer facilement un modèle et comment adapter le modèle à un apprenant collaboratif. Jona pose au présentateur une question sur le problème des biais dans les systèmes de filtrage collaboratif, et le présentateur fournit une réponse générale sur le problème.
  
  
• 00:30:00 Dans cette vidéo, Jeremy explique comment les intégrations fonctionnent dans le filtrage collaboratif et le NLP, et comment elles peuvent être utilisées pour interpréter les réseaux de neurones.
  
  
• 00:35:00 Dans cette vidéo, l'auteur montre comment utiliser un réseau de neurones pour prédire le prix de vente aux enchères d'équipements lourds industriels, à l'aide d'une forêt aléatoire et d'un apprenant tabulaire. L'auteur note que le réseau de neurones créé à l'aide de l'apprenant tabulaire est presque identique au réseau de neurones créé manuellement.
  
  
• 00:40:00 Les réseaux de neurones peuvent être considérés comme un type d'algorithme d'apprentissage automatique qui prend des données en entrée et utilise ces données pour créer des prédictions ou des sorties. Les réseaux de neurones sont composés de couches de nœuds (appelés neurones), qui sont interconnectés pour créer un graphe. Les entrées d'un réseau de neurones peuvent être catégorielles (par exemple une catégorie telle que des voitures ou des fleurs) ou continues (c'est-à-dire un nombre). Les réseaux de neurones peuvent être utilisés pour prédire les résultats de différents résultats (par exemple, les ventes dans différents magasins) ou pour deviner le contenu d'une nouvelle entrée (par exemple, l'emplacement géographique d'un ensemble donné de points de données).
  
  
• 00:45:00 Dans cette vidéo, nous découvrons les convolutions, qui sont un type de multiplication matricielle utilisé dans les réseaux de neurones convolutifs. Nous voyons un exemple de cela en action, puis discutons de la façon de créer un détecteur de bord supérieur à l'aide de réseaux de neurones convolutifs.
  
  
• 00:50:00 La vidéo explique comment effectuer une convolution, une opération mathématique qui prend deux tableaux de données et combine leurs éléments, produisant un résultat généralement plus élevé du côté gauche du tableau que du côté droit. Une convolution est effectuée sur un noyau 3 par 3, qui est répétée plusieurs fois pour produire une couche d'apprentissage en profondeur.
  
  
• 00:55:00 La vidéo explique le fonctionnement de l'apprentissage en profondeur en montrant comment deux filtres, un pour les bords horizontaux et un pour les bords verticaux, sont combinés pour créer une seule activation pour la reconnaissance des nombres. L'ancienne façon de procéder, qui utilisait la mise en commun maximale, entraînait moins d'activations et finalement il en restait une. La méthode la plus récente, qui utilise une technique appelée "Max Pooling avec fenêtres coulissantes", continue jusqu'à ce que toutes les activations soient utilisées et produise un résultat plus précis.
  
  
• 01:00:00 Dans cette vidéo, le présentateur explique comment l'apprentissage en profondeur se fait au 21e siècle. Aujourd'hui, l'apprentissage en profondeur se fait différemment d'il y a 10 ans, et le présentateur donne un exemple de la façon dont ce changement fonctionne. Au lieu de Max Pooling, les algorithmes d'apprentissage en profondeur utilisent désormais Stride 2 Convolution. De plus, les modèles d'apprentissage en profondeur utilisent désormais une seule couche dense à la fin au lieu d'une couche Max Pool. Enfin, le présentateur donne un bref aperçu de la façon dont fast.ai gère la formation et la prédiction d'apprentissage en profondeur.
  
  
• 01:05:00 Dans cette vidéo YouTube, l'auteur montre comment la convolution est identique à la multiplication matricielle et comment calculer une convolution à l'aide des deux méthodes. Il discute également du Dropout, une technique pour réduire l'impact du bruit aléatoire dans les réseaux de neurones.
  
  
• 01:10:00 Dans cette leçon, l'auteur décrit comment les Dropout Layers aident à éviter le surajustement dans les réseaux de neurones. Plus vous utilisez d'abandon, moins il sera bon sur les données d'entraînement, mais mieux il devrait généraliser. Cela vient d'un article du groupe de Geoffrey Hinton, qui a été rejeté de la principale conférence sur les réseaux de neurones, alors appelée NIPS, maintenant appelée NeurIPS.
  
  
• 01:15:00 Cette vidéo couvre les bases de l'apprentissage en profondeur, y compris les types de réseaux de neurones et leur mise en œuvre. Il explique également comment utiliser diverses méthodes de formation et comment évaluer les performances d'un réseau de neurones. Enfin, la vidéo fournit des conseils sur la façon de continuer à apprendre l'apprentissage en profondeur.
  
  
• 01:20:00 Lucas demande comment rester motivé dans l'apprentissage en profondeur, et il note que le domaine s'oriente rapidement vers des modèles plus coûteux et à grande échelle. Il se demande s'il serait encore capable de former des modèles raisonnables avec un seul GPU à l'avenir. Dans l'ensemble, cette vidéo donne un aperçu de la façon de rester motivé dans l'apprentissage en profondeur et de se tenir au courant des dernières recherches.
  
  
• 01:25:00 Cette vidéo YouTube donne un bref aperçu de l'apprentissage en profondeur et de son application pratique au codage. La vidéo explique comment le succès de l'apprentissage en profondeur de DawnBench était dû à l'utilisation du bon sens et de l'intelligence par l'équipe, et comment n'importe qui peut appliquer l'apprentissage en profondeur à ses propres domaines problématiques. La vidéo aborde également l'importance de l'éducation formelle dans le domaine de l'apprentissage automatique et la manière dont les sessions de codage en direct contribuent à renforcer l'apprentissage.
  
  
• 01:30:00 Jeremy a partagé quelques astuces de productivité, notamment passer du temps à apprendre quelque chose de nouveau chaque jour et ne pas travailler trop dur.
  
  
• 01:35:00 Cette vidéo YouTube est une leçon sur l'apprentissage en profondeur pour les programmeurs, et l'orateur explique que la ténacité est importante dans ce domaine. Il conseille que si vous voulez réussir, vous devez continuer jusqu'à ce que quelque chose soit terminé, même si ce n'est pas la meilleure qualité. Il recommande également d'aider d'autres débutants sur forums.fast.ai.