Apprentissage Automatique et Réseaux Neuronaux - page 70
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
6.5 Gini & Entropie versus erreur de mauvaise classification (L06 : Arbres de décision)
6.5 Gini & Entropie versus erreur de mauvaise classification (L06 : Arbres de décision)
Dans la vidéo précédente, nous avons discuté des différents critères de fractionnement qui peuvent être utilisés pour développer un arbre de décision. Voyons maintenant pourquoi deux des critères de division, à savoir l'impureté de Gini et l'entropie, sont préférés au troisième critère, l'erreur de classification erronée.
Pour récapituler, nous avons trois mesures d'impureté : l'entropie, l'entropie mise à l'échelle (mise à l'échelle de 0,5 pour la comparaison avec l'impureté de Gini) et l'erreur de classification erronée. La forme de ces mesures d'impuretés diffère. L'entropie apparaît comme une fonction concave, tandis que l'erreur de mauvaise classification a un pic net à 0,5 avec des pentes linéaires.
La question se pose : pourquoi utilisons-nous l'entropie et l'impureté de Gini au lieu de l'erreur de classification erronée pour la croissance des arbres de décision ? Cette question s'applique non seulement à l'entropie mais aussi à l'impureté de Gini. Dans cette vidéo, nous nous concentrerons sur l'entropie, mais le concept s'applique également à l'impureté de Gini.
Considérons l'équation de gain d'information. Nous avons une fonction d'impureté pour le nœud parent, qui représente l'ensemble de données D au nœud parent. Lorsque nous divisons cet ensemble de données en fonction des valeurs de caractéristiques, nous générons différents nœuds enfants. Ce concept s'applique à la fois aux caractéristiques catégoriques et continues. Pour les fonctionnalités continues, nous pouvons diviser en créant des bacs en fonction d'un seuil.
La mesure d'impureté est utilisée à la fois pour les nœuds parent et enfant, et nous les additionnons en tenant compte de la taille de l'ensemble de données d'origine au niveau du nœud parent et du nœud enfant actuel. Généralement, si nous choisissons une mesure d'impureté pour le parent, nous la gardons également cohérente pour les nœuds enfants.
En pratique, nous avons tendance à éviter d'utiliser une erreur de classification car elle présente un inconvénient, dont nous parlerons dans cette vidéo. Revoyons brièvement comment l'entropie et l'erreur de mauvaise classification sont calculées. L'entropie est calculée en additionnant le produit de la proportion d'étiquettes pour chaque classe et le logarithme de la proportion. D'autre part, l'erreur de classification erronée est basée sur la perte 0/1, qui mesure la proportion d'étiquettes mal classées.
Maintenant, en se concentrant sur l'entropie par rapport à l'erreur de mauvaise classification, une différence clé est leurs formes. L'entropie est concave, alors que l'erreur de mauvaise classification ne l'est pas. Cette différence influence la raison pour laquelle l'entropie est favorisée par rapport à l'erreur de classification erronée pour la croissance des arbres de décision.
Pour illustrer cela, considérons un ensemble de données de jouet simple. Au nœud parent, nous avons 40 exemples de classe un et 80 exemples de classe zéro. Si nous divisons l'ensemble de données en fonction des valeurs de caractéristiques, nous nous retrouvons avec des nœuds enfants qui ont des distributions de classes différentes. Nous devons évaluer si cette séparation améliore la pureté des nœuds par rapport au parent.
Si nous calculons l'entropie des nœuds parent et enfant, nous constatons que l'entropie du nœud enfant deux est inférieure à celle du parent, ce qui indique une pureté améliorée. Cependant, le nœud enfant un est pire que le parent. En moyenne, nous devons déterminer si la scission est bénéfique.
Pour mesurer la qualité de la division, nous utilisons le gain d'information, qui considère les valeurs d'entropie pour les nœuds parent et enfant. Si le gain d'information est positif, cela indique un bon partage. Dans notre exemple, le gain d'information est positif, indiquant un partage favorable basé sur l'entropie.
Maintenant, examinons le même scénario en utilisant une erreur de classification erronée. L'erreur pour le parent, le nœud enfant un et le nœud enfant deux est calculée en fonction de la proportion d'étiquettes mal classées. Si nous insérons ces valeurs d'erreur dans la formule de gain d'information, nous constatons que le gain d'information est nul. Un gain d'information nul implique que la scission n'est pas bénéfique. Par conséquent, ces nœuds n'existeront pas et nous aurions besoin d'envisager d'autres fonctionnalités.
En conclusion, la principale raison pour laquelle l'entropie est préférée à l'erreur de classification erronée pour la croissance des arbres de décision est que l'entropie capture plus efficacement l'incertitude et le désordre dans les données. La forme concave de l'entropie permet une meilleure différenciation entre les différentes distributions de classe et fournit une mesure plus nuancée de l'impureté. D'autre part, l'erreur de classification erronée est une mesure plus simpliste qui ne prend en compte que la proportion d'étiquettes mal classées et ne saisit pas l'incertitude et la distribution des classes.
La forme concave de l'entropie lui permet de pénaliser à la fois les petits et les grands déséquilibres de classe. Il est sensible aux changements dans les proportions de classe, donnant des poids plus élevés aux classes réparties plus uniformément. Cette propriété rend l'entropie particulièrement utile lorsqu'il s'agit d'ensembles de données qui ont des distributions de classes déséquilibrées.
En revanche, l'erreur de classification erronée a une forme linéaire, avec un pic net à 0,5. Il traite toutes les erreurs de classification de la même manière et ne fait pas de distinction entre les différents degrés d'erreur de classification. Cela rend les erreurs de classification plus sensibles aux déséquilibres de classe et moins efficaces dans les scénarios avec des ensembles de données déséquilibrés.
De plus, la différence de formes entre l'entropie et l'erreur de mauvaise classification a un impact sur le processus d'apprentissage de l'arbre de décision. Les arbres de décision visent à trouver des fractionnements qui maximisent le gain d'information ou diminuent l'impureté. Étant donné que l'entropie fournit une mesure plus fine de l'impureté, elle permet aux arbres de décision de faire des divisions plus informées et plus précises.
En utilisant l'entropie comme mesure d'impureté, les arbres de décision sont capables de capturer des relations complexes entre les caractéristiques et les classes. Ils peuvent gérer à la fois des caractéristiques continues et catégorielles et peuvent découvrir des modèles complexes dans les données.
En résumé, l'entropie est préférée à l'erreur de classification erronée pour la croissance des arbres de décision, car elle capture plus efficacement l'incertitude et le désordre dans les données. Sa forme concave permet une meilleure différenciation entre les différentes distributions de classes, et il est plus robuste aux ensembles de données déséquilibrés. En utilisant l'entropie, les arbres de décision peuvent effectuer des divisions plus éclairées et capturer des relations complexes entre les caractéristiques et les classes.
6.6 Améliorations et gestion du surajustement (L06 : Arbres de décision)
6.6 Améliorations et gestion du surajustement (L06 : Arbres de décision)
Dans la vidéo précédente, nous avons discuté des différents critères de fractionnement qui peuvent être utilisés pour développer un arbre de décision. Maintenant, nous allons approfondir pourquoi deux des critères de division, à savoir l'impureté de Gini et l'entropie, sont préférés au troisième critère, l'erreur de classification erronée.
Pour nous rafraîchir la mémoire, rappelons les trois critères de séparation : l'entropie, l'entropie mise à l'échelle (pour comparaison avec l'impureté de Gini) et l'erreur de classification. La forme de ces mesures d'impuretés peut être visualisée comme suit : l'entropie est une fonction concave, représentée par une grande ligne noire ; l'entropie mise à l'échelle est également concave et est obtenue en multipliant l'entropie par 0,5 ; et l'erreur de mauvaise classification présente un pic net à 0,5 et des pentes linéaires.
Maintenant, la question se pose : pourquoi préférons-nous utiliser l'entropie et l'impureté de Gini au lieu de l'erreur de classification erronée lors de la croissance des arbres de décision ? Cette question s'applique à la fois à l'entropie et à l'impureté de Gini, mais pour plus de simplicité, nous nous concentrerons sur l'entropie dans cette discussion.
Récapitulons l'équation du gain d'information. Nous commençons avec un nœud parent, noté D, et divisons cet ensemble de données en fonction des valeurs de caractéristiques, en créant différents nœuds enfants. La fonction d'impureté est utilisée à la fois pour les nœuds parent et enfant, et nous additionnons les valeurs d'impureté tout en tenant compte de la taille des ensembles de données. Si nous choisissons l'entropie pour le nœud parent, nous utilisons également l'entropie pour les nœuds enfants. Le même principe s'applique à l'impureté de Gini.
En pratique, nous préférerions ne pas utiliser l'erreur de mauvaise classification car elle présente un inconvénient, que nous allons explorer dans cette vidéo. Pour mieux comprendre cela, examinons brièvement les formules d'entropie, d'impureté de Gini et d'erreur de classification erronée.
L'entropie est calculée en insérant les proportions des étiquettes de classe et en les additionnant. Il utilise des logarithmes et est représenté par la formule où nous additionnons les classes et multiplions la proportion de chaque classe par le logarithme de cette proportion.
L'impureté de Gini, en revanche, met au carré la proportion de l'étiquette de classe et la soustrait de un. Il évite d'utiliser des logarithmes et est noté 1 moins la somme des proportions d'étiquettes de classe au carré.
L'erreur de classification erronée est basée sur la perte 0-1, qui mesure la proportion d'étiquettes mal classées. Par exemple, si nous avons un nœud avec des étiquettes 001111, le vote majoritaire prédira 0 car il s'agit de la classe majoritaire. Cependant, compte tenu de la distribution, nous n'aurions raison que quatre fois sur six, ce qui donnerait une précision de 4/6 ou 66,6 %. L'erreur serait de 2/6 ou 33,3 %.
Pour comparer l'entropie et l'erreur de classification erronée, nous observons que l'entropie est concave, tandis que l'erreur de classification erronée présente un pic net à 0,5 et des pentes linéaires. Cette différence est cruciale pour comprendre pourquoi l'entropie est préférée à l'erreur de classification erronée pour la croissance des arbres de décision.
Pour illustrer cela, considérons un ensemble de données de jouet simple avec un nœud parent contenant 40 exemples de la classe un et 80 exemples de la classe zéro. En supposant que la meilleure caractéristique à diviser est x1, nous divisons l'ensemble de données selon que les valeurs de caractéristique sont un ou zéro. Nous obtenons deux nœuds enfants : le nœud enfant un et le nœud enfant deux. En analysant la distribution des classes, nous constatons que le nœud enfant deux est plus pur que le parent, tandis que le nœud enfant un est pire.
La question clé est de savoir si cela vaut la peine de se diviser sur cette fonctionnalité ou non. Pour le déterminer, nous calculons le gain d'information en utilisant l'entropie. Nous calculons les valeurs d'entropie pour le parent, le nœud enfant un et le nœud enfant deux. En comparant ces valeurs, nous observons que le nœud enfant deux est meilleur, tandis que le nœud enfant un est pire que le parent. En appliquant la formule de gain d'information, nous constatons que le gain d'information pour cette division est positif, ce qui indique que la division améliore la pureté globale de l'ensemble de données.
Considérons maintenant l'erreur de classification erronée comme mesure d'impureté au lieu de l'entropie. Nous calculons l'erreur de mauvaise classification pour le parent, le nœud enfant un et le nœud enfant deux. En comparant ces valeurs, nous constatons que le nœud enfant deux a une erreur de mauvaise classification inférieure à celle du parent, tandis que le nœud enfant un a une erreur de mauvaise classification plus élevée.
Cependant, lorsque nous calculons le gain d'information à l'aide de l'erreur de mauvaise classification, nous rencontrons un problème. La formule de gain d'informations consiste à soustraire les erreurs de mauvaise classification pondérées des nœuds enfants de l'erreur de mauvaise classification du parent. Étant donné que l'erreur de mauvaise classification est une fonction linéaire, le gain d'information peut être négatif si l'erreur de mauvaise classification des nœuds enfants est supérieure à celle du parent.
Dans notre exemple, même si le nœud enfant deux a une erreur de mauvaise classification inférieure à celle du parent, l'erreur de mauvaise classification du nœud enfant un est plus élevée, ce qui entraîne un gain d'informations négatif. Cela signifie que l'utilisation de l'erreur de classification erronée comme mesure d'impureté découragerait la scission, même si cela améliore la pureté de l'un des nœuds enfants.
D'autre part, lorsque nous utilisons l'entropie ou l'impureté de Gini comme mesure d'impureté, le gain d'information sera toujours non négatif. L'entropie et l'impureté de Gini sont des fonctions concaves, ce qui signifie que les valeurs d'impureté des nœuds enfants sont toujours inférieures ou égales à la valeur d'impureté du nœud parent. Cela garantit que le gain d'informations sera positif chaque fois que la division améliore la pureté d'au moins un nœud enfant.
En utilisant l'entropie ou l'impureté de Gini comme mesure d'impureté, les arbres de décision peuvent effectuer des divisions en fonction du gain d'informations, ce qui fournit une approche fondée sur des principes pour développer l'arbre et améliorer son pouvoir prédictif. L'erreur de classification erronée, d'autre part, peut conduire à des divisions sous-optimales et à des arbres de décision moins précis.
En résumé, la préférence pour l'entropie et l'impureté de Gini par rapport à l'erreur de classification dans les algorithmes d'arbre de décision est enracinée dans leurs propriétés mathématiques. La nature concave de l'entropie et de l'impureté de Gini garantit que le gain d'information sera positif pour les fractionnements qui améliorent la pureté des nœuds enfants, tandis que la nature linéaire de l'erreur de mauvaise classification peut entraîner des gains d'information négatifs et des fractionnements sous-optimaux.
6.7 Exemple de code Implémentation d'arbres de décision dans Scikit-Learn (L06 : Arbres de décision)
6.7 Exemple de code Implémentation d'arbres de décision dans Scikit-Learn (L06 : Arbres de décision)
Pour conclure la sixième conférence, nous allons maintenant examiner un exemple de code utilisant scikit-learn, en nous concentrant spécifiquement sur l'algorithme d'arbre de décision. Scikit-learn est recommandé pour les projets d'apprentissage automatique dans le monde réel en raison de sa rapidité, de son efficacité et de sa robustesse. Bien que nous utiliserons scikit-learn pour cette démonstration, il convient de mentionner que vous implémenterez un arbre de décision à partir de zéro pour le devoir afin d'améliorer votre compréhension de l'algorithme.
Pour commencer, importons les packages nécessaires, y compris le package de filigrane, qui nous aidera à suivre les versions du logiciel utilisé. Cela peut être utile en cas de problème lors de l'exécution du code en raison de versions logicielles obsolètes. Ensuite, nous chargeons le jeu de données iris, un jeu de données populaire souvent utilisé pour les tâches de classification. En utilisant un ensemble de données bien connu comme iris, nous pouvons nous concentrer davantage sur la compréhension du code et de ses fonctionnalités plutôt que sur l'explication des données.
Nous avons divisé l'ensemble de données en ensembles d'entraînement et de test, avec 30 % des données allouées aux tests. Il est important de noter que nous n'effectuerons aucun réglage dans ce notebook. Bien qu'il soit possible d'ajuster les hyperparamètres de l'arbre de décision à l'aide de techniques telles que la recherche par grille, nous allons rester simples et ignorer l'ajustement pour l'instant. Par conséquent, nous n'avons pas besoin d'un ensemble de validation séparé, car nous entraînerons l'arbre de décision uniquement sur l'ensemble d'apprentissage et évaluerons ses performances sur l'ensemble de test.
Passant au tracé des régions de décision, nous initialisons le classificateur d'arbre de décision et définissons les hyperparamètres. Dans ce cas, nous choisissons le critère d'entropie pour le gain d'information et fixons la profondeur maximale à deux à des fins pédagogiques. De plus, nous adaptons l'arbre de décision aux données d'apprentissage et traçons les régions de décision. En visualisant les régions de décision, nous pouvons observer comment l'arbre de décision sépare les données en fonction des caractéristiques sélectionnées.
Nous explorons différentes options et hyperparamètres qui peuvent être définis pour le classificateur d'arbre de décision. Ceux-ci incluent le séparateur, qui détermine comment les divisions sont effectuées à chaque nœud, et les paramètres liés aux échantillons minimum requis pour diviser les nœuds et les nœuds feuilles. Il existe également des options pour sélectionner la mesure d'impureté et contrôler le caractère aléatoire des fractionnements. Ces hyperparamètres peuvent être ajustés et ajustés en fonction du problème et de l'ensemble de données spécifiques.
Ensuite, nous procédons à la visualisation de l'arbre de décision à l'aide de la bibliothèque graphviz. Nous exportons l'arbre de décision sous forme de fichier de points, qui représente la structure arborescente sous forme de graphique. Nous pouvons personnaliser l'apparence des nœuds, des arêtes et des étiquettes dans le graphique. En utilisant la bibliothèque graphviz en conjonction avec la bibliothèque pydotplus, nous pouvons tracer l'arbre de décision directement sans enregistrer le fichier dot séparément. De cette façon, nous pouvons visualiser l'arbre de décision dans le cahier lui-même.
Pour afficher le tracé de l'arbre de décision, nous chargeons le fichier PNG généré à l'aide du module d'affichage ipython. Nous importons la classe d'image de l'affichage ipython et l'utilisons pour charger le fichier PNG. Cela nous permet de visualiser le tracé de l'arbre de décision directement dans le Jupyter Notebook. Le tracé de l'arbre de décision affiche les fractionnements et les limites de décision sous forme de lignes verticales et horizontales, respectivement, en fonction des entités sélectionnées.
En résumé, cet exemple de code montre comment implémenter et visualiser un classificateur d'arbre de décision à l'aide de scikit-learn. L'algorithme d'arbre de décision fournit un modèle interprétable pour les tâches de classification et peut être ajusté à l'aide de divers hyperparamètres pour améliorer les performances. La visualisation de l'arbre de décision aide à comprendre comment l'algorithme prend des décisions en fonction des caractéristiques d'entrée.
7.1 Introduction aux méthodes d'ensemble (L07 : Ensemble Methods)
7.1 Introduction aux méthodes d'ensemble (L07 : Ensemble Methods)
Dans la conférence de cette semaine, nous nous plongerons dans les méthodes d'ensemble, qui sont un domaine crucial de l'apprentissage automatique. Ces méthodes sont largement utilisées dans la recherche appliquée en apprentissage automatique pour atteindre des performances élevées dans les applications du monde réel. Les méthodes solides, connues pour leur efficacité dans la pratique, donnent souvent les meilleurs résultats.
La conférence revisitera également les arbres de décision, en abordant certaines questions soulevées sur Piazza quant à leur pertinence. Bien qu'il s'agisse d'un algorithme relativement ancien et familier, les arbres de décision restent très pertinents aujourd'hui. Ils ne sont pas seulement interprétables mais sont fréquemment employés dans les méthodes d'ensemble, où ils présentent des performances exceptionnelles. La conférence vise également à explorer cet aspect.
Avant de se plonger dans les méthodes d'ensemble, il est important de récapituler où nous en sommes dans le semestre. Nous terminons actuellement la troisième partie, qui se concentre sur les méthodes basées sur les arbres. Cependant, il convient de noter que certaines de ces méthodes vont au-delà des arbres de décision et englobent d'autres techniques, y compris des méthodes solides appliquées aux réseaux de neurones profonds. Les arbres de décision ont été classés dans la troisième partie en raison de leur étroite association avec la plupart des méthodes d'ensemble.
Après avoir terminé cette section, nous approfondirons l'évaluation du modèle avant de discuter de l'apprentissage non supervisé et, si le temps le permet, de l'apprentissage bayésien. Bien que le plan initial était d'avoir l'examen de mi-session et de couvrir d'autres méthodes plus tôt, la progression du cours a pris plus de temps que prévu. Néanmoins, le temps supplémentaire passé à configurer l'environnement Python et à familiariser tout le monde, en particulier ceux qui n'avaient pas de solides connaissances en Python, a été bénéfique. Il garantit que tous les participants sont sur la même longueur d'onde et préparés pour les devoirs à venir, qui impliqueront la mise en œuvre d'un arbre de décision CART (arbres de classification et de régression) sans s'appuyer sur des bibliothèques prédéfinies telles que scikit-learn.
Le cours magistral est structuré en sept parties. La première partie présente une introduction et un aperçu des méthodes d'ensemble. Par la suite, nous explorerons diverses méthodes internes, à commencer par le vote majoritaire, le type le plus simple de méthode d'ensemble. Nous approfondirons ensuite le bagging, une technique qui implique un échantillonnage bootstrap à partir de l'ensemble d'apprentissage. L'utilité de cette méthode sera expliquée. Le boosting, qui consiste à booster les apprenants faibles (tels que les arbres de décision courts) en modèles solides, sera également couvert. En particulier, nous aborderons le gradient boosting, l'un des algorithmes les plus populaires aujourd'hui, connu pour son succès dans les compétitions Kaggle. Les forêts aléatoires, une autre méthode d'ensemble largement reconnue, seront introduites. Ces modèles sont connus pour leur facilité d'utilisation, car ils offrent souvent d'excellentes performances sans réglage approfondi des hyperparamètres. Ils sont recommandés pour les personnes à la recherche de modèles prédictifs dans divers domaines scientifiques, en particulier s'ils manquent d'expertise en apprentissage automatique.
Les machines à vecteurs de support (SVM) seront également évoquées, notamment leur popularité dans le passé en raison de leurs performances, notamment avec les noyaux RBF (Radial Basis Function). Cependant, les forêts aléatoires fournissent souvent des résultats aussi bons ou meilleurs sans nécessiter de réglages approfondis, ce qui les rend préférables pour les applications pratiques. Enfin, l'empilement, une autre technique populaire dans les applications, sera abordé.
Pour illustrer l'importance des méthodes d'ensemble, une figure sera présentée, présentant un exemple impliquant des forêts aléatoires. Ce modèle n'est pas limité aux tâches de classification et peut facilement calculer l'importance des caractéristiques. Par exemple, dans l'exemple mentionné, les atomes de soufre ont été identifiés comme les caractéristiques les plus importantes pour prédire l'activité des molécules. De telles informations peuvent être précieuses dans la pratique.
De plus, les méthodes d'ensemble, y compris les forêts aléatoires et l'amplification de gradient, font partie des modèles d'apprentissage automatique non profonds les plus largement utilisés. Bien que l'apprentissage en profondeur gagne en importance, les ensembles sont toujours très pertinents en raison de leurs performances exceptionnelles et de leur facilité de mise en œuvre. L'article mentionnait la montée en puissance de l'extrême gradient boosting (XGBoost) comme la "nouvelle reine" des algorithmes d'apprentissage automatique. Cela souligne l'importance des modèles arborescents, en particulier l'amplification du gradient, dans diverses applications.
En résumé, la conférence de cette semaine fournira une compréhension complète des méthodes d'ensemble. Il couvrira différents types de techniques d'ensemble et leurs applications.
7.2 Vote à la majorité (L07 : Méthodes d'ensemble)
7.2 Vote à la majorité (L07 : Méthodes d'ensemble)
Dans cette vidéo, nous allons explorer l'un des cas fondamentaux d'ensembles modèles connus sous le nom de vote majoritaire. À travers un exemple jouet, nous examinerons les avantages du vote à la majorité par rapport à l'utilisation d'un seul classificateur isolé.
Pour commencer, considérons un scénario où nous avons un problème de classification binaire. Nous avons un ensemble de données composé de plusieurs observations, chacune associée à un ensemble d'entités et à une étiquette de classe correspondante. Notre objectif est de créer un classificateur capable de prédire avec précision les étiquettes de classe pour les nouvelles instances invisibles.
Pour démontrer le concept de vote à la majorité, nous commençons par former trois classificateurs individuels sur notre ensemble de données. Chaque classificateur utilise un algorithme ou un modèle différent pour faire des prédictions. Pour simplifier, supposons que ces classificateurs sont des arbres de décision.
Une fois que nous avons formé nos trois classificateurs d'arbre de décision, nous pouvons maintenant faire des prédictions sur de nouvelles instances. Cependant, au lieu de nous fier à la prédiction d'un seul classifieur, nous utilisons le principe du vote à la majorité. Lors du vote majoritaire, chaque classificateur de l'ensemble vote pour son étiquette de classe prédite. L'étiquette de classe qui reçoit le plus de votes est considérée comme la prédiction finale de l'ensemble.
Voyons maintenant pourquoi le vote à la majorité peut être plus efficace que l'utilisation d'un seul classificateur. Considérez un scénario où chaque classificateur d'arbre de décision individuel a un certain degré d'erreur en raison du bruit inhérent ou de la variabilité dans l'ensemble de données. Ces erreurs peuvent conduire à des prédictions incorrectes, réduisant la précision globale d'un seul classifieur.
Cependant, en combinant les prédictions de plusieurs classificateurs par le vote à la majorité, nous pouvons potentiellement atténuer l'impact des erreurs individuelles. Même si un ou deux classificateurs d'arbre de décision font des prédictions incorrectes, le processus de vote à la majorité peut compenser ces erreurs. L'étiquette de classe qui reçoit la majorité des votes est plus susceptible d'être correcte, ce qui améliore la précision par rapport à l'utilisation d'un seul classificateur.
Pour illustrer cela, imaginons une situation où deux classificateurs d'arbre de décision prédisent l'étiquette de classe correcte, tandis qu'un classificateur fait une prédiction erronée. Dans ce cas, l'étiquette de classe correcte recevra deux votes, tandis que la prédiction erronée ne recevra qu'un seul vote. En conséquence, le processus de vote majoritaire de l'ensemble identifiera correctement l'étiquette de classe avec le plus de votes comme prédiction finale, remplaçant la prédiction incorrecte du classificateur individuel.
Cet exemple démontre la puissance des méthodes d'ensemble, en particulier le vote à la majorité, pour améliorer la précision des prédictions. En combinant les prédictions de plusieurs classificateurs, nous pouvons tirer parti des forces de chaque classificateur et minimiser l'impact de leurs faiblesses ou erreurs individuelles.
En conclusion, cette vidéo souligne l'importance du vote majoritaire comme forme de base des ensembles modèles. À travers un exemple jouet, nous avons vu comment le vote à la majorité peut surpasser l'utilisation d'un seul classificateur, en particulier lorsque les classificateurs individuels présentent des erreurs ou une variabilité. Les méthodes d'ensemble, telles que le vote à la majorité, offrent une approche puissante pour améliorer la précision des prédictions et sont largement utilisées dans les applications pratiques d'apprentissage automatique.
7.3 Ensachage (L07 : Méthodes d'ensemble)
7.3 Ensachage (L07 : Méthodes d'ensemble)
Après avoir discuté en profondeur du concept de vote à la majorité dans la vidéo précédente, la vidéo à venir plongera dans une autre méthode fondamentale connue sous le nom de bagging, qui signifie agrégation bootstrap. Le terme "bagging" est dérivé de la combinaison des initiales "B" et "ag G" et est étroitement lié au concept de bootstrap. Cette technique a été proposée à l'origine par Leo Breiman, une figure éminente dans le domaine des arbres de décision, en particulier des arbres de classification et de régression (CART). Nous explorerons plus en détail les contributions de Breiman dans une prochaine conférence consacrée aux forêts aléatoires.
Pour commencer, décrivons l'algorithme de bagging. Bien qu'il puisse sembler complexe à première vue, il est en fait assez simple et se compose de seulement six lignes de code, ou cinq si l'on exclut la ligne vide. L'algorithme fonctionne comme suit : Supposons que nous ayons un total de n échantillons ou tours bootstrap. Pour chaque tour i, nous tirons un échantillon bootstrap de taille m à partir de l'ensemble d'apprentissage. Ici, m représente la taille de l'ensemble d'apprentissage. Il est important de noter que l'utilisation de lettres simples pour les variables peut sembler non conventionnelle, mais elle était nécessaire en raison des limitations imposées par le choix des lettres. Dans la vidéo précédente, nous avons utilisé n pour représenter le nombre d'échantillons bootstrap, ce qui correspond au nombre de classificateurs dans les classificateurs de vote d'ensemble dont nous avons discuté.
Pour chaque échantillon bootstrap, nous formons un classificateur et appliquons le vote à la majorité. Ce processus est assez similaire au classificateur de vote d'ensemble que nous avons abordé précédemment, à la seule différence qu'au lieu d'entraîner chaque classificateur sur l'ensemble de l'apprentissage, nous entraînons chaque classificateur de base sur un échantillon bootstrap extrait de l'ensemble d'apprentissage.
Avant de poursuivre, récapitulons brièvement le concept d'échantillonnage bootstrap. Considérons un ensemble de données d'une taille de m. Chaque échantillon bootstrap tiré de cet ensemble de données aura également une taille de m, basée sur l'algorithme susmentionné. L'échantillonnage bootstrap implique la sélection aléatoire de points de données dans l'ensemble de données avec remplacement. Par exemple, si nous avons dix points de données étiquetés de un à dix et que nous effectuons un échantillonnage avec remplacement, certains des points de données seront dupliqués dans l'ensemble de données bootstrap. Cette duplication se produit parce que chaque position est tirée indépendamment de l'ensemble de formation. Par conséquent, certains points de données peuvent apparaître plusieurs fois, tandis que d'autres peuvent ne pas apparaître du tout, ce qui donne ce que nous appelons des échantillons hors sac (OOB). Ces échantillons OOB sont les points de données qui ne sont pas inclus dans l'échantillon bootstrap pour un cycle particulier.
Pour mieux comprendre la probabilité associée à la non-sélection d'un élément spécifique dans un échantillon bootstrap, examinons la probabilité de ne pas sélectionner un point de données particulier pour une seule position. La probabilité de choisir un point de données spécifique pour une position donnée est de 1/m, puisqu'il y a m exemples dans l'ensemble d'apprentissage. Par conséquent, la probabilité de ne pas sélectionner ce point de données particulier est de 1 - 1/m. Puisque nous avons m choix, la probabilité de ne pas choisir un exemple spécifique dans l'ensemble de l'échantillon bootstrap est de (1 - 1/m)^n. Lorsque m devient suffisamment grand, environ 36,8 % des points ne seront pas inclus dans l'échantillon bootstrap. Par conséquent, 63,2 % des points de données seront uniques dans l'échantillon bootstrap, tandis que les points restants seront des doublons.
La visualisation de l'échantillonnage bootstrap dans la procédure d'ensachage peut aider à mieux comprendre le concept. Plusieurs cycles d'échantillonnage bootstrap sont effectués, chacun aboutissant à un nouvel échantillon bootstrap. Un classificateur est ensuite formé indépendamment sur chaque échantillon bootstrap. Ce processus facilite le parallélisme des modèles puisqu'il n'y a pas de dépendance entre les tours d'amorçage. Par conséquent, chaque cycle peut être exécuté simultanément, ce qui améliore le potentiel de traitement parallèle.
L'organigramme du classificateur d'ensachage donne un aperçu des étapes impliquées. Semblable au classificateur de vote, le classificateur d'ensachage commence par un ensemble d'apprentissage. Cependant, dans le bagging, nous réutilisons l'ensemble d'apprentissage pour créer plusieurs échantillons bootstrap. Chaque échantillon bootstrap est utilisé pour former un classificateur, ce qui donne un total de m classificateurs. Chaque classificateur génère des prédictions et la prédiction finale est déterminée par un vote à la majorité. Cette approche aide à réduire le surajustement et à améliorer la stabilité et la généralisation du modèle.
L'ensachage offre plusieurs avantages :
Malgré ses avantages, l'ensachage présente également certaines limites :
Dans cette section, nous approfondirons les concepts abordés précédemment. Lorsque les prédictions d'un modèle présentent des variations importantes, cela indique une variance élevée. Par exemple, considérons un arbre de décision complexe pour le cas orange. Les prédictions de ce modèle différeront considérablement des prédictions du modèle bleu. De même, le cas vert aura son propre ensemble de prédictions différentes. Ces prédictions variables illustrent le concept de variance élevée.
Pour mieux comprendre l'impact d'une variance élevée, examinons les arbres de décision réels ajustés sur ces ensembles de données. Malgré leurs variations, le cas à forte variance parvient toujours à fournir une bonne prédiction moyenne. Il est important de noter que même si je n'ai pas explicitement montré la prédiction moyenne ici, la moyenne des prédictions des trois modèles (modèles un, deux et trois) ajustés sur différents ensembles d'apprentissage se traduira par une prédiction qui se rapproche étroitement de la vraie fonction . En revanche, les modèles à fort biais, comme indiqué précédemment, ne sont précis qu'à des positions spécifiques où les lignes se croisent avec la vraie fonction. Dans tous les autres cas, ils fonctionnent mal en raison de leur biais élevé.
Cependant, en utilisant un modèle à variance élevée et en faisant la moyenne des prédictions de plusieurs modèles, nous pouvons toujours obtenir des prédictions précises. Ce concept constitue la base du bagging, qui consiste à utiliser différents ensembles d'apprentissage générés par l'échantillonnage bootstrap. Dans le bagging, chaque échantillon bootstrap est utilisé pour ajuster un arbre de décision, ce qui donne plusieurs modèles à variance élevée. Ces modèles sont ensuite moyennés à l'aide du vote d'ensemble, soit en considérant les étiquettes de classe dans les tâches de classification, soit les sorties de régression dans les tâches de régression. Ce processus de calcul de la moyenne aide à obtenir des prévisions très précises en réduisant la variance.
En faisant la moyenne des prédictions des trois arbres de décision ajustés sur différents ensembles d'apprentissage, nous obtiendrions une prédiction moyenne qui se rapproche étroitement de la vraie fonction. Cette moyenne est similaire au concept de bagging, où chaque ensemble d'apprentissage agit comme un ensemble de données bootstrap. Deuxièmement, il est important de noter que les arbres de décision ne peuvent pas interpoler les valeurs. Ils ne peuvent prédire que les valeurs cibles qui existent dans l'ensemble d'apprentissage ou leurs moyennes. Ainsi, la fonction pas à pas illustrée sur la figure est une approximation d'un arbre de décision non élagué.
Pour conclure, le bagging est une technique efficace pour réduire la variance en faisant la moyenne des prédictions des modèles à forte variance. En utilisant la parallélisation, le bagging peut accélérer l'ajustement du modèle en utilisant plusieurs processeurs. Cependant, certains ordinateurs Windows peuvent rencontrer des problèmes de multitraitement en Python, ce qui limite l'utilisation de plusieurs tâches. Il convient également de mentionner que les classificateurs d'ensachage peuvent calculer la précision hors sac, ce qui implique d'utiliser les points de données qui ne sont pas inclus dans l'échantillon bootstrap pour évaluer les performances du modèle. Cela fournit une métrique utile pour évaluer la capacité de généralisation du modèle. Dans l'exemple de code utilisant scikit-learn, le classificateur d'ensachage peut être importé à partir du sous-module ensemble.
L'estimateur de base, qui est l'arbre de décision dans ce cas, est initialisé avec la profondeur maximale définie sur Aucun pour créer un arbre de décision non élagué. Le nombre d'estimateurs détermine le nombre de cycles d'amorçage et la parallélisation peut être obtenue en définissant le paramètre n_jobs en conséquence. De plus, le paramètre oob_score permet de calculer le score out-of-bag. Après avoir formé le classificateur d'ensachage, le score hors sac et la précision de l'ensemble de test peuvent être évalués.
Dans l'ensemble, le bagging offre une approche efficace pour atténuer la variance élevée et améliorer la précision des prédictions en combinant plusieurs modèles à variance élevée. En résumé, le bagging est une méthode d'ensemble puissante qui combine plusieurs classificateurs formés sur différents échantillons bootstrap pour améliorer la précision de la prédiction et réduire la variance. Il est particulièrement utile lorsqu'il s'agit d'ensembles de données complexes et peut améliorer la stabilité et la généralisation du modèle. Cependant, il présente également certaines limites, notamment une interprétabilité réduite et une complexité de calcul accrue.
7.4 Boosting et AdaBoost (L07 : Ensemble Methods)
7.4 Boosting et AdaBoost (L07 : Ensemble Methods)
Dans la vidéo précédente, nous avons discuté du concept de modèles à forte variance et à faible biais, en nous concentrant spécifiquement sur les arbres de décision non élagués. Nous avons également découvert une technique appelée bagging, qui permet d'améliorer les performances des modèles à variance élevée en réduisant la variance grâce à la moyenne.
Dans cette conférence, nous porterons notre attention sur le boosting, qui fonctionne dans la direction opposée. Le boosting consiste à utiliser des modèles à fort biais avec une faible variance, tels que de simples souches d'arbre de décision, et à les booster pour améliorer les performances globales du modèle. Cette première vidéo fournira un aperçu des concepts de boosting et présentera le boosting en général, tandis que la prochaine vidéo se plongera dans un type de boost populaire appelé gradient boosting.
Le boosting peut être classé en deux types principaux : le boosting adaptatif (par exemple, adaboost) et le boosting de gradient. Historiquement, le gradient boosting était moins utilisé en raison de sa complexité de calcul. Cependant, des avancées récentes, telles que l'introduction de XGBoost en 2016, ont considérablement amélioré les performances du gradient boosting. De nos jours, des variantes encore meilleures comme LightGBM sont apparues, dont nous parlerons dans la prochaine vidéo. Bien que le gradient boosting ait gagné en popularité, il est essentiel de comprendre la procédure générale de boosting grâce au boosting adaptatif.
La procédure de boosting suit un schéma spécifique, qui diffère de la procédure d'ensachage. Une distinction notable est la présence de dépendances entre les rondes. La procédure de renforcement implique plusieurs classificateurs, appelés classificateur un, classificateur deux, etc., jusqu'au classificateur M. Initialement, nous commençons avec un ensemble de données d'apprentissage régulier et adaptons le classificateur un. Sur la base des prédictions du classificateur un, nous pondérons les échantillons d'apprentissage à l'aide d'une méthode de pondération spécifique, dont nous discuterons plus en détail ultérieurement. Ensuite, le deuxième classifieur utilise cet ensemble de données d'apprentissage pondéré et le processus se poursuit. La pondération dépend des prédictions des classificateurs précédents, ce qui rend difficile la parallélisation du boosting. Contrairement au bagging, où les classificateurs peuvent être formés simultanément, le boosting nécessite d'attendre que le classificateur précédent ait fait des prédictions avant de mettre à jour l'ensemble de données pour le classificateur suivant. Lors de la réalisation des prédictions finales, le boosting utilise une combinaison pondérée des classificateurs, contrairement au vote d'ensemble ou à la moyenne utilisés dans le bagging. La combinaison pondérée est déterminée en fonction de la fonction de signe, qui attribue des poids à la prédiction de chaque classifieur. Pour la classification binaire, la fonction de signe renvoie 1 pour les résultats positifs et -1 pour les résultats négatifs. Cette prédiction pondérée aboutit à une prédiction finale de -1 ou 1. Le processus peut être étendu pour gérer des nombres arbitraires de classes à l'aide de fonctions indicatrices.
Pour mieux comprendre la procédure générale de boosting, décrivons les étapes impliquées. Tout d'abord, nous initialisons un vecteur de poids avec des poids uniformes pour chaque exemple d'apprentissage. Ces poids représentent l'importance de chaque exemple de formation. Ensuite, nous entrons dans une boucle qui itère sur les différents classificateurs ou tours de la procédure de boosting. À chaque tour, nous appliquons un apprenant faible, qui est un classificateur légèrement meilleur que la supposition aléatoire, aux exemples d'apprentissage pondérés. Nous pouvons attribuer des poids plus élevés à des exemples spécifiques ou tirer des échantillons bootstrap avec des probabilités pondérées. Après avoir formé l'apprenant faible, nous augmentons le poids des exemples mal classés, permettant au classificateur suivant de se concentrer sur ces exemples mal classés. Cette boucle est répétée plusieurs fois, et enfin, un vote à la majorité pondérée est effectué sur les classificateurs entraînés pour obtenir les prédictions finales.
Concentrons-nous maintenant sur l'algorithme adaboost, qui s'aligne étroitement sur la procédure de boosting générale décrite précédemment. Adaboost est similaire au schéma général de renforcement, où les classificateurs sont ajustés sur des exemples d'entraînement pondérés. L'algorithme commence par initialiser les pondérations pour chaque point de données d'apprentissage. Ensuite, la boucle for principale, comprenant les tours adaboost, commence. À chaque tour, les poids sont normalisés pour s'assurer qu'ils totalisent un. Ensuite, un apprenant faible est formé sur l'ensemble d'apprentissage pondéré et les erreurs de prédiction pondérées sont calculées. Les erreurs de prédiction sont pondérées par les poids de l'ensemble d'apprentissage et indiquent les erreurs de classification. Les erreurs de prédiction sont ensuite utilisées pour calculer la contribution de l'apprenant faible à la prédiction finale. La contribution est déterminée par la précision de l'apprenant faible, les apprenants plus précis ayant une contribution plus élevée. La contribution est ensuite utilisée pour mettre à jour les poids des exemples d'apprentissage. Les poids des exemples mal classés sont augmentés, tandis que les poids des exemples correctement classés sont diminués. Cet ajustement met l'accent sur l'importance des exemples mal classés dans les cycles suivants.
Après la mise à jour des pondérations, le processus passe au tour suivant, où l'apprenant faible est formé sur l'ensemble de formation pondéré mis à jour. Ce processus itératif se poursuit pendant le nombre de tours spécifié ou jusqu'à ce qu'un certain critère soit rempli. Une fois tous les tours terminés, la prédiction finale est faite en combinant les prédictions de tous les apprenants faibles. Le poids de la prédiction de chaque apprenant faible est déterminé par sa contribution à la précision globale pendant la formation.
L'algorithme adaboost combine efficacement les prédictions des apprenants faibles pour créer un modèle d'ensemble solide. Les poids attribués à la prédiction de chaque apprenant faible reflètent sa performance dans la classification des exemples de formation. En ajustant itérativement les pondérations et en se concentrant sur les exemples mal classés, adaboost est en mesure d'améliorer la précision du modèle au fil du temps.
Il est important de noter qu'adaboost est sensible aux valeurs aberrantes et au bruit dans les données. Les valeurs aberrantes peuvent avoir un impact significatif sur les mises à jour de poids, entraînant potentiellement un surajustement. Par conséquent, il est recommandé de prétraiter les données pour gérer les valeurs aberrantes et les échantillons bruyants. De plus, adaboost peut être sujet au surajustement si les apprenants faibles sont trop complexes ou si le nombre de tours est trop élevé. Les techniques de régularisation telles que la limitation de la profondeur des arbres de décision ou l'utilisation d'un arrêt précoce peuvent aider à atténuer le surajustement.
Si nous devions esquisser grossièrement le concept, cela ressemblerait à ceci : nous avons une flèche sur l'axe des x, représentant la valeur alpha. La valeur alpha détermine l'importance de chaque classificateur dans la prédiction finale. Lorsque nous utilisons la valeur alpha pour pondérer l'estimation et la prédiction, nous constatons que si un classificateur a une erreur importante, la valeur alpha sera relativement faible. Cela signifie qu'un classificateur avec une erreur élevée n'est pas aussi important pour la prédiction finale. D'autre part, les classificateurs avec de petites erreurs auront un poids plus élevé car nous leur faisons plus confiance lors du calcul du vote majoritaire.
Nous utilisons la valeur alpha de deux manières : premièrement, nous l'utilisons pour pondérer l'estimation et la prédiction, et deuxièmement, nous l'utilisons pour mettre à jour les pondérations pour le tour suivant. Si la prédiction est correcte, le poids attribué à cet exemple d'entraînement sera faible. Cela signifie que si nous faisons une prédiction correcte, nous n'accordons pas beaucoup d'attention à cet exemple d'entraînement au tour suivant. Il est considéré comme un exemple facile. En revanche, si nous commettons une erreur, le poids attribué à cet exemple sera plus important. Cela signifie que nous accordons plus d'attention aux exemples mal classés lors du prochain tour. Plus la valeur alpha est petite, plus le poids attribué aux exemples mal classés est important.
Pour illustrer ce concept, considérons un cas bidimensionnel. Nous avons un exemple de jouet avec deux fonctionnalités, x1 et x2. Nous adaptons une souche d'arbre de décision, qui est un arbre de décision avec une seule division. La souche d'arbre de décision classe correctement certains points mais fait des erreurs sur d'autres. Au premier tour d'AdaBoost, nous donnons des poids plus élevés aux exemples mal classés et des poids plus faibles aux exemples correctement classés. Ensuite, nous adaptons une autre souche d'arbre de décision, en nous concentrant sur les exemples mal classés du tour précédent. Ce processus se poursuit, chaque nouveau classificateur apprenant des erreurs du classificateur précédent et accordant plus d'attention aux exemples mal classés. Enfin, lorsque nous combinons tous les classificateurs en utilisant le vote majoritaire, nous pouvons nous retrouver avec un classificateur qui classe correctement tous les exemples.
AdaBoost peut être un peu compliqué à comprendre, mais il existe des ressources disponibles pour vous aider. L'article original sur AdaBoost fournit une explication approfondie, mais pour une introduction plus accessible, l'article du didacticiel de Manwani est recommandé. Avant de passer aux exemples de code, il convient de mentionner une modification de l'algorithme AdaBoost pour la classification multi-classes appelée AdaBoost.M2 ou SAMME. Il introduit une petite modification à l'algorithme d'origine pour gérer plusieurs classes. Il existe également une version en nombre réel appelée SAMME.R. Si vous êtes intéressé, vous pouvez explorer ces variations dans les documents respectifs.
Dans scikit-learn, AdaBoost est implémenté en tant que classificateur boostant. Il utilise des souches d'arbre de décision comme classificateurs faibles et ajuste les poids des exemples d'apprentissage en fonction de leurs résultats de classification. En boostant ces classificateurs faibles, AdaBoost améliore les performances globales. En comparant la précision d'un arbre de décision non élagué et d'une souche d'arbre de décision sur l'ensemble de données de l'iris, AdaBoost avec des souches d'arbre de décision atteint une plus grande précision. Le processus de formation implique la mise à jour des poids de l'échantillon, il n'y a donc pas d'option de parallélisation comme dans le bagging. AdaBoost dans scikit-learn fournit un moyen efficace de booster les classificateurs faibles et d'obtenir de meilleurs résultats de classification.
Ensuite, nous nous plongerons dans le gradient boosting, une autre variante populaire du boosting. L'amplification des dégradés s'appuie sur les concepts d'AdaBoost mais introduit des améliorations supplémentaires.
L'amplification de gradient est une variante populaire de l'algorithme d'amplification qui vise à améliorer encore les performances des classificateurs faibles en améliorant de manière itérative leurs faiblesses. Il est basé sur le concept de descente de gradient, qui est couramment utilisé dans les problèmes d'optimisation. Dans le gradient boosting, les classificateurs faibles sont séquentiellement entraînés et combinés pour créer un classificateur fort.
L'idée de base derrière le gradient boosting est d'entraîner de manière itérative des classificateurs faibles, puis d'ajuster les poids des exemples d'apprentissage en fonction des erreurs commises par l'ensemble des classificateurs. Cet ajustement se fait en calculant les gradients de la fonction de perte par rapport aux prédictions de l'ensemble. En minimisant la fonction de perte, l'ensemble améliore progressivement ses performances.
Pour illustrer le concept, prenons un exemple simple. Supposons que nous ayons un problème de classification binaire où nous voulons classer les points de données comme positifs ou négatifs. Nous commençons par former un classificateur faible initial, tel qu'une souche d'arbre de décision, sur les données de formation. Ce classificateur fera quelques erreurs, et nous calculons les erreurs ou les résidus en comparant ses prédictions aux véritables étiquettes des exemples d'apprentissage.
Dans la prochaine itération, nous formons un nouveau classifieur faible pour prédire les résidus du classificateur précédent. Ce nouveau classificateur se concentre sur la correction des erreurs commises par le précédent. Nous calculons les résidus en soustrayant les valeurs prédites des vrais résidus. Encore une fois, ce nouveau classificateur fera quelques erreurs et nous calculons les résidus.
Nous répétons ce processus, en formant séquentiellement de nouveaux classificateurs faibles pour prédire les résidus de l'ensemble, et en mettant à jour les résidus en fonction des erreurs commises par l'ensemble actuel. Chaque classificateur faible est formé pour minimiser la fonction de perte par rapport aux résidus actuels. L'ensemble final est obtenu en combinant tous les classificateurs faibles, chaque classificateur apportant un vote pondéré en fonction de ses performances.
Les poids des classificateurs faibles sont déterminés par le taux d'apprentissage, qui contrôle la contribution de chaque classificateur à la prédiction finale. Un taux d'apprentissage plus faible conduit à une convergence plus lente mais peut entraîner une meilleure généralisation. Un taux d'apprentissage plus élevé peut conduire à une convergence plus rapide, mais peut également conduire à un surajustement.
Le gradient boosting s'est avéré être une technique puissante pour un large éventail de tâches d'apprentissage automatique, y compris les problèmes de régression, de classification et de classement. Il a été appliqué avec succès dans divers domaines, tels que la vision par ordinateur, le traitement du langage naturel et la bioinformatique.
En pratique, plusieurs implémentations de gradient boosting sont disponibles, notamment XGBoost, LightGBM et CatBoost, qui offrent des algorithmes efficaces et optimisés pour le gradient boosting. Ces implémentations fournissent des fonctionnalités supplémentaires, telles que la parallélisation, les techniques de régularisation et la gestion des valeurs manquantes, pour améliorer encore les performances et la flexibilité des modèles d'amplification de gradient.
Cela conclut l'introduction au boosting et la présentation de l'algorithme adaboost. Dans la vidéo suivante, nous explorerons plus en détail l'amplification du gradient, y compris les concepts de descente de gradient, les fonctions de perte et les algorithmes spécifiques qui ont été développés pour améliorer le processus d'amplification du gradient.
7.5 Gradient Boosting (L07 : Ensemble Methods)
7.5 Gradient Boosting (L07 : Ensemble Methods)
Le concept de gradient boosting est présenté comme une version moderne du boosting qui utilise des arbres de décision et une fonction de perte différentiable. Bien que similaire à AdaBoost, le gradient boosting diffère dans la façon dont les arbres de décision sont ajustés. Dans l'amplification de gradient, des arbres plus profonds sont utilisés et aucun poids n'est attribué aux exemples d'entraînement ou aux classificateurs. L'idée clé derrière l'amplification des gradients est l'utilisation des gradients de la fonction de perte pour améliorer le modèle, ce qui se traduit par de meilleures performances sur les ensembles de données tabulaires. Cet algorithme a gagné en popularité, notamment dans les compétitions d'apprentissage automatique.
Dans le contexte de la régression, le gradient boosting commence par la construction d'un arbre de base. Par exemple, dans un problème de prévision du prix de l'immobilier, l'arbre de base initial se compose uniquement du nœud racine. La cible est prédite sur la base de la valeur moyenne à ce nœud, qui dans ce cas est le prix moyen des quatre maisons de l'ensemble d'apprentissage. Ensuite, l'arbre suivant est construit sur la base de l'erreur de prédiction de l'arbre précédent. Cette erreur prédite est utilisée pour ajuster un nouvel arbre. Les arbres des première et deuxième étapes sont combinés, et ce processus est répété plusieurs fois, chaque arbre suivant étant ajusté sur les erreurs des arbres précédents. En combinant l'arbre de décision simple avec le nouveau basé sur les résidus, le modèle peut faire des prédictions meilleures et plus précises.
Le concept de gradient boosting en tant que modèle additif est discuté, où les prédictions de tous les arbres sont combinées consécutivement en les additionnant. Le taux d'apprentissage ou la taille du pas est également introduit, ce qui détermine le poids ou la contribution de chaque arbre à la prédiction finale. L'amplification du gradient est exécutée en répétant le processus d'ajustement des arbres sur les erreurs de la prédiction précédente, en construisant progressivement le modèle avec une petite taille de pas pour éviter le surajustement. Ce processus se poursuit jusqu'à ce qu'un nombre prédéterminé d'arbres, basé sur des paramètres d'hyperparamètres, ait été complété.
L'orateur explique l'algorithme de gradient boosting, qui est utilisé à la fois pour les problèmes de régression et de classification. L'algorithme consiste à initialiser le modèle en tant que nœud racine, puis à ajuster plusieurs arbres et à créer des nœuds terminaux. Des prédictions sont faites à chaque nœud et la perte est calculée. L'algorithme peut être répété jusqu'à ce que le nombre d'arbres souhaité soit atteint, dans le but global de minimiser la perte.
Pour calculer le modèle actuel, le modèle précédent et le nouveau pas de prédiction sont combinés, pondérés par le taux d'apprentissage ou la taille du pas, pour déterminer le modèle mis à jour. Ce processus est répété jusqu'à ce que le nombre d'arbres souhaité, noté T, soit atteint. Les pseudo-résidus sont calculés, suivis du calcul de la dérivée de la perte basée sur les véritables étiquettes et prédictions du modèle du tour précédent. Les résidus sont ensuite calculés et la valeur de prédiction qui minimise la perte au niveau du nœud spécifique est déterminée. Le modèle est mis à jour en conséquence, et ce processus est répété jusqu'à ce que les modèles T soient atteints. Bien que des fonctions de perte différentiables telles que la perte de log-vraisemblance négative puissent être utilisées pour la classification, l'accent dans cette classe est mis sur l'erreur quadratique somme ou l'erreur quadratique moyenne.
La vidéo décrit les étapes impliquées dans le gradient boosting et son application pratique. La première étape consiste à minimiser la perte pour tous les exemples d'apprentissage à un nœud donné en trouvant la prédiction qui minimise l'expression. Dans la deuxième étape, une boucle est utilisée pour T arbres et la prédiction à chaque nœud feuille est calculée en faisant la moyenne des exemples à ce nœud. La prédiction moyenne est combinée avec le modèle précédent, et les prédictions pour chaque arbre sont additionnées. Le taux d'apprentissage est utilisé pour diminuer les pseudo-résidus et éviter le surajustement. La vidéo aborde également brièvement d'autres aspects intéressants de l'amplification des gradients utilisés dans la pratique.
La vidéo met en évidence les inconvénients potentiels du boosting en tant qu'algorithme séquentiel, car il ne peut pas utiliser pleinement plusieurs processus ou nœuds de calcul. Cependant, il existe une implémentation appelée xgBoost qui intègre plusieurs astuces pour rendre le processus de boosting de gradient plus efficace. En effet, parmi les 29 Challenge Winning Solutions publiées sur Kaggle de 2015 à 2017, 17 d'entre elles ont utilisé xgBoost. Huit de ces solutions s'appuyaient uniquement sur xgBoost pour former le modèle, tandis que d'autres combinaient xgBoost avec des réseaux de neurones ou utilisaient l'empilement, une technique de vote d'ensemble populaire. La vidéo présente deux tableaux d'un article qui comparent différentes implémentations de boosting, démontrant les caractéristiques uniques de xgBoost qui contribuent à son efficacité.
La vidéo traite d'Extra Boost, une variante de l'amplification de gradient qui offre plusieurs avantages, tels que l'apprentissage global approximatif, hors cœur, la sensibilisation à la parcimonie et le parallélisme. Extra Boost intègre des méthodes d'approximation pour trouver la meilleure répartition en utilisant des statistiques récapitulatives de sous-ensembles de données distribuées. La vidéo compare les performances d'Extra Boost avec d'autres implémentations d'amplification de gradient en utilisant la méthode gourmande exacte et démontre qu'Extra Boost atteint des performances identiques à une implémentation mais avec un temps considérablement réduit par arbre, ce qui le rend plus attrayant pour le réglage des hyperparamètres.
De plus, la vidéo explique les diverses améliorations offertes par Extra Boost, telles que les techniques de régularisation, la gestion des fonctionnalités manquantes par imputation et la mise en cache. Ces améliorations permettent de réduire le surajustement et d'améliorer les performances globales d'Extra Boost. De plus, Extra Boost utilise un sous-échantillonnage basé sur des colonnes et des lignes, qui sélectionne de manière aléatoire des sous-ensembles de fonctionnalités et d'exemples de formation, améliorant à la fois l'efficacité de calcul et la réduction du surajustement. La vidéo suggère de se référer à l'article sur Extra Boost pour une explication plus détaillée de ses techniques.
La vidéo donne un aperçu d'Extra Boost, une nouvelle implémentation des machines d'amplification de gradient. Extra Boost vise à réduire le surajustement et à améliorer la précision des prédictions. La vidéo traite de différentes techniques pour trouver des fractionnements, y compris l'algorithme glouton exact et la recherche de fractionnement basée sur l'histogramme. Cette dernière approche consiste à regrouper une caractéristique continue dans un histogramme discret, ce qui peut améliorer la vitesse d'entraînement et réduire l'utilisation de la mémoire. La vidéo compare également Extra Boost à Light GBM, une autre implémentation encore plus rapide et plus précise. Light GBM utilise la recherche de fractionnement basée sur l'histogramme et offre une utilisation de mémoire inférieure et une précision de prédiction plus élevée par rapport à Extra Boost.
La vidéo traite de la mise en œuvre des classificateurs d'amplification de gradient dans scikit-learn et présente un nouveau classificateur d'amplification de gradient qui a été ajouté dans une version récente de la bibliothèque. Le nouveau classificateur utilise un fractionnement basé sur l'histogramme inspiré de LightGBM, ce qui le rend plus rapide que le classificateur précédent. La vidéo suggère d'utiliser les deux classificateurs d'amplification de gradient et de les comparer avec XGBoost pour déterminer celui qui fonctionne le mieux. Des exemples de code sont fournis pour servir de modèles pour les projets de classe ou pour une utilisation générale, y compris la mise en œuvre du classificateur d'amplification de gradient dans scikit-learn et l'utilisation du nouveau classificateur d'amplification de gradient d'histogramme.
Le présentateur discute de l'amplification du gradient à l'aide des bibliothèques XGBoost et LightGBM. La bibliothèque XGBoost est similaire, mais un peu plus impliquée que scikit-learn. Cela nécessite de convertir les tableaux NumPy au format DMatrix, et au lieu d'utiliser la méthode fit, la méthode train est utilisée pour former le modèle. Des prédictions peuvent être faites en appelant la méthode predict pour obtenir des probabilités d'appartenance à une classe. D'autre part, la bibliothèque Microsoft LightGBM possède une API similaire à scikit-learn. Les hyperparamètres doivent être définis avant d'installer la machine d'amplification de gradient, et la méthode de score peut être utilisée pour calculer la précision. Dans le cas présenté, le modèle présente une précision d'entraînement de 100 % sans réglage des hyperparamètres.
La vidéo se termine en insistant sur l'efficacité des techniques de renforcement de gradient, notamment grâce à l'utilisation de bibliothèques telles que XGBoost et LightGBM. Ces bibliothèques fournissent des outils puissants pour implémenter des modèles d'amplification de gradient et offrent diverses optimisations pour améliorer les performances et la précision.
De plus, le présentateur reconnaît l'importance du réglage des hyperparamètres dans l'amplification du gradient. Différents hyperparamètres, tels que le taux d'apprentissage, le nombre d'arbres et la profondeur des arbres, peuvent avoir un impact significatif sur les performances du modèle. Par conséquent, il est recommandé d'expérimenter différentes configurations d'hyperparamètres pour trouver les paramètres optimaux pour un problème spécifique.
Pour explorer plus en détail le gradient boosting, la vidéo suggère de se référer à des articles de recherche et à de la documentation sur XGBoost, LightGBM et d'autres implémentations pertinentes. Ces ressources fournissent des explications détaillées sur les algorithmes, les techniques et les fonctionnalités avancées de l'amplification de gradient.
En résumé, la vidéo fournit un aperçu complet du gradient boosting, de ses concepts et de ses implémentations pratiques à l'aide de bibliothèques telles que XGBoost et LightGBM. Il met en évidence les avantages du gradient boosting, tels que sa capacité à gérer des ensembles de données tabulaires complexes, son efficacité dans les compétitions et son potentiel d'amélioration de la précision des prédictions. En comprenant les principes et les techniques derrière l'amplification de gradient, les praticiens peuvent tirer parti de ce puissant algorithme pour résoudre divers problèmes de régression et de classification.
7.6 Forêts aléatoires (L07 : méthodes d'ensemble)
7.6 Forêts aléatoires (L07 : méthodes d'ensemble)
Super! Nous avons enfin atteint la dernière partie de la leçon 5, qui se trouve être la plus intéressante : les pipelines d'apprentissage sacrés. Les pipelines d'apprentissage sacrés sont des objets ou des classes qui combinent diverses étapes de traitement et de prédiction de données, ce qui les rend extrêmement utiles dans les applications du monde réel. Pour vous aider à comprendre le fonctionnement des pipelines, examinons un organigramme. Je n'aborderai pas toutes les subtilités maintenant, mais nous y reviendrons peu de temps après avoir donné un exemple de pipeline.
Essentiellement, un pipeline peut être considéré comme une API d'estimateur et de transformateur. Semblable à un estimateur, un pipeline a une méthode d'ajustement qui peut être utilisée sur l'ensemble d'apprentissage. En interne, plusieurs étapes d'ajustement et de transformation sont effectuées, suivies d'une étape d'ajustement finale. Selon les composants inclus dans le pipeline, vous pouvez définir une séquence d'opérations telles que la mise à l'échelle des données (par exemple, la normalisation ou la mise à l'échelle min-max) ou la réduction de la dimensionnalité, suivie de l'apprentissage d'un algorithme d'apprentissage. Le pipeline renvoie ensuite un modèle prédictif qui peut être utilisé sur l'ensemble de test.
Pendant la phase de prédiction, lorsque vous appelez la méthode de prédiction sur le jeu de test, le pipeline utilise en interne la transformation pour appliquer la même mise à l'échelle que celle effectuée sur le jeu d'apprentissage. Il applique également l'étape de prédiction finale, telle que le retour des étiquettes de classe dans le cas d'un classifieur. Examinons un exemple de code simple d'un pipeline pour illustrer ce concept.
Ici, je crée un pipeline en utilisant la fonction make_pipeline du sous-module scikit-learn.dot.pipeline de Sacred Learn. Bien qu'il existe différentes façons de créer des pipelines, cette méthode est assez pratique. Dans cet exemple, je construis un pipeline simple composé d'un classificateur et d'un scaler standard. Le scaler standard, comme indiqué dans la vidéo précédente, normalise les données pour avoir une moyenne nulle et une variance unitaire. Après avoir créé le pipeline, nous pouvons utiliser la méthode d'ajustement pour former le pipeline sur les données de formation. Nous pouvons ensuite utiliser la méthode de prédiction pour faire des prédictions sur l'ensemble de test.
Maintenant, approfondissons le fonctionnement de la méthode d'ajustement dans le pipeline. Lorsque fit est appelée, la mise à l'échelle standard est appliquée en premier. Il apprend la moyenne et l'écart type des données d'apprentissage et les utilise pour mettre les données à l'échelle. Ce processus implique une étape d'ajustement et de transformation, où le scaler standard calcule les données mises à l'échelle et les transmet à l'étape suivante. Dans ce cas, l'étape suivante est le K classificateur le plus proche voisin. Le classificateur K voisin le plus proche reçoit les données normalisées, combinant efficacement ces quatre étapes en une seule. En appelant pipe.fit, toutes ces étapes sont effectuées automatiquement, ce qui nous évite d'avoir à les exécuter individuellement.
Pendant la phase de prédiction, le même processus se produit, sauf qu'il n'y a pas d'étape d'ajustement. Au lieu de cela, le pipeline réutilise les paramètres de l'ensemble de formation pour mettre à l'échelle les données de test, garantissant ainsi la cohérence. Il transmet ensuite les données de test mises à l'échelle au classifieur pour la prédiction.
Pour mieux visualiser ce processus, revoyons l'organigramme. En tant qu'utilisateur, il vous suffit d'utiliser les méthodes d'ajustement et de prédiction. En appelant fit, le pipeline invoque automatiquement l'étape de transformation. Il est important de noter que la convention dans les pipelines est d'avoir la dernière étape comme classificateur. Seule la dernière étape appelle fit, tandis que toutes les étapes précédentes appellent fit et transform. Par conséquent, un pipeline peut avoir plusieurs transformateurs, tels que le détartreur standard ou même des techniques de réduction de dimensionnalité comme l'analyse en composantes principales (PCA). Cependant, il ne peut avoir qu'un seul classificateur comme dernière étape. Cette conception garantit la compatibilité et la fonctionnalité du pipeline.
Pour illustrer le pipeline en action, explorons un scénario de sélection de modèle simple à l'aide de la méthode holdout. Veuillez noter qu'il ne s'agit que d'une démonstration de base et que nous aborderons des méthodes de sélection de modèles plus avancées telles que la validation croisée K-fold dans des conférences ultérieures.
La méthode d'exclusion consiste à diviser les données en deux sous-ensembles : un ensemble d'apprentissage et un ensemble de validation. L'ensemble de formation est utilisé pour former le pipeline, tandis que l'ensemble de validation est utilisé pour évaluer ses performances et sélectionner le meilleur modèle.
Voici un exemple d'implémentation de la méthode holdout avec un pipeline :
Ensuite, nous créons un pipeline à l'aide de make_pipeline et passons les étapes souhaitées. Dans ce cas, nous incluons un StandardScaler pour standardiser les données et un KNeighborsClassifier avec n_neighbors=3 comme classificateur.
Nous formons le pipeline en appelant la méthode fit sur les données de formation (X_train et y_train).
Après la formation, nous utilisons le pipeline pour faire des prédictions sur l'ensemble de validation (X_val) en appelant la méthode predict.
Enfin, nous évaluons la précision du pipeline en comparant les étiquettes prédites (y_pred) avec les vraies étiquettes (y_val) à l'aide de la fonction precision_score.
Il s'agit d'un exemple de base d'utilisation d'un pipeline avec la méthode holdout pour la sélection de modèle. Gardez à l'esprit qu'il existe des techniques plus avancées, telles que la validation croisée, qui peuvent fournir des évaluations plus robustes des performances du pipeline.
7.7 Empilement (L07 : Méthodes d'ensemble)
7.7 Empilement (L07 : Méthodes d'ensemble)
Ouais, ça a été une longue, longue conférence sept. Et enfin, nous arrivons à la dernière vidéo pour parler de stacking.
Tout au long de cette conférence, nous avons couvert beaucoup de terrain. Nous avons discuté du vote à la majorité et de l'ensachage, où nous avons ajusté des arbres de décision sur des échantillons bootstrap. Nous avons également couvert le boosting, où nous adaptons les apprenants profonds en fonction des erreurs ou des erreurs des apprenants précédents, ainsi que des résidus et du gradient boosting. De plus, nous avons exploré les forêts aléatoires, qui améliorent les performances par rapport à l'ensachage régulier en utilisant des sous-ensembles de fonctionnalités aléatoires à chaque nœud. Et maintenant, nous allons enfin parler d'empilement.
L'empilement est similaire au vote à la majorité, mais avec un méta-classificateur combinant les prédictions d'autres classificateurs au lieu de simplement faire un vote à la majorité. Plongeons-nous dans les détails de l'empilement.
Avant de poursuivre, permettez-moi de vous rappeler le sujet de cette vidéo : l'empilement. Je m'excuse pour la diapositive inutile, mais concentrons-nous sur les bases de l'algorithme d'empilement proposé par David H. Wolpert dans son article intitulé "Stacked Generalization" publié en 1992. Bien qu'il s'agisse d'un ancien article, la notation utilisée dans un livre plus récent, je le référencement facilite la compréhension. Alors, commençons par cette version de base de l'empilement.
Dans cet algorithme, nous définissons l'entrée et la sortie, ce qui pose le problème. Nous travaillons avec un ensemble de données d'entraînement de taille 'n.' Chaque vecteur caractéristique, désigné par 'x_i', est un vecteur 'm'-dimensionnel. De même, les étiquettes de classe correspondant aux exemples de formation sont désignées par "y_i". La sortie de cet algorithme est un classificateur d'ensemble, que nous appellerons le deuxième classificateur.
Maintenant, concentrons-nous sur les étapes impliquées dans l'empilement. La première étape consiste à apprendre les classificateurs de premier niveau. Nous utilisons une boucle de un à 't' pour ajuster ces classificateurs. Nous avons donc une collection de classificateurs, notés "h_1" à "h_t", qui sont entraînés sur les données d'entrée "X" et les étiquettes de classe "Y".
Passant à la deuxième étape, nous construisons de nouveaux ensembles de données à partir de l'ensemble d'apprentissage. Pour chaque exemple d'entraînement "x_i", nous créons un nouvel ensemble de données contenant le vecteur de caractéristiques modifié "x_i prime". Le vecteur de caractéristiques modifié, 'x_i prime,' contient les prédictions des classificateurs de premier niveau. Ces prédictions peuvent être les étiquettes de classe ou même les probabilités d'appartenance à la classe. En utilisant ces prédictions, nous pouvons effectuer un vote à la majorité, similaire à ce dont nous avons discuté précédemment. Cependant, nous ne nous arrêtons pas là; nous passons à la troisième étape.
À la troisième étape, au lieu d'effectuer un vote à la majorité, nous apprenons un classificateur de second niveau basé sur les prédictions des classificateurs de premier niveau. 'x_i prime' représente une matrice de conception modifiée, où chaque colonne contient les prédictions des classificateurs 'h_1' à 'h_t.' Nous pouvons ajuster un classificateur sur ces prédictions, en tenant compte soit des étiquettes de classe, soit des probabilités d'appartenance à la classe. Ce classifieur de second niveau sera entraîné sur ces prédictions.
Une faiblesse de la procédure d'empilement de base est sa susceptibilité au surajustement. Si l'un des classificateurs de premier niveau sur-ajuste l'ensemble d'apprentissage, cela pourrait avoir un impact négatif sur les performances du méta-classificateur et conduire à un sur-ajustement général du système. Pour résoudre ce problème, nous pouvons améliorer la procédure d'empilement en incorporant la validation croisée.
La validation croisée est une technique dans laquelle nous divisons l'ensemble de données en plusieurs sous-ensembles et entraînons le modèle sur différentes combinaisons de ces sous-ensembles. Cela aide à réduire le surajustement et à obtenir une estimation de performance plus fiable. Une variante couramment utilisée est la validation croisée k-fold, où l'ensemble de données est divisé en «k» sous-ensembles ou plis. Nous formons le modèle sur les plis 'k-1' et évaluons ses performances sur le pli restant. Ce processus est répété 'k' fois, en utilisant à chaque fois un pli différent comme ensemble de validation. Les résultats de performance de chaque pli peuvent ensuite être moyennés pour obtenir une estimation plus robuste des performances du modèle.
Dans le cadre de l'empilement, nous pouvons utiliser la validation croisée pour améliorer l'entraînement des classificateurs de premier niveau. Au lieu de les entraîner sur l'intégralité de l'ensemble d'entraînement, nous divisons les données en plis k. Pour chaque pli, nous entraînons les classificateurs de premier niveau sur les plis « k-1 » restants et les utilisons pour faire des prédictions sur le pli qui a été omis. Ce processus est répété pour chaque pli, ce qui donne des prédictions pour l'ensemble de l'apprentissage.
Une fois que nous avons les prédictions des classificateurs de premier niveau pour l'ensemble de la formation, nous pouvons passer à la troisième étape de l'algorithme d'empilement, où nous formons le classificateur de deuxième niveau sur ces prédictions. En incorporant la validation croisée, nous nous assurons que le classificateur de deuxième niveau est formé sur des prédictions diverses et fiables des classificateurs de premier niveau, réduisant ainsi le risque de surajustement.
Après avoir formé le classificateur de second niveau, nous pouvons l'utiliser pour faire des prédictions sur de nouvelles données inédites. Les prédictions sont généralement obtenues en faisant passer l'entrée par les classificateurs de premier niveau pour obtenir leurs prédictions, puis en utilisant ces prédictions comme entrées pour le classificateur de second niveau. La sortie du classificateur de second niveau représente la prédiction finale de l'ensemble d'empilement.
L'empilement est une technique d'apprentissage d'ensemble puissante qui exploite les points forts de plusieurs classificateurs pour améliorer les performances globales. En combinant les prédictions de plusieurs classificateurs, l'empilement peut capturer différents aspects des données et faire des prédictions plus précises. Il s'agit d'une technique flexible et polyvalente qui peut être adaptée à différents domaines de problèmes et types de classificateurs.
En conclusion, l'empilement est une méthode d'apprentissage d'ensemble qui va au-delà du simple vote à la majorité. Il combine les prédictions de plusieurs classificateurs via un méta-classificateur de second niveau, permettant une prise de décision plus sophistiquée. En incorporant la validation croisée, nous pouvons améliorer la robustesse et la capacité de généralisation de l'algorithme d'empilement. L'empilement est un outil précieux dans l'apprentissage automatique et a été largement utilisé dans diverses applications pour améliorer les performances de prédiction.