Apprentissage Automatique et Réseaux Neuronaux - page 61
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Une introduction conviviale aux réseaux antagonistes génératifs (GAN)
Une introduction conviviale aux réseaux antagonistes génératifs (GAN)
Bonjour, je suis Luis Serrano, et cette vidéo concerne les réseaux antagonistes génératifs (GAN). Les GAN, développés par Ian Goodfellow, constituent une avancée significative dans l'apprentissage automatique avec de nombreuses applications. L'une des applications les plus fascinantes des GAN est la génération de visages. Vous pouvez le voir en action sur le site "thispersondoesnotexist.com", où toutes les images de personnes sont générées par un réseau de neurones.
Dans cette vidéo, nous allons apprendre à générer des visages à l'aide de GAN de manière simple. Même si vous préférez ne pas écrire de code, cette vidéo vous fournira intuition et équations. Nous allons coder une paire de réseaux de neurones à une couche qui génèrent des images simples, et vous pouvez trouver le code sur GitHub.
Laissez-moi vous expliquer ce que sont les GAN. Les GAN sont constitués de deux réseaux de neurones, un générateur et un discriminateur, qui se font concurrence. Le générateur essaie de créer de fausses images, tandis que le discriminateur essaie de faire la distinction entre les vraies et les fausses images. Lorsque le discriminateur attrape le générateur, le générateur améliore ses images jusqu'à ce qu'il puisse générer une image parfaite qui trompe le discriminateur. Pour entraîner les GAN, nous utilisons un ensemble d'images réelles et un ensemble de fausses images générées par le générateur. Le discriminateur apprend à identifier les vraies images des fausses, tandis que le générateur apprend à tromper le discriminateur en classant ses images comme réelles.
Dans cette vidéo, nous allons créer une simple paire de GAN en utilisant Python sans aucun package d'apprentissage en profondeur. Notre tâche consiste à générer des visages dans un monde appelé "Slanted Land", où tout le monde apparaît allongé et marche à un angle de 45 degrés. Le monde de Slanted Land a une technologie limitée, y compris des écrans de 2x2 pixels qui affichent des images en noir et blanc. Nous allons créer des réseaux de neurones avec une couche pour générer les visages des habitants de Slanted Land.
Le réseau discriminateur analyse les valeurs de pixel des images pour distinguer les visages des non-visages. Nous pouvons déterminer si une image est un visage en comparant les valeurs des coins supérieur gauche et inférieur droit avec les deux autres coins. Les visages auront une différence de valeur plus élevée, tandis que les non-visages ou les images bruyantes auront une différence plus faible. En appliquant un seuil, nous pouvons classer les images en visages ou en non-visages. Le réseau de générateurs crée des faces en attribuant des valeurs supérieures aux coins supérieur gauche et inférieur droit et des valeurs inférieures aux coins supérieur droit et inférieur gauche. En appliquant la fonction sigmoïde, nous pouvons obtenir des probabilités et générer des valeurs de pixels pour l'image. Le réseau de générateurs est conçu pour toujours générer un visage, quelles que soient les valeurs d'entrée. Pour former les réseaux de neurones, nous devons définir une fonction d'erreur. Nous utilisons la perte logarithmique, qui est le logarithme naturel négatif, pour mesurer l'erreur entre la sortie prédite et la sortie souhaitée. La fonction d'erreur aide les réseaux à améliorer leurs poids et à réduire l'erreur grâce à un processus appelé rétropropagation.
La rétropropagation consiste à calculer la dérivée de l'erreur par rapport aux poids et à ajuster les poids en conséquence pour minimiser l'erreur. Ce processus est répété de manière itérative pour former les réseaux de générateur et de discriminateur. En entraînant les réseaux de générateurs et de discriminateurs à l'aide de fonctions d'erreur et de rétropropagation appropriées, nous pouvons générer des visages réalistes dans Slanted Land. Le générateur apprend à créer des images qui ressemblent à des visages, tandis que le discriminateur apprend à différencier les visages réels des visages générés.
Cet aperçu donne une idée générale des GAN et de la manière dont ils peuvent générer des visages. Dans la vidéo, nous approfondirons les concepts et démontrerons étape par étape le processus de codage. Que vous souhaitiez écrire du code ou acquérir de l'intuition et de la compréhension, cette vidéo vous sera précieuse. Ainsi, l'erreur pour le discriminateur dans ce cas serait le logarithme négatif de 1 moins la prédiction. Nous calculons le gradient de cette erreur par rapport aux poids du discriminateur en utilisant la rétropropagation, puis mettons à jour les poids du discriminateur pour minimiser cette erreur. Ensuite, considérons le générateur. Le but du générateur est de produire des images que le discriminateur classe en réelles ou en faces. En d'autres termes, le générateur veut tromper le discriminateur en lui faisant sortir une probabilité élevée pour ses images générées. Par conséquent, l'erreur pour le générateur est le logarithme négatif de la prédiction du discriminateur pour l'image générée.
Encore une fois, nous calculons le gradient de cette erreur par rapport aux poids du générateur en utilisant la rétropropagation, et mettons à jour les poids du générateur pour minimiser cette erreur. Le générateur apprend à ajuster ses poids de telle sorte qu'il produise des images qui ressemblent à de vrais visages et augmentent la probabilité d'être classé comme visage par le discriminateur. Nous répétons ce processus plusieurs fois, en alternant entre l'entraînement du discriminateur et du générateur. Chaque itération aide les deux réseaux à améliorer leurs performances. Le discriminateur devient meilleur pour distinguer les images réelles des fausses, tandis que le générateur devient meilleur pour générer des images réalistes qui peuvent tromper le discriminateur.
Ce processus itératif de formation du générateur et du discriminateur est ce qui rend les GAN puissants. Ils apprennent à générer des échantillons très réalistes et cohérents en se faisant concurrence. Le générateur apprend à créer des images plus convaincantes, tandis que le discriminateur devient plus apte à détecter les fausses images. Avec une formation suffisante, les GAN peuvent générer des images, des textes, de la musique et même des vidéos qui ressemblent à de vraies données.
Les GAN se composent d'un générateur et d'un discriminateur qui s'affrontent à la manière d'un jeu. Le générateur génère de faux échantillons et le discriminateur essaie de faire la distinction entre les vrais et les faux échantillons. Grâce à ce processus contradictoire et à une formation avec des fonctions d'erreur appropriées, les GAN apprennent à générer des données réalistes et de haute qualité.
Machines Boltzmann restreintes (RBM) - Une introduction conviviale
Machines Boltzmann restreintes (RBM) - Une introduction conviviale
Bonjour, je suis Luis Serrano, et cette vidéo concerne les machines Boltzmann restreintes (RBM). Les RBM sont des algorithmes puissants utilisés dans l'apprentissage supervisé, la réduction de la dimensionnalité et l'apprentissage automatique génératif.
Commençons par un mystère. Il y a une maison de l'autre côté de la rue où les gens viennent parfois visiter. Nous observons que trois individus, Ayesha, Beto et Cameron, viennent souvent, mais pas toujours ensemble. Parfois, seule Ayesha se présente, d'autres fois c'est Beto ou Cameron, et parfois plusieurs d'entre eux viennent, y compris les jours où aucun d'entre eux ne se présente. Nous enquêtons sur ce modèle et constatons qu'ils ne se connaissent pas, nous devons donc trouver une autre raison à leurs apparitions.
Nous découvrons qu'il y a des animaux domestiques dans la maison, un chien nommé Descartes et un chat nommé Euler. Ayesha et Cameron adorent les chiens, alors ils se présentent quand Descartes est là. D'autre part, Beto est allergique aux chiens mais adore les chats, il ne se présente donc qu'en présence d'Ayesha. Nous attribuons des scores pour représenter leurs préférences, les scores positifs indiquant les goûts et les scores négatifs indiquant les aversions. Maintenant, nous voulons déterminer la probabilité que différents scénarios se produisent. Nous attribuons des scores à chaque scénario et les convertissons en probabilités. Une approche consiste à utiliser la fonction softmax pour transformer les scores en probabilités, en veillant à ce que les scores les plus élevés correspondent aux probabilités les plus élevées.
Nous construisons une machine de Boltzmann restreinte (RBM) avec des couches visibles et cachées. La couche visible représente les données observées (personnes), tandis que la couche cachée représente les données non observées (animaux domestiques). Le RBM se compose de nœuds connectés par des poids, avec des scores attribués à chaque connexion. Pour former le RBM, nous devons trouver les poids qui correspondent aux probabilités que nous avons obtenues à partir des données. Nous voulons que le RBM attribue des probabilités élevées aux scénarios où Ayesha et Cameron ou seulement Beto se présentent, et des probabilités faibles aux autres scénarios. En ajustant les poids, nous pouvons influencer les probabilités attribuées par le RBM. L'objectif est d'aligner le RBM sur les données observées et d'imiter les probabilités souhaitées.
Pour atteindre nos probabilités souhaitées, nous devons ajuster les pondérations dans notre RBM. Les poids déterminent l'influence de chaque connexion entre les couches visibles et masquées. En mettant à jour les poids, nous pouvons augmenter la probabilité de certains scénarios et diminuer la probabilité d'autres. Pour mettre à jour les poids, nous utilisons une technique appelée divergence contrastive. Il s'agit de comparer les probabilités des états de la couche visible avant et après quelques itérations du RBM. La mise à jour du poids est basée sur la différence entre ces deux ensembles de probabilités. Pendant la formation, nous présentons à plusieurs reprises les données de formation au RBM et ajustons les poids pour maximiser la probabilité des données observées. Ce processus est connu sous le nom d'apprentissage non supervisé car nous n'avons pas d'étiquettes explicites pour les données d'apprentissage.
Après la formation, le RBM peut être utilisé pour générer de nouvelles données en échantillonnant à partir de la distribution de probabilité apprise. Nous pouvons générer des scénarios similaires à ceux observés dans les données d'entraînement. Pour entraîner notre modèle, nous utilisons une RBM (Restricted Boltzmann Machine) et suivons un processus de probabilités croissantes et décroissantes. Au lieu de considérer tous les scénarios possibles, nous sélectionnons au hasard un scénario et augmentons sa probabilité, tout en diminuant la probabilité d'un scénario choisi au hasard. Nous répétons ce processus plusieurs fois, en ajustant progressivement les probabilités en fonction du résultat souhaité. Pour chaque point de données, nous sélectionnons un scénario qui le prolonge et augmente sa probabilité, tout en sélectionnant au hasard un autre scénario et en diminuant sa probabilité. Nous poursuivons ce processus pour l'ensemble du jeu de données, en le parcourant plusieurs fois. Les probabilités qui en résultent correspondent bien à nos données, correspondant aux occurrences de différents scénarios.
Pour modifier les probabilités, nous ajustons les poids du RBM. Nous nous concentrons sur des sommets et des arêtes spécifiques qui correspondent aux scénarios souhaités. En augmentant ou en diminuant les poids, nous influençons les probabilités de ces scénarios. L'échantillonnage pose un défi puisque nous voulons choisir des scénarios en fonction de leurs probabilités respectives. Nous introduisons un échantillonnage indépendant, où nous ne considérons que les sommets et les arêtes pertinents connectés aux scénarios souhaités. En calculant les probabilités à l'aide de la fonction sigmoïde, nous pouvons sélectionner au hasard des scénarios avec des probabilités proportionnelles à leurs poids. Pour choisir un scénario qui correspond à un point de données donné, nous nous concentrons sur les participants pertinents et leurs connexions, sans tenir compte de ceux qui ne sont pas pertinents. Nous calculons les probabilités en fonction des poids et utilisons la fonction sigmoïde pour les convertir en probabilités. Cela nous permet de sélectionner au hasard un scénario avec des probabilités reflétant leurs poids.
Pour choisir un scénario complètement aléatoire, nous l'approchons en prenant des mesures aléatoires dans la distribution, ce qui revient à explorer différentes possibilités. Bien qu'il ne s'agisse pas d'une représentation parfaite d'un scénario complètement aléatoire, il s'agit d'une approximation proche. Ce processus nous permet de former le RBM et d'ajuster les probabilités pour qu'elles correspondent aux résultats souhaités, en modélisant efficacement nos données.
Les machines Boltzmann restreintes ont été appliquées avec succès à diverses tâches, telles que le filtrage collaboratif, la réduction de la dimensionnalité et l'apprentissage des fonctionnalités. Ils sont également utilisés comme blocs de construction pour des modèles d'apprentissage en profondeur plus complexes, tels que les réseaux de croyances profondes.
Les machines Boltzmann restreintes sont des algorithmes puissants utilisés dans l'apprentissage automatique. Ils impliquent une couche visible et une couche cachée reliées par des poids. En ajustant les pondérations par l'apprentissage, les RBM peuvent apprendre la distribution de probabilité des données d'apprentissage et générer de nouveaux échantillons de données. Les RBM ont des applications dans divers domaines et sont un élément important des modèles d'apprentissage en profondeur.
Une introduction conviviale à l'apprentissage par renforcement profond, aux réseaux Q et aux gradients politiques
Une introduction conviviale à l'apprentissage par renforcement profond, aux réseaux Q et aux gradients politiques
Bonjour, je m'appelle Luis Serrano, et ceci est une introduction conviviale à l'apprentissage par renforcement profond et aux gradients politiques. L'apprentissage par renforcement a des applications dans les voitures autonomes, la robotique et les jeux complexes comme les jeux de Go, d'échecs et d'Atari. La principale différence entre l'apprentissage par renforcement et l'apprentissage automatique prédictif est que dans l'apprentissage par renforcement, nous avons un agent qui interagit avec un environnement, collectant des récompenses et des punitions pour créer des données, tandis que l'apprentissage automatique prédictif s'appuie sur des données existantes pour former un modèle. Dans cette vidéo, nous couvrirons des concepts importants tels que les processus de décision de Markov (MDP), l'équation de Bellman et comment les réseaux de neurones peuvent aider à l'apprentissage par renforcement avec les réseaux Q et les gradients de politique.
Commençons par un exemple d'apprentissage par renforcement utilisant un MDP appelé Grid World. Dans Grid World, nous avons une grille représentant l'univers, et notre agent, représenté par un cercle. La grille contient des carrés spéciaux, y compris ceux avec de l'argent et un carré avec un dragon qui entraîne la fin de la partie. L'objectif de l'agent est de maximiser les points en se déplaçant sur la grille, en collectant des récompenses ou des punitions. Nous pouvons déterminer la meilleure stratégie pour l'agent en utilisant l'équation de Bellman, qui calcule la valeur de chaque état en fonction des valeurs maximales de ses états voisins. Nous pouvons alors en déduire une politique, qui fournit des instructions à l'agent sur le meilleur chemin à suivre pour maximiser les points.
Pour améliorer l'efficacité de la politique, nous introduisons des récompenses et un facteur de remise. Les récompenses représentent les points gagnés ou perdus lors d'un pas, et le facteur de remise tient compte de la valeur des récompenses futures par rapport aux récompenses immédiates. En tenant compte des récompenses et du facteur de remise, nous pouvons ajuster les valeurs des états et mettre à jour l'équation de Bellman en conséquence. En itérant et en mettant à jour les valeurs, nous pouvons converger vers les valeurs optimales pour chaque état et déterminer la politique qui guide l'agent vers les points les plus élevés.
En comprenant l'équation de Bellman et en utilisant les récompenses et les facteurs d'actualisation, nous pouvons résoudre les MDP et trouver la meilleure politique d'apprentissage par renforcement. Le côté gauche indique que l'agent doit se déplacer vers la droite pour trouver la meilleure valeur. La politique ordonne à l'agent de se déplacer vers la droite avec une probabilité de 1 et vers d'autres directions avec une probabilité de 0. En revanche, une politique stochastique favoriserait fortement le déplacement vers la droite mais donnerait toujours une chance aux autres directions en fonction des récompenses obtenues. . Par exemple, la politique stochastique de droite donne la priorité à l'état de droite car il a la valeur la plus élevée, tandis que l'état de gauche a la priorité la plus faible en raison de son faible score. Cependant, les probabilités sont toujours non nulles, permettant à l'agent d'explorer l'espace même s'il ne reçoit pas toujours la meilleure récompense.
Parlons maintenant du rôle des réseaux de neurones dans ce processus. Au lieu de demander à l'agent de visiter tous les États à plusieurs reprises, ce qui est coûteux, nous pouvons utiliser un réseau de neurones pour recueillir des informations auprès de quelques États. Le réseau de neurones peut apprendre que des états avec des coordonnées similaires doivent avoir des valeurs similaires. Nous utilisons un réseau de valeurs, où l'entrée est les coordonnées d'un point et la sortie est le score à ce point. De même, nous pouvons utiliser un réseau de politiques pour approximer la politique à chaque état. Le réseau de politiques prend les coordonnées en entrée et produit quatre nombres représentant les probabilités de déplacement vers le haut, la droite, le bas et la gauche. Pour entraîner le réseau de valeurs, nous le forçons à satisfaire l'équation de Bellman, qui relie la valeur d'un état à ses états voisins. Nous utilisons les valeurs du réseau de neurones aux états voisins et ajustons la valeur au milieu pour satisfaire l'équation. En mettant à jour à plusieurs reprises le réseau neuronal basé sur l'équation de Bellman, nous pouvons approximer les valeurs de tous les états.
Pour le réseau politique, nous le formons en prenant des chemins basés sur la politique actuelle et en étiquetant chaque action avec le gain correspondant. Nous créons un ensemble de données avec le gain, les coordonnées et les actions, et le transmettons au réseau de politiques. Nous encourageons ou décourageons ensuite le réseau à prendre certaines mesures en fonction du gain. En répétant ce processus avec différents chemins, nous pouvons améliorer le réseau politique au fil du temps. Nous utilisons des réseaux de neurones pour approximer les valeurs et la politique des États. Le réseau de valeur nous aide à estimer la valeur de chaque état, tandis que le réseau de politique guide les actions de l'agent. La formation implique la mise à jour répétée des réseaux en fonction de l'équation de Bellman et de l'étiquetage basé sur le chemin.
Maintenant que nous avons les valeurs de chaque état et la politique correspondante, nous pouvons les utiliser pour prendre des décisions dans le jeu. La politique nous indique la meilleure action à entreprendre de chaque état, en fonction des valeurs que nous avons calculées. Par exemple, si l'agent est dans un certain état et veut savoir quelle action entreprendre, il regarde simplement la politique et suit la flèche qui pointe vers l'état voisin avec la valeur la plus élevée. Cela garantit que l'agent emprunte le chemin optimal pour maximiser ses récompenses. Dans le cas de notre jeu de monde en grille, la politique peut guider l'agent pour éviter les obstacles et atteindre les états terminaux avec les récompenses les plus élevées le plus rapidement possible. En suivant la politique, l'agent peut naviguer dans le monde de la grille et collecter des points tout en évitant les récompenses négatives.
Les algorithmes d'apprentissage par renforcement, tels que le Q-learning ou les gradients de politique, peuvent être utilisés pour trouver la politique et les valeurs optimales pour des environnements plus complexes. Ces algorithmes exploitent les concepts des processus de décision de Markov et l'équation de Bellman pour mettre à jour les valeurs de manière itérative et améliorer la politique au fil du temps. Les réseaux de neurones peuvent également être utilisés pour gérer des espaces d'états vastes et complexes. Les réseaux Q et les méthodes de gradient de politique utilisent des réseaux de neurones pour approximer les valeurs ou la fonction de politique, permettant un apprentissage plus efficace et efficient dans les tâches d'apprentissage par renforcement.
En combinant des algorithmes d'apprentissage par renforcement et des réseaux de neurones, nous pouvons résoudre des problèmes complexes tels que les voitures autonomes, la robotique et les jeux complexes. Ces techniques ont de nombreuses applications et continuent de faire progresser le domaine de l'intelligence artificielle.
L'apprentissage par renforcement consiste à former un agent à prendre des décisions dans un environnement en interagissant avec lui et en collectant des récompenses. L'agent utilise les valeurs et la politique obtenues à partir de l'équation de Bellman pour naviguer dans l'environnement et maximiser ses récompenses. Les réseaux de neurones peuvent être utilisés pour traiter des problèmes plus complexes dans l'apprentissage par renforcement.
Une introduction conviviale à l'apprentissage automatique
Une introduction conviviale à l'apprentissage automatique
Bonjour et bienvenue dans le monde de l'apprentissage automatique. Aujourd'hui, nous allons explorer ce qu'est l'apprentissage automatique. Dans ce monde, nous avons des humains et des ordinateurs, et une distinction clé entre eux est la façon dont ils apprennent. Les humains apprennent des expériences passées, tandis que les ordinateurs doivent être programmés et suivre les instructions. Cependant, pouvons-nous aussi apprendre aux ordinateurs à apprendre de l'expérience ? La réponse est oui, et c'est là que l'apprentissage automatique entre en jeu. Dans le domaine des ordinateurs, les expériences passées sont appelées données.
Dans les minutes qui suivent, je vais vous présenter quelques exemples qui montrent comment nous pouvons apprendre aux ordinateurs à apprendre à partir de données antérieures. Ce qui est excitant, c'est que ces algorithmes sont assez simples et que l'apprentissage automatique n'a rien à craindre. Plongeons-nous dans notre premier exemple. Imaginez que nous étudions le marché du logement et que notre tâche consiste à prédire le prix d'une maison en fonction de sa taille. Nous avons recueilli des données sur diverses maisons, y compris leurs tailles et leurs prix. En traçant ces données sur un graphique, avec l'axe des x représentant la taille de la maison en pieds carrés et l'axe des y représentant le prix en dollars, nous pouvons visualiser la relation entre les deux. Nous remarquons que les points de données forment approximativement une ligne.
En utilisant une méthode appelée régression linéaire, nous pouvons tracer une ligne qui correspond le mieux aux points de données. Cette ligne représente notre meilleure estimation pour prédire le prix d'une maison compte tenu de sa taille. En examinant le graphique, nous pouvons estimer le prix d'une maison de taille moyenne en identifiant le point correspondant sur la ligne. La régression linéaire nous permet de trouver la ligne la mieux ajustée en minimisant les erreurs entre la ligne et les points de données. La régression linéaire n'est qu'un exemple d'algorithme d'apprentissage automatique. C'est relativement simple et efficace lorsque les données forment une relation linéaire. Cependant, nous pouvons utiliser des méthodes similaires pour ajuster d'autres types de données, telles que des courbes, des cercles ou des polynômes de degré supérieur, selon la nature du problème.
Passons maintenant à un autre exemple. Supposons que nous voulions créer un système de détection de spam par e-mail. Nous avons collecté des données sur les e-mails précédents, y compris s'ils ont été marqués comme spam ou non. En analysant ces données, nous pouvons identifier les caractéristiques susceptibles d'indiquer si un e-mail est un spam ou non. Par exemple, nous pourrions constater que les e-mails contenant le mot "bon marché" sont souvent signalés comme spam. En utilisant l'algorithme naïf de Bayes, nous pouvons associer des probabilités à ces caractéristiques. Dans ce cas, si un e-mail contient le mot "bon marché", nous constatons que 80 % de ces e-mails sont marqués comme spam. En combinant plusieurs fonctionnalités et leurs probabilités associées, nous pouvons créer un classificateur qui prédit si un e-mail est un spam ou non en fonction de ses fonctionnalités.
Passons à notre exemple suivant, disons que nous travaillons dans l'App Store ou Google Play, et que notre objectif est de recommander des applications aux utilisateurs. Nous pouvons recueillir des données sur les utilisateurs, leurs caractéristiques et les applications qu'ils ont téléchargées. En analysant ces données, nous pouvons construire un arbre de décision qui guide nos recommandations. L'arbre de décision se compose de questions basées sur les caractéristiques de l'utilisateur, conduisant à la recommandation d'applications spécifiques. Par exemple, nous pouvons demander si l'utilisateur a moins de 20 ans. En fonction de la réponse, nous pouvons recommander une application spécifique. Si l'utilisateur est plus âgé, nous pouvons poser une question différente, telle que son sexe, pour affiner davantage notre recommandation. L'arbre de décision nous aide à faire des recommandations d'applications personnalisées en fonction des attributs de l'utilisateur.
Enfin, considérons le bureau des admissions d'une université. Ils essaient de déterminer quels étudiants admettre en fonction de deux éléments d'information : un résultat à l'examen d'entrée et les notes des étudiants. En analysant les données des étudiants précédemment admis et rejetés, nous pouvons créer un modèle de régression logistique.
En utilisant la régression logistique, nous pouvons tracer une ligne qui sépare les points de données des étudiants acceptés et rejetés. Cette ligne représente la limite de décision pour déterminer si un étudiant sera admis ou rejeté. Le modèle de régression logistique calcule la probabilité d'admission en fonction du score et des notes de l'examen d'entrée. Une fois la limite de décision établie, les nouveaux étudiants peuvent être évalués en traçant leur score et leurs notes à l'examen d'entrée sur un graphique. Si le point tombe au-dessus de la limite de décision, le modèle prédit l'admission ; s'il tombe en dessous, le modèle prédit le rejet. Ce ne sont là que quelques exemples d'algorithmes d'apprentissage automatique et de la manière dont ils peuvent être appliqués à divers domaines. L'apprentissage automatique permet aux ordinateurs d'apprendre à partir des données et de faire des prédictions ou des décisions sans être explicitement programmés pour chaque scénario. Il permet l'automatisation, la reconnaissance des formes et la capacité de gérer des données complexes et à grande échelle.
Il est important de noter que l'apprentissage automatique nécessite des données à partir desquelles apprendre. La qualité et la pertinence des données jouent un rôle important dans l'exactitude et l'efficacité des modèles. De plus, les modèles d'apprentissage automatique doivent être formés sur un ensemble de données représentatif et validés pour garantir leur généralisabilité.
L'apprentissage automatique est un domaine en évolution rapide avec de nombreux algorithmes, techniques et applications. Les chercheurs et les praticiens explorent continuellement de nouvelles méthodes et repoussent les limites de ce qui est possible. À mesure que la technologie progresse et que davantage de données deviennent disponibles, l'apprentissage automatique devrait avoir un impact de plus en plus important sur diverses industries et aspects de nos vies.
Apprentissage automatique : tests et métriques d'erreur
Apprentissage automatique : tests et métriques d'erreur
Bonjour et bienvenue dans ce didacticiel sur les tests d'apprentissage automatique et les mesures d'erreur. Je m'appelle Luis Serrano et je travaille chez Udacity, où j'enseigne l'apprentissage automatique. C'est une photo de moi. Aujourd'hui, nous allons nous concentrer sur deux questions : premièrement, comment se porte mon modèle ? Une fois que nous avons compris cela, comment pouvons-nous l'améliorer en fonction de ces mesures ? Plongeons-nous dans le vif du sujet et examinons quelques données. Nous avons des points bleus et des points rouges, et nous voulons former un modèle pour les séparer. Notre modèle le plus simple est un modèle linéaire, qui est une ligne qui coupe les données en bleu et rouge. Il fait quelques erreurs mais est généralement bon. Considérons également un modèle plus complexe utilisant un polynôme de degré supérieur. Ce modèle sépare mieux les points, mais quel modèle est le meilleur entre les deux ?
Pour répondre à cette question, nous devons utiliser des tests. Au lieu d'utiliser tous les points pour l'entraînement, nous les avons divisés en ensembles d'entraînement et de test. Les points de formation sont utilisés pour former le modèle, tandis que les points de test sont utilisés pour évaluer les performances du modèle. Dans notre exemple, le modèle linéaire fait une erreur sur l'ensemble de test, tandis que le modèle polynomial fait deux erreurs. Par conséquent, le modèle linéaire fonctionne mieux sur l'ensemble de test car il généralise mieux.
En ce qui concerne les tests, il y a quelques règles importantes à suivre. La première règle d'or est de ne jamais utiliser vos données de test pour la formation. Gardez vos données de test séparées et utilisez-les uniquement pour l'évaluation. La deuxième règle est de s'assurer que vos amis n'utilisent pas non plus leurs données de test pour s'entraîner. Enfin, la troisième règle insiste sur le fait de ne jamais utiliser vos données de test pour la formation. Il est crucial d'éviter toute mauvaise utilisation accidentelle des données de test.
Bien qu'il puisse sembler que nous gaspillons des données en les séparant en ensembles d'apprentissage et de test, il existe un moyen de résoudre ce problème. Nous pouvons diviser les données en k ensembles égaux, généralement en utilisant une technique appelée validation croisée k fois. Chaque partie des données est utilisée à la fois pour la formation et les tests, et les résultats sont moyennés à la fin. Cette approche nous permet de mieux utiliser les données tout en évaluant les performances du modèle.
Parlons maintenant des mesures qui nous aident à évaluer la performance de nos modèles. Une métrique courante est la précision, qui mesure le nombre d'instances que le modèle classe correctement par rapport au nombre total d'instances. Cependant, la précision seule n'est pas toujours la meilleure mesure, comme le montrent les exemples de détection de fraude par carte de crédit, de diagnostics médicaux et de classification des spams. Dans ces cas, les faux négatifs et les faux positifs ont des implications différentes.
Pour évaluer plus efficacement les modèles, nous utilisons une matrice de confusion. Cette matrice présente quatre possibilités : les vrais positifs, les vrais négatifs, les faux positifs et les faux négatifs. Chacun d'eux représente des résultats différents basés sur les prédictions du modèle par rapport aux données réelles. Par exemple, dans les diagnostics médicaux, un faux négatif signifie qu'une personne malade est classée comme en bonne santé, ce qui est pire qu'un faux positif. De même, dans la classification des spams, un faux positif signifie qu'un e-mail non spam est marqué comme spam, ce qui est pire qu'un faux négatif.
En tenant compte du contexte spécifique et des conséquences des faux positifs et des faux négatifs, nous pouvons choisir des mesures appropriées pour évaluer nos modèles. La précision seule peut ne pas capturer l'ensemble de l'image, et d'autres mesures telles que la précision, le rappel et le score F1 peuvent fournir plus d'informations sur les performances du modèle.
Peut-on combiner ces deux scores en un seul ? Une façon simple de combiner les scores de précision et de rappel consiste à prendre leur moyenne. Calculons la moyenne des scores de précision et de rappel fournis. A gauche, la précision est de 69,5, et à droite, elle est de 66,95. En faisant la moyenne de ces deux scores, on obtient 68,225. Cependant, cette moyenne peut ne pas fournir suffisamment d'informations et peut ne pas être significativement différente de la précision. Pour comprendre les implications de ce score moyen, considérons un exemple extrême impliquant la détection de fraude par carte de crédit.
Dans l'exemple, nous avons deux modèles : un qui classe toutes les transactions comme bonnes et un autre qui classe toutes les transactions comme frauduleuses. Calculons la précision et le rappel pour les deux modèles.
Pour le modèle qui classe toutes les transactions comme bonnes, la précision est de 100 % (car toutes les transactions classées comme mauvaises sont en fait bonnes) et le rappel est de 0 % (car aucune des transactions frauduleuses n'est détectée). Si nous prenons la moyenne de la précision et du rappel, nous obtiendrons 50 %. Cependant, donner un score aussi élevé à un modèle qui fonctionne mal ne semble pas approprié. De même, pour le modèle qui classe toutes les transactions comme frauduleuses, la précision est de 0,16 % (classé correctement 472 sur toutes les transactions) et le rappel est de 100 % (car toutes les transactions frauduleuses sont détectées). Encore une fois, la moyenne entre la précision et le rappel serait d'environ 50 %, ce qui ne reflète pas précisément les mauvaises performances du modèle.
Pour surmonter cette limitation, nous pouvons utiliser un autre type de moyenne appelée la moyenne harmonique, également connue sous le nom de score F1. La moyenne harmonique est calculée à l'aide de la formule 2 * (précision * rappel) / (précision + rappel). Le score F1 fournit une représentation plus équilibrée, en particulier lorsqu'une métrique (précision ou rappel) est significativement différente de l'autre.
Pour le modèle médical, la précision est de 55,7 et le rappel est de 83,3. En calculant le score F1 à l'aide de la formule de la moyenne harmonique, nous obtenons 66,76 %. Pour le modèle de détection de spam, la précision est de 76,9 et le rappel est de 37. Le score F1 est de 49,96 %. Et pour le modèle linéaire, la précision est de 75 et le rappel est de 85,7. Le score F1 est de 80%.
Dans le cas des modèles de fraude par carte de crédit, si nous préférons détecter toutes les transactions frauduleuses, nous donnerons la priorité au rappel. Ainsi, une bonne métrique dans ce cas serait plus proche du rappel que de la précision.
Les mesures de test et d'erreur sont essentielles pour évaluer et améliorer les modèles d'apprentissage automatique. Le respect des règles d'or des tests, la sélection des métriques appropriées et la prise en compte des conséquences des faux positifs et des faux négatifs nous aident à prendre des décisions éclairées concernant nos modèles.
La combinaison de la précision et du rappel en un seul score peut être effectuée à l'aide du score F1, qui prend la moyenne harmonique des deux métriques. Cela fournit une évaluation plus équilibrée et est particulièrement utile lorsqu'une métrique est significativement différente de l'autre.
Courbe ROC (Receiver Operating Characteristic) en 10 minutes !
Courbe ROC (Receiver Operating Characteristic) en 10 minutes !
Salutations! Je suis Luis Serrano, et dans cette vidéo, nous discuterons de la courbe ROC (Receiver Operating Characteristic). La courbe ROC est largement utilisée pour évaluer les modèles d'apprentissage automatique et prendre des décisions importantes.
Commençons par un ensemble de données contenant des points bleus et rouges, où les points bleus sont étiquetés comme positifs et les rouges comme négatifs. Nous allons construire un modèle d'apprentissage automatique qui correspond à cet ensemble de données. Par exemple, considérez cette ligne. Notez que le côté bleu de la ligne classe chaque point de ce côté comme bleu ou positif, tandis que le côté rouge classe les points de ce côté comme rouge ou négatif. Cependant, le modèle fait quelques erreurs. Un exemple est le point rouge situé dans la zone bleue, qui est un faux positif. Un autre exemple est le point bleu sous la ligne dans la zone rouge, qui est un faux négatif. Pour mieux comprendre les faux positifs et les faux négatifs, regardez mon autre vidéo sur les tests d'apprentissage automatique et les mesures d'erreur.
Considérons maintenant deux exemples différents pour le même type de modèle. Le modèle de gauche est un modèle médical, où les points positifs représentent les patients malades et les points négatifs représentent les patients sains. D'autre part, le modèle de droite est un modèle de détection de spam, où les points positifs sont les messages de spam et les points négatifs sont les messages non-spam ou "ham".
Dans le modèle médical, un faux positif se produit lorsqu'une personne en bonne santé est diagnostiquée comme malade, ce qui entraîne des tests inutiles. Un faux négatif se produit lorsqu'une personne malade est diagnostiquée comme étant en bonne santé, ce qui entraîne l'absence de traitement. Dans ce cas, les faux négatifs sont considérés comme pires car il vaut mieux envoyer une personne en bonne santé pour des tests supplémentaires que de renvoyer une personne malade chez elle sans traitement. Ainsi, nous visons à modifier le modèle pour réduire les faux négatifs.
Dans le modèle de détection de spam, les faux positifs sont de bons e-mails "amateurs" classés comme spam et envoyés dans le dossier spam. Les faux négatifs sont des spams classés à tort comme "ham" et livrés dans la boîte de réception. Ici, les faux positifs sont considérés comme pires, car la réception de spams occasionnels dans la boîte de réception est préférable aux e-mails importants marqués comme spam. Par conséquent, nous nous concentrons sur la réduction des faux positifs dans ce modèle.
Ces deux modèles représentent des extrêmes, et la plupart des modèles se situent quelque part entre les deux, tolérant certains faux positifs ou faux négatifs. Cependant, l'importance accordée à chaque type d'erreur peut varier. Ainsi, pour chaque type de modèle, nous devons déterminer le point optimal pour fixer le seuil de classification.
Dans cette vidéo, je vais vous montrer une méthode utile pour vous aider à prendre de telles décisions. Nous allons considérer un jeu de données hypothétique représenté par cette ligne. Nos modèles seront des traductions parallèles de cette ligne. Pour chaque modèle, nous enregistrerons le nombre de points rouges et bleus correctement classés.
Nous commençons par la ligne du bas, où tous les points bleus sont correctement classés et aucun des points rouges n'est correctement classé. Cela nous donne 0 points rouges corrects et 5 points bleus corrects. Nous traçons ces valeurs et déplaçons la ligne pour couvrir un point à la fois, en enregistrant les classifications correctes. Ce processus se poursuit jusqu'à la fin. A la fin, nous avons toujours 5 bons points bleus et 0 bons points rouges. Nous traçons ces points et calculons l'aire sous la courbe. Dans ce cas, l'aire est de 21 carrés sur 25, ce qui donne une aire sous la courbe de 0,84. La zone est comprise entre 0 et 1, les valeurs les plus élevées indiquant de meilleures performances du modèle. Nous pouvons utiliser cette courbe ROC pour prendre des décisions concernant notre modèle. Un bon modèle serait représenté par un point sur la courbe avec peu de faux positifs et de faux négatifs. En fonction de nos exigences spécifiques, telles que la minimisation des faux négatifs dans le modèle médical ou des faux positifs dans le modèle de détection de spam, nous pouvons sélectionner les points correspondants sur la courbe.
Alternativement, nous pouvons considérer les points de données comme ayant des scores entre 0 et 1 attribués par le modèle. En appliquant un seuil, nous pouvons convertir ces scores en prédictions discrètes. Nous ajustons le seuil et observons les performances du modèle à différents niveaux. Ce processus crée la courbe ROC. Le choix d'un point sur la courbe nous aide à sélectionner un seuil approprié pour nos prédictions. De plus, il convient de noter qu'une aire sous la courbe inférieure à 0,5 n'indique pas un pire modèle. En fait, cela peut encore être un bon modèle. Par exemple, un modèle avec une aire de 0 correspond à un modèle faisant toutes les erreurs, mais si nous inversons les prédictions, il devient presque aussi bon qu'un modèle ne faisant aucune erreur. Ainsi, les modèles avec des aires inférieures à 0,5 peuvent toujours être efficaces.
Merci pour votre attention! Si vous avez aimé cette vidéo, abonnez-vous pour plus de contenu. N'hésitez pas à aimer, partager et commenter, surtout si vous avez des suggestions pour de futures vidéos. Vous pouvez également me contacter sur Twitter @LuisLikesMath. Consultez l'Académie Luis Serrano pour plus d'informations sur les vidéos, les livres et les cours. Rendez-vous dans la prochaine vidéo !
Régression linéaire : une introduction conviviale
Régression linéaire : une introduction conviviale
Salut, je suis Louis Serrano, et ceci est une introduction amicale à la régression linéaire. Cette vidéo est la première partie d'une série en trois parties où je couvrirai la régression linéaire, la régression logistique et les machines à vecteurs de support. Cependant, concentrons-nous sur la régression linéaire pour l'instant.
En règle générale, les explications de la régression linéaire impliquent des concepts complexes tels que l'algèbre linéaire, les matrices, les dérivées, le calcul et les fonctions d'erreur. Mais pour moi, cela peut être écrasant. J'ai un esprit visuel et je préfère comprendre la régression linéaire avec une approche plus intuitive utilisant des points et des lignes.
Permettez-moi de démontrer ce que je veux dire par là. Définissons d'abord la régression linéaire à l'aide d'un exemple de prix de l'immobilier. Imaginez que nous ayons cinq maisons avec un nombre variable de pièces. Nous possédons la maison trois et souhaitons estimer son prix de vente. Pour ce faire, nous examinons les prix de maisons similaires et essayons de faire une supposition éclairée. Après avoir observé que la maison un coûte 150 000 $, la maison deux coûte 200 000 $, la maison quatre coûte 300 000 $ et la maison cinq coûte 350 000 $, nous pouvons estimer que la maison trois pourrait coûter environ 250 000 $.
Essentiellement, ce que nous avons fait ici est d'effectuer une régression linéaire. Nous avons tracé les maisons sur un graphique, avec le nombre de pièces sur l'axe horizontal et le prix sur l'axe vertical. Nous avons observé que les prix semblaient suivre une ligne droite, nous avons donc placé la maison trois sur la ligne pour faire la meilleure estimation. Cette approche simple consistant à ajuster une ligne à travers un ensemble de points et à l'utiliser pour des prédictions est l'essence même de la régression linéaire.
En réalité, le calcul des prix implique des facteurs supplémentaires, rendant les données plus complexes. Cependant, nous pouvons toujours ajuster une ligne qui se rapproche étroitement des prix des maisons. La régression linéaire peut être appliquée à divers scénarios, tels que le calcul du cours des actions dans la finance ou la détermination de la durée de vie des patients en médecine. Les applications sont nombreuses.
Voyons maintenant comment nous effectuons réellement la régression linéaire. Nous avons besoin d'un algorithme ou d'une procédure pour trouver la ligne qui correspond le mieux aux points. Pour plus de simplicité, nous nous concentrerons sur un algorithme de base qui consiste à apporter de petits ajustements à la ligne jusqu'à ce qu'elle corresponde bien aux points.
Voici un résumé de l'algorithme :
Pour déplacer la droite vers un point, on effectue des rotations et des translations. La rotation de la ligne dans le sens des aiguilles d'une montre ou dans le sens inverse des aiguilles d'une montre ajuste la pente, tandis que la translation de la ligne vers le haut ou vers le bas ajuste l'ordonnée à l'origine. Les ajustements sont effectués en ajoutant ou en soustrayant de petites quantités, qui sont déterminées par le taux d'apprentissage.
En répétant ce processus plusieurs fois, la ligne se rapproche progressivement des points, ce qui donne un bon ajustement. Le nombre d'époques détermine combien de fois nous répétons le processus, et il peut être ajusté en fonction de la précision souhaitée et des ressources de calcul disponibles.
C'est l'idée de base derrière la régression linéaire. C'est un outil puissant pour ajuster les lignes aux points de données et faire des prédictions. J'espère que cette explication intuitive vous aidera à mieux comprendre la régression linéaire.
Nous avons quelque chose qui est plus proche du point principal, et il y a quatre cas à vérifier pour s'assurer que l'astuce carrée fonctionne efficacement. Examinons un autre cas où le point est en dessous de la ligne et à droite de l'axe des ordonnées. L'équation est à nouveau présentée. Dans la première étape, nous sélectionnons un petit taux d'apprentissage de 0,01. À la deuxième étape, nous appliquons ce taux à la pente et à l'ordonnée à l'origine. Maintenant, la distance verticale est négative car le point est en dessous de la ligne (-4), tandis que la distance horizontale reste positive car le point est à droite de l'axe des ordonnées (+5). Pour modifier la pente, nous ajoutons 0,01 fois (-4) fois 5, ce qui donne -0,2. En soustrayant -0,2, nous diminuons la pente, ce qui fait que la ligne se déplace dans le sens des aiguilles d'une montre. Pour l'ordonnée à l'origine, nous ajoutons le taux d'apprentissage multiplié par la distance verticale, soit 0,01 fois (-4), ce qui donne -0,04. La nouvelle équation de ligne devient y = 1,8 - 0,2x + 2,96 - 0,04. Notez que la pente est plus petite, indiquant une rotation dans le sens des aiguilles d'une montre, et l'ordonnée à l'origine est plus petite, indiquant une translation vers le bas. Cet ajustement nous rapproche de l'essentiel. Bien que nous n'ayons vérifié que deux des quatre cas, je vous encourage à les tester tous pour voir que la deuxième étape fonctionne de manière cohérente. Enfin, explorons l'algorithme de régression linéaire. L'algorithme procède comme suit :
Maintenant, la question se pose : cet algorithme est-il meilleur ou le même que ceux existants ? Cette situation me rappelle un brillant mathématicien du nom de John Borwein, avec qui j'ai déjà travaillé. Il a recherché des formules pour calculer les chiffres de pi et a découvert que lorsqu'une formule se rapprochait étroitement de pi, c'était une situation gagnant-gagnant parce qu'il découvrait une nouvelle formule ou trouvait quelque chose de remarquablement proche de pi. De même, avec cet algorithme, nous avons une situation gagnant-gagnant. Soit il surpasse les algorithmes existants, soit il s'avère aussi efficace tout en étant plus simple.
Étonnamment, cet algorithme est exactement le même que celui utilisé dans la régression linéaire traditionnelle, comme la descente de gradient d'erreur carrée. L'approche traditionnelle consiste à minimiser l'erreur carrée en calculant la distance entre les points et la ligne, puis en utilisant les dérivées, le calcul et la descente de gradient ou en résolvant des systèmes linéaires d'équations. Le défi que je vous présente est de vérifier que l'astuce carrée est équivalente à la méthode d'erreur carrée traditionnelle en calculant l'erreur carrée, en prenant des dérivées et en effectuant de petits pas opposés à la direction dérivée, tout comme la descente de gradient. Vous découvrirez que la dérivée de la différence au carré est étroitement liée aux distances verticale et horizontale. Cela démontre que l'astuce carrée est équivalente à l'approche traditionnelle.
Le deuxième défi concerne la mesure de la méchanceté ou de la qualité d'une ligne. Nous avons discuté précédemment de l'erreur quadratique, qui consiste à élever au carré les distances. Une autre méthode plus simple est l'erreur absolue, où l'on additionne les valeurs absolues des distances sans tenir compte de leurs signes. La mauvaise ligne a des distances orange plus grandes, tandis que la bonne ligne a des distances orange plus petites en raison de sa plus grande proximité avec les points. En utilisant le calcul, vous pouvez minimiser l'erreur absolue et effectuer des étapes de descente de gradient. Vous pouvez développer une astuce absolue, qui ne traite que de la distance horizontale et inclut une instruction if pour gérer la position de la ligne par rapport au point. En explorant ce défi, vous découvrirez l'astuce absolue. N'hésitez pas à le coder et à observer son efficacité.
Cette vidéo portait sur la régression linéaire. N'oubliez pas que cela fait partie d'une série en trois parties qui comprend des astuces pour la régression logistique et les machines à vecteurs de support. Restez à l'écoute pour les prochaines vidéos. Si vous avez apprécié ce contenu, pensez à vous abonner, à aimer et à partager. J'apprécie vos commentaires, questions et suggestions. Faites-moi savoir comment vous avez relevé les défis et n'hésitez pas à suggérer des sujets pour les futures vidéos. Vous pouvez également me contacter sur Twitter (@LouisLikesMath). Merci et à bientôt dans la prochaine vidéo.
Régression logistique et algorithme de Perceptron : une introduction conviviale
Régression logistique et algorithme de Perceptron : une introduction conviviale
Il existe un meilleur algorithme qui peut gérer les trois cas simultanément. Je vais maintenant expliquer l'astuce du perceptron, qui prend en charge ces cas ensemble. Considérons une ligne avec la même équation et un point bleu qui se trouve sur la ligne rouge. Nous devons ajuster la position de la ligne pour tenir compte de ce point. Pour ce faire, nous diminuerons légèrement la valeur de -6, disons 0,1, ce qui déplacera la ligne vers le haut. Ensuite, nous allons ajuster la pente de la ligne pour la faire pivoter. Par exemple, si nous voulons faire pivoter la ligne pour qu'elle soit plus raide, nous pouvons réduire la valeur de 2 à 1,8.
De même, si le point est plus éloigné dans cette direction, nous devons faire pivoter davantage la ligne pour la rapprocher. Dans ce cas, nous pourrions réduire la valeur de 2 à 1,4. Cependant, si le point est de l'autre côté, nous devons faire pivoter la ligne dans la direction opposée. Ainsi, nous devrons peut-être augmenter la valeur de 2, disons à 2,2. Reprenons ce processus plus précisément. Lorsque le point n'est pas éloigné de l'axe des ordonnées, nous diminuons légèrement la valeur de -6, par exemple 0,01, ce qui déplace légèrement la ligne vers le haut.
Considérons maintenant la valeur de 2. Si le point a pour coordonnées (4, 5), la distance horizontale est de 4. Pour ajuster la pente, nous pouvons multiplier 4 par un taux d'apprentissage, disons 0,04, pour réduire la valeur de 2 Cela fera pivoter la ligne autour d'un pivot. De même, nous pouvons appliquer le même principe à la valeur de 3. Par exemple, si le point a des coordonnées (4, 5), la distance verticale est de 5. En multipliant 5 avec un taux d'apprentissage, comme 0,05, nous pouvons diminuer la valeur de 3. Cela fera encore pivoter la ligne. Enfin, après avoir réduit 2 de 0,04, 3 de 0,05 et -6 de 0,01, l'équation devient 1,96x + 2,95y - 6,01. Cette technique, connue sous le nom d'astuce du perceptron, traite à la fois de la direction et de l'ampleur des ajustements. Pour résumer, avec un taux d'apprentissage de 0,01, nous pouvons mettre à jour l'équation sous la forme ax + par + c = 0 en réduisant a d'un taux d'apprentissage fois b, en réduisant b d'un taux d'apprentissage fois q et en réduisant c de a taux d'apprentissage.
Cependant, il y a une autre considération : le cas où la zone bleue est en haut et la zone rouge est en bas, avec des points mal classés. Dans ce scénario, nous ajouterions les valeurs au lieu de les soustraire. Par exemple, si nous avons -2x - 3y + 6 = 0 au lieu de 2x + 3y - 6 = 0, nous ajouterions de petites quantités à a, b et c. En tenant compte de l'emplacement des points par rapport à l'axe des ordonnées, nous pouvons déterminer s'il faut augmenter ou diminuer les valeurs. Passons maintenant à l'algorithme de régression logistique, qui est une approche encore meilleure.
Je ne vais pas entrer dans les détails, mais je vais vous donner un aperçu et deux défis. Le premier défi est appelé descente de gradient, qui consiste à utiliser une fonction d'erreur pour mesurer les performances du classifieur. L'objectif est de minimiser l'erreur et d'améliorer l'algorithme en utilisant le calcul. Le processus de descente de gradient est similaire à l'algorithme de perceptron dont nous avons discuté précédemment.
Le deuxième défi consiste à choisir une fonction d'activation appropriée pour la régression logistique. La fonction d'activation est chargée de transformer la somme pondérée des entrées en une valeur de probabilité comprise entre 0 et 1.
Une fonction d'activation couramment utilisée est la fonction sigmoïde, qui a une courbe en forme de S. Il fait correspondre tout nombre réel à une valeur comprise entre 0 et 1. La fonction sigmoïde est définie comme suit :
σ(z) = 1 / (1 + e^(-z))
Ici, z représente la somme pondérée des entrées et est calculé comme suit :
z = une X + b y + c
Dans la régression logistique, l'objectif est de trouver les valeurs optimales pour a, b et c qui maximisent la vraisemblance des données observées. Ceci est réalisé en minimisant une fonction de coût, souvent appelée fonction de perte d'entropie croisée.
La fonction de coût mesure l'écart entre les probabilités prédites et les étiquettes de classe réelles. Une forme courante de la fonction de coût est :
J(a, b, c) = -1/m * Σ(y * log(σ(z)) + (1-y) * log(1-σ(z)))
Dans cette équation, m représente le nombre d'exemples d'apprentissage, y est la véritable étiquette de classe (0 ou 1) et σ(z) est la probabilité prédite de la classe positive.
Pour minimiser la fonction de coût, une descente de gradient peut être appliquée. L'idée derrière la descente de gradient est de mettre à jour itérativement les valeurs des paramètres (a, b et c) dans la direction opposée du gradient de la fonction de coût par rapport à ces paramètres. Ce processus se poursuit jusqu'à la convergence, où la fonction de coût est minimisée.
Les équations de mise à jour pour la descente de gradient dans la régression logistique sont similaires à celles de l'algorithme perceptron. En utilisant le taux d'apprentissage (α), les mises à jour des paramètres sont les suivantes :
une := une - α * ∂J/∂ab := b - α * ∂J/∂bc := c - α * ∂J/∂c
Les dérivées partielles (∂J/∂a, ∂J/∂b, ∂J/∂c) représentent les gradients de la fonction de coût par rapport à chaque paramètre. Ils peuvent être calculés à l'aide du calcul différentiel.
En mettant à jour de manière itérative les valeurs des paramètres à l'aide de la descente de gradient, la régression logistique peut apprendre à classer les données avec plus de flexibilité par rapport à l'algorithme perceptron. C'est un algorithme largement utilisé et efficace pour les problèmes de classification binaire.
En conclusion, la régression logistique s'appuie sur les principes de l'algorithme perceptron mais introduit un cadre probabiliste et une fonction de coût différente. En appliquant la descente de gradient, il optimise les paramètres pour maximiser la vraisemblance des données observées. Le choix de la fonction d'activation sigmoïde permet à la régression logistique de produire des estimations de probabilité pour l'appartenance à une classe.
Machines à vecteurs de support (SVM) : une introduction conviviale
Machines à vecteurs de support (SVM) : une introduction conviviale
Bonjour, je m'appelle Luis Serrano, et ceci est une introduction conviviale aux machines à vecteurs de support, ou SVM en abrégé. Il s'agit de la troisième vidéo d'une série de trois sur les modèles linéaires. Si vous n'avez pas encore regardé le premier, il s'intitule "Régression linéaire" et le second s'appelle "Régression logistique". Cette vidéo s'appuie sur les concepts abordés dans la deuxième vidéo.
Tout d'abord, je voudrais rendre hommage aux étudiants du cours d'apprentissage automatique que j'ai enseigné à l'Université Quest en Colombie-Britannique, au Canada. Ils m'ont aidé à développer l'idée clé de cette vidéo, et ce fut une expérience merveilleuse de travailler avec eux. Sur la photo, vous pouvez me voir avec mon ami Richard Hoshino, qui est également professeur à l'université.
Maintenant, plongeons dans SVM. Les machines à vecteurs de support sont un algorithme de classification crucial qui vise à séparer les points de deux classes à l'aide d'une ligne. Cependant, SVM va encore plus loin pour trouver la meilleure ligne possible qui maximise la séparation entre les points. Typiquement, SVM est expliqué en termes d'optimisation linéaire ou de descente de gradient. Mais dans cette vidéo, je vais introduire une méthode que je n'ai pas vue dans la littérature, que j'appelle la "méthode des petits pas". C'est une approche itérative où nous améliorons continuellement la capacité de classification de la ligne.
Pour commencer, récapitulons la vidéo précédente sur la régression logistique et l'algorithme du perceptron. Dans cette vidéo, nous avons cherché à trouver une ligne qui sépare les données en deux classes : les points rouges et les points bleus. L'algorithme perceptron commence par une ligne aléatoire et l'ajuste de manière itérative en fonction du retour des points. L'algorithme fait de petites étapes pour améliorer progressivement la capacité de la ligne à classer correctement les points.
Introduisons maintenant l'étape supplémentaire dans SVM. Au lieu de trouver une seule ligne, nous cherchons à trouver deux lignes parallèles aussi éloignées que possible tout en séparant efficacement les données. Pour illustrer cela, imaginez deux ensembles de lignes parallèles, équidistantes de la ligne principale. Le but est de maximiser la distance entre ces deux lignes. Plus la séparation est grande, meilleure est la classification.
Ensuite, nous devons former l'algorithme pour sélectionner la meilleure ligne. Nous y parvenons en multipliant les équations de ligne par différentes constantes. En faisant cela, nous pouvons contrôler la distance entre les lignes. Une constante plus grande entraîne une séparation plus large, tandis qu'une constante plus petite rapproche les lignes. De cette façon, nous pouvons trouver les lignes optimales qui maximisent la distance.
Pour séparer des lignes à l'aide d'équations, considérons un exemple d'équation : 2x + 3y - 6 = 0. Multiplier cette équation par un facteur constant ne change pas la ligne elle-même mais affecte la distance entre les lignes. Nous pouvons ajuster cette constante pour étendre ou contracter les lignes.
Pour formaliser l'algorithme SVM, nous incorporons le taux d'expansion, qui détermine la taille du pas pour écarter les lignes. En multipliant les équations des droites par une valeur proche de 1, comme 0,99, on augmente progressivement la distance entre les droites à chaque itération.
En résumé, l'algorithme SVM suit ces étapes :
Il s'agit d'un bref aperçu de l'algorithme SVM et de la manière dont il intègre la méthode des petits pas pour améliorer la classification. C'est une technique efficace pour résoudre les problèmes de classification, et j'espère que cette vidéo fournira une perspective unique sur SVM.
Nous allons maintenant considérer un autre aspect qui contribue à l'erreur de notre modèle. Cet aspect est basé sur la distance entre deux lignes. Pour le démontrer, examinons deux machines à vecteurs de support (SVM) qui classent un ensemble de données. Le premier SVM a des lignes plus larges mais classe mal un point, tandis que le second SVM a des lignes étroites mais classe tous les points correctement. La question est, lequel est le meilleur? La réponse dépend de divers facteurs tels que l'ensemble de données, le modèle et le scénario. Cependant, nous pouvons analyser cela en utilisant des fonctions d'erreur.
Rappelons le calcul d'erreur dans l'algorithme du perceptron. Lorsqu'un point est correctement classé, l'erreur est nulle. Si un point est mal classé, l'erreur dépend de sa distance par rapport à la frontière. Les points plus proches de la frontière ont des erreurs plus petites, tandis que ceux plus éloignés ont des erreurs plus importantes. Nous voulons une fonction d'erreur qui capture cette relation de distance. De même, dans SVM, nous avons deux erreurs de classification : l'erreur de classification bleue et l'erreur de classification rouge. Chaque erreur mesure la distance entre un point mal classé et sa limite respective. En additionnant ces distances, on obtient l'erreur de classement.
De plus, nous avons l'erreur de marge, qui indique la proximité des lignes. Une erreur de marge plus grande implique que les lignes sont plus rapprochées, tandis qu'une erreur de marge plus petite suggère que les lignes sont plus éloignées. Nous voulons que notre modèle ait une petite erreur de marge, indiquant des lignes larges. Ainsi, plus l'erreur est petite, meilleur est notre modèle. Fait intéressant, l'erreur de marge ressemble au terme de régularisation dans la régularisation L2.
Pour résumer, l'erreur SVM se compose de l'erreur de classification et de l'erreur de marge. L'erreur de classification mesure le nombre de points mal classés et l'étendue de la mauvaise classification. L'erreur de marge indique la distance entre les lignes. Ces deux erreurs forment ensemble l'erreur SVM totale. Notre objectif est de minimiser cette erreur en utilisant la descente de gradient, similaire à l'astuce SVM consistant à ajuster la position et la séparation des lignes.
Revenant à la comparaison des deux modèles, celui de gauche a une grande erreur de classification mais une petite erreur de marge puisque les lignes sont éloignées. Le modèle de droite, en revanche, présente une petite erreur de classification mais une grande marge d'erreur en raison de la proximité des lignes. Décider quel modèle est le meilleur dépend de nos préférences et de nos exigences. Nous pouvons utiliser le paramètre C, un hyperparamètre, pour contrôler l'importance de l'erreur de classification par rapport à l'erreur de marge. Un petit C accentue l'erreur de marge, résultant en un modèle comme celui de gauche, tandis qu'un grand C donne la priorité à l'erreur de classification, conduisant à un modèle similaire à celui de droite.
Il est important de noter que le choix des hyperparamètres peut être déterminé par l'expérimentation et le test de différentes valeurs pour évaluer les performances du modèle. Les hyperparamètres jouent un rôle crucial dans les algorithmes d'apprentissage automatique et nous permettent d'affiner nos modèles.
Merci de votre attention tout au long de cette série de vidéos sur les modèles linéaires. J'espère que vous l'avez trouvé instructif et agréable. N'hésitez pas à liker, partager et commenter. Vos commentaires sont appréciés. Restez à l'écoute pour plus de vidéos à l'avenir.
Débruitage et auto-encodeurs variationnels
Débruitage et auto-encodeurs variationnels
Bonjour, je suis Luis Serrano, et dans cette vidéo, nous parlerons des encodeurs automatiques. Plus précisément, nous nous concentrerons sur le débruitage et les auto-encodeurs variationnels.
Les auto-encodeurs sont des modèles de générateurs populaires et font partie d'une série qui comprend des réseaux antagonistes génératifs et des machines Boltzmann restreintes. Si vous aimez les modèles de générateurs, assurez-vous de consulter les liens dans les commentaires.
Pour comprendre les auto-encodeurs, imaginons que vous vouliez comprendre un livre, alors vous demandez à votre amie intelligente Aisha de le résumer pour vous. Le travail d'Aisha est de condenser le livre en quelques pages pour vous faciliter la compréhension. Ensuite, nous évaluons la qualité du résumé d'Aisha en demandant à notre autre amie, Berta, de réécrire tout le livre sur la base du résumé d'Aisha. Nous comparons le livre réécrit de Berta avec le livre original pour évaluer leur performance.
Idéalement, Aisha résumerait les idées principales du livre aussi précisément que possible, et Berta excellerait dans la reconstruction du livre sur la base de ces idées. En forçant Aisha et Berta à condenser et à reconstruire le livre, respectivement, elles acquièrent une compréhension approfondie de son contenu. Ce concept est à la base des auto-encodeurs. Ils simplifient considérablement les données, puis les reconstruisent, en extrayant les caractéristiques les plus utiles du processus.
Les auto-encodeurs sont des algorithmes de réduction de dimensionnalité et font partie de l'apprentissage automatique non supervisé. Dans le contexte d'ensembles de données réels, considérons un ensemble de données d'images faciales. Chaque image est codée à l'aide de plusieurs nombres pour représenter la couleur de chaque pixel. Aisha, désormais appelée l'encodeur, résume cet ensemble de données en extrayant des caractéristiques telles que la taille des yeux, la couleur des cheveux et d'autres caractéristiques faciales. Ces caractéristiques sont ensuite transmises à Berta, le décodeur, qui aide à reconstruire les visages à partir de ces caractéristiques extraites.
La dimension d'un point de données fait référence au nombre de nombres nécessaires pour l'encoder. Dans ce cas, nous réduisons la dimensionnalité de l'ensemble de données d'images faciales en le résumant en un ensemble plus petit de caractéristiques, puis en l'augmentant à nouveau pendant le processus de reconstruction.
Les encodeurs automatiques se composent de deux parties : un encodeur qui réduit les données et un décodeur qui les étend. L'objectif est que la sortie reconstruite ressemble étroitement à l'entrée d'origine. Les données réduites ou simplifiées sont connues sous le nom d'espace latent, qui résume et compactifie les données pour fournir des informations précieuses.
Deux types importants d'auto-encodeurs sont les auto-encodeurs de débruitage et les auto-encodeurs variationnels. Les encodeurs automatiques de débruitage sont formés pour prendre des données corrompues, telles que des images bruyantes, et générer des versions claires et plus nettes de ces images. Les auto-encodeurs variationnels, quant à eux, sont formés pour générer de nouvelles données en sélectionnant des échantillons dans un espace latent simplifié, qui représente une version de dimension inférieure de l'espace de données d'origine.
Les auto-encodeurs variationnels sont particulièrement efficaces pour générer des images haute résolution, telles que des espaces. Dans la vidéo, vous pouvez trouver des exemples de visages générés par un auto-encodeur variationnel.
Le principal concept à saisir avant de plonger dans les auto-encodeurs est la réduction de la dimensionnalité. Pour illustrer ce concept, considérons un exemple d'ensemble de données d'images. Ces images sont de simples images de 2x2 pixels, chaque pixel ayant une couleur différente : rouge, bleu, jaune et vert. Chaque pixel a une valeur d'intensité comprise entre 0 et 1, où 1 représente l'intensité de la couleur complète et 0 représente le blanc.
Chaque point de données de cet ensemble de données est décrit par quatre valeurs d'intensité, correspondant aux quatre couleurs. Cependant, en y regardant de plus près, on remarque une propriété particulière : les intensités des pixels dans les coins supérieur droit et inférieur gauche sont toujours les mêmes, tout comme les intensités des pixels dans les coins supérieur gauche et inférieur droit. Cela signifie que nous n'avons plus besoin d'encoder les quatre valeurs d'intensité indépendamment. Au lieu de cela, nous pouvons représenter chaque point de données avec seulement deux valeurs : l'intensité des pixels en haut à gauche et en bas à droite.Ce faisant, nous avons réduit la dimensionnalité de notre ensemble de données de quatre à deux. Cette réduction nous permet de capturer les informations essentielles des images tout en éliminant les fonctionnalités redondantes ou corrélées. Il simplifie également la représentation des données et peut aider dans diverses tâches telles que la visualisation, le stockage et l'analyse.
Les auto-encodeurs utilisent un principe similaire de réduction de dimensionnalité mais d'une manière plus sophistiquée et apprise. Au lieu de sélectionner manuellement les fonctionnalités à conserver ou à supprimer, les auto-encodeurs apprennent à extraire automatiquement les fonctionnalités les plus informatives des données d'entrée.
Plongeons plus profondément dans l'architecture et le processus de formation des auto-encodeurs. Comme mentionné précédemment, les auto-encodeurs se composent d'un encodeur et d'un décodeur.
L'encodeur prend les données d'entrée, telles qu'une image, et applique une série de transformations pour les encoder dans une représentation de dimension inférieure, connue sous le nom d'espace latent. L'espace latent est une représentation compressée des données d'entrée, capturant ses caractéristiques les plus importantes.
Le décodeur prend la représentation de l'espace latent et applique les transformations inverses pour reconstruire les données d'entrée d'origine aussi fidèlement que possible. L'objectif est de minimiser la différence entre les données d'entrée et la sortie reconstruite, en apprenant efficacement une représentation compressée qui peut reproduire fidèlement l'entrée.
Pour former un auto-encodeur, nous avons besoin d'un ensemble de données d'entrée pour lequel nous avons à la fois les échantillons d'origine et leurs sorties cibles correspondantes. Pendant la formation, l'auto-encodeur apprend à minimiser l'erreur de reconstruction, qui est généralement mesurée à l'aide d'une fonction de perte telle que l'erreur quadratique moyenne (MSE) ou l'entropie croisée binaire.
Le processus d'apprentissage consiste à faire passer les données d'entrée par l'encodeur pour obtenir la représentation de l'espace latent. Ensuite, la représentation de l'espace latent est passée à travers le décodeur pour reconstruire les données. La reconstruction est comparée à l'entrée d'origine, et l'écart entre eux est utilisé pour mettre à jour les poids de l'encodeur et du décodeur par rétropropagation et descente de gradient.
En entraînant de manière itérative l'auto-encodeur sur un grand ensemble de données, il apprend progressivement à extraire les caractéristiques les plus saillantes des données d'entrée et devient capable de les reconstruire avec une perte minimale.
Les auto-encodeurs de débruitage et les auto-encodeurs variationnels sont deux variantes populaires de l'architecture de base de l'auto-encodeur.
Les encodeurs automatiques de débruitage sont spécifiquement conçus pour gérer les données d'entrée bruyantes ou corrompues. Pendant la formation, l'auto-encodeur est présenté avec des données d'entrée qui ont été intentionnellement corrompues, par exemple en ajoutant du bruit aléatoire ou en introduisant des distorsions. L'auto-encodeur apprend alors à débruiter l'entrée en reconstruisant les données originales et propres aussi précisément que possible. Cette capacité de débruitage permet à l'auto-encodeur d'apprendre des représentations robustes qui sont plus résistantes au bruit.
Les auto-encodeurs variationnels (VAE) adoptent une approche différente en incorporant la modélisation probabiliste dans le cadre de l'auto-encodeur. Les VAE visent à apprendre un espace latent qui suit une distribution de probabilité spécifique, telle qu'une distribution gaussienne. Cela permet aux VAE de générer de nouveaux points de données en échantillonnant à partir de la distribution apprise dans l'espace latent.
L'entraînement des VAE implique non seulement de minimiser l'erreur de reconstruction, mais également de maximiser la probabilité que la distribution spatiale latente corresponde à la distribution souhaitée. Ceci est réalisé grâce à une combinaison de perte de reconstruction et d'un terme de régularisation appelé la divergence de Kullback-Leibler (KL), qui mesure la différence entre la distribution apprise et la distribution souhaitée.
En optimisant simultanément la perte de reconstruction et la divergence KL, les VAE apprennent à générer de nouveaux échantillons de données qui présentent des caractéristiques similaires aux données d'apprentissage tout en explorant la diversité de l'espace latent appris.
Les auto-encodeurs sont de puissants modèles d'apprentissage non supervisés qui peuvent apprendre des représentations compactes des données d'entrée. Ils se composent d'un encodeur et d'un décodeur qui fonctionnent ensemble pour compresser et reconstruire les données. Les encodeurs automatiques de débruitage et les encodeurs automatiques variationnels sont deux variantes notables qui étendent l'architecture de base de l'encodeur automatique et offrent des fonctionnalités supplémentaires telles que le débruitage et la modélisation générative.
Examinons quelques exemples supplémentaires dans cette section. Le premier exemple que nous avons ici semble être une image entièrement colorée, à l'exception du pixel vert dans le coin inférieur droit, qui a une valeur de 0,2. L'encodeur de débruitage est capable de colorer toute l'image pour nous. Ensuite, nous avons un autre exemple d'image blanche, à l'exception du pixel bleu avec une valeur de 0,8 dans le coin supérieur droit. L'encodeur neocenter détermine que l'image doit être blanche et transforme le pixel bleu en blanc. Je vous encourage à explorer le référentiel et à expérimenter avec vos propres images pour voir les résultats. En résumé, ces encodeurs externes forcent toute image à ressembler à l'une des images de l'ensemble de données formé.
Les autres encodeurs que nous avons utilisés jusqu'à présent n'avaient qu'une seule couche, mais il est important de noter que ce n'est pas toujours le cas dans les réseaux de neurones. Les codeurs peuvent avoir plusieurs couches et des architectures complexes, telles que des couches convolutionnelles ou récurrentes. Voici un exemple d'encodeur convolutif utilisé pour débruiter des images de caractères manuscrits dans l'ensemble de données MNIST. Comme vous pouvez le voir, ces types d'encodeurs automatiques de débruitage fonctionnent bien pour nettoyer les images bruyantes.
Passons maintenant à une autre propriété fascinante des auto-encodeurs. Ils ont la capacité de générer des points de données entièrement nouveaux, tels que de nouvelles images. Ces images générées ne sont pas de simples copies des images de l'ensemble de données, mais des images complètement nouvelles et uniques qui ressemblent étroitement à celles de l'ensemble de données. Cette capacité est vraiment remarquable. Par exemple, un encodeur automatique peut générer le visage d'une personne qui n'existe pas ou un chiffre manuscrit qui n'a jamais été dessiné auparavant. Pour générer ces nouvelles images, il suffit de se concentrer sur le décodeur et d'oublier l'encodeur. Le décodeur prend un ensemble de nombres, appelé la représentation latente, et génère une image basée sur ces nombres. Ce processus fournit une représentation visuelle de l'espace latent.
Pour illustrer cela, prenons un exemple. Supposons que nous saisissions les nombres 0,3 et 0,8 dans le décodeur. Il génère une image avec des intensités de 0,12 et 0,95. Nous pouvons visualiser l'espace latent comme un carré, où l'axe horizontal correspond à la diagonale rouge-vert et l'axe vertical correspond à la diagonale bleu-jaune de l'image. Chaque point de ce carré représente une image, et à mesure que nous nous déplaçons vers la droite, l'intensité de la diagonale rouge-vert augmente. De même, au fur et à mesure que l'on se déplace de bas en haut, l'intensité de la diagonale bleu-jaune augmente. Cette visualisation nous permet de comprendre l'espace latent et sa relation avec les images générées.
Dans l'espace latent, nous pouvons sélectionner n'importe quel point uniformément, ce qui équivaut à choisir deux nombres et à les faire passer par le décodeur. Ce processus nous permet de générer n'importe laquelle de ces images avec la même vraisemblance. Cependant, dans certains cas, nous pouvons uniquement vouloir générer des images spécifiques qui existent dans l'ensemble de données, tout en excluant les autres. Cette situation est courante lorsque l'espace latent est grand et contient du bruit, avec seulement une petite partie représentant les images souhaitées. Pour résoudre ce problème, nous pouvons utiliser une technique appelée auto-encodeurs variationnels.
Dans le cas des auto-encodeurs variationnels, nous entraînons deux distributions normales qui nous permettent de sélectionner des points qui sont très susceptibles d'être à l'intérieur d'une région d'intérêt spécifique. Par exemple, si nous avons une petite région de forme ovale dans l'espace latent où les images souhaitées existent, nous voulons que l'auto-encodeur génère des images à l'intérieur ou à proximité de cette région avec une probabilité plus élevée que le reste de l'espace. Nous y parvenons en formant deux distributions normales, une pour chaque coordonnée dans l'espace latent. Ces distributions nous permettent de sélectionner des points qui sont susceptibles d'être vers le centre de la région souhaitée. En utilisant ces points sélectionnés comme représentation latente et en les faisant passer par le décodeur, nous pouvons générer des images plus ciblées et alignées sur nos critères souhaités.Le processus d'apprentissage des auto-encodeurs variationnels consiste à optimiser simultanément deux objectifs : la perte de reconstruction et la perte de régularisation. La perte de reconstruction mesure à quel point les images générées correspondent aux images d'entrée, comme les encodeurs automatiques traditionnels. La perte de régularisation, souvent appelée divergence de Kullback-Leibler (KL), encourage la distribution latente à ressembler à une distribution antérieure connue, généralement une distribution normale standard.
L'ajout de la perte de régularisation introduit un compromis lors de la formation. D'une part, nous voulons que les images reconstruites ressemblent étroitement aux images d'entrée, ce qui est obtenu en minimisant la perte de reconstruction. D'autre part, nous voulons que la distribution latente corresponde à la distribution antérieure, favorisant la génération d'images diverses et réalistes. Il est crucial d'équilibrer ces objectifs pour s'assurer que le modèle capture les caractéristiques importantes des données tout en permettant la créativité et la nouveauté dans les images générées.
Une fois que l'auto-encodeur variationnel est formé, nous pouvons échantillonner des points de la distribution précédente (souvent une distribution normale standard) et les passer à travers le décodeur pour générer de nouvelles images. En contrôlant le processus d'échantillonnage, nous pouvons explorer différentes régions de l'espace latent et générer diverses variations des données d'entrée.
Les auto-encodeurs variationnels ont été largement utilisés dans diverses applications, telles que la génération d'images, la génération de texte et la détection d'anomalies. Ils fournissent un cadre puissant pour apprendre et générer des distributions de données complexes tout en permettant de contrôler la sortie générée.
En résumé, les auto-encodeurs, y compris les auto-encodeurs de débruitage et variationnels, offrent des capacités fascinantes de traitement et de génération d'images. Ils peuvent supprimer le bruit des images, reconstruire les parties manquantes et générer des images entièrement nouvelles et uniques. Les encodeurs automatiques de débruitage exploitent une architecture d'encodeur-décodeur pour apprendre la structure sous-jacente des données, tandis que les encodeurs automatiques variationnels ajoutent une modélisation probabiliste pour capturer diverses variations dans la sortie générée. Ces techniques ont révolutionné le domaine de l'apprentissage non supervisé et ont trouvé de nombreuses applications dans la recherche sur la vision par ordinateur et l'intelligence artificielle.