[PYTHON] [Apprentissage automatique] J'ai essayé de résumer la théorie d'Adaboost

introduction

Cette fois, je résumerai la théorie d'Adaboost dans l'apprentissage d'ensemble.

Il y a beaucoup de termes dans ce domaine, donc je vais d'abord expliquer les termes utilisés pour l'apprentissage d'ensemble.

La théorie d'AdaBoost sera résumée plus tard, donc si vous voulez la voir rapidement, veuillez la sauter.

Les articles suivants ont été très utiles pour rédiger cet article.

Apprentissage automatique ⑤ Résumé AdaBoost

Explication détaillée du boosting et AdaBoost

Premier renforcement de la reconnaissance des formes Chapitre 11

J'ai fait des recherches sur Ada Boost, je vais donc le résumer

Faisons de notre mieux.

Qu'est-ce que l'apprentissage d'ensemble?

L'apprentissage d'ensemble est une technique qui tente d'obtenir de meilleures prédictions en combinant plusieurs machines d'apprentissage.

Dans de nombreux cas, vous obtiendrez de meilleurs résultats que d'utiliser un seul modèle.

Quant à la manière de combiner plusieurs apprenants, dans le cas de la classification, la «décision majoritaire» de plusieurs apprenants est prise, et dans le cas de la régression, la «moyenne» de plusieurs apprenants est prise.

Les techniques couramment utilisées dans l'apprentissage d'ensemble comprennent le «ensachage», le «renforcement», «l'empilement» et le «bumping».

On peut dire que la forêt aléatoire est un apprentissage d'ensemble utilisant un "arbre de décision" en tant qu'apprenant utilisant une technique appelée ensachage.

Beaucoup de termes sont sortis et c'est devenu difficile à comprendre. J'expliquerai chaque technique.

À propos de l'ensachage

Bagging est une abréviation pour l'agrégation bootstrap.

À l'aide d'une technique appelée boost trap, créez plusieurs ensembles de données à partir d'un ensemble de données, générez un apprenant pour chaque ensemble de données dupliqué et prenez une décision majoritaire sur les multiples apprenants créés de cette manière. Cela fera la prédiction finale.

Boost trap est une méthode d'échantillonnage de n données à partir d'un ensemble de données, permettant la duplication.

Soit l'ensemble de données $ S_0 = (d_1, d_2, d_3, d_4, d_5) $, et lors de l'échantillonnage n = 5 données, $ S_1 = (d_1, d_1, d_3, d_4, d_5) $ ou $ S_2 = Vous allez créer un ensemble de données tel que (d_2, d_2, d_3, d_4, d_5) $.

Comme vous pouvez le voir, vous pouvez utiliser des traps de boost pour créer de nombreux ensembles de données différents à partir d'un ensemble de données.

Considérons la valeur prédite avec un exemple concret.

Générez N ensembles de données d'interruption d'amplification de taille n à partir de l'ensemble de données d'entraînement.

Créez N modèles de prédiction en utilisant ces données, et laissez chaque valeur de prédiction être $ y_n (X) $.

Puisque la moyenne de ces N valeurs prédites est la valeur prédite finale, la valeur prédite finale du modèle utilisant l'ensachage est la suivante.

y(X) = \frac{1}{N}\sum_{n=1}^{N}y_n(X)

C'est la fin de l'explication de l'ensachage. Ensuite, regardons la stimulation.

À propos du boosting

En boostant, les apprenants faibles sont construits un par un dans l'ordre, au lieu de faire des apprenants faibles indépendamment comme dans l'ensachage. À ce moment-là, le k + 1e apprenant faible est construit sur la base du ke apprenant faible (pour compenser la faiblesse).

Contrairement à l'ensachage, qui génère indépendamment des apprenants faibles, le renforcement, qui vous oblige à générer des apprenants faibles un par un, prend du temps. Au lieu de cela, le boost a tendance à être plus précis que l'ensachage.

Empilement

Pour l'ensachage, nous avons considéré une simple moyenne de N valeurs prédites.

Cet algorithme évalue les prédictions individuelles de manière égale et ne prend pas en compte l'importance de chaque modèle.

L'empilement ajoute des poids aux valeurs prédites individuelles en fonction de leur importance pour obtenir la valeur prédite finale.

Il est exprimé par la formule suivante.

y(X) = \sum_{n=1}^{N}W_ny_n(X)

Cogner

Le bumping est une technique permettant de trouver le meilleur modèle d'ajustement parmi plusieurs apprenants.

Générez N modèles à l'aide de l'ensemble de données d'interruption d'amplification, appliquez l'apprenant créé à l'aide de celui-ci aux données d'origine et sélectionnez celui avec la plus petite erreur de prédiction comme meilleur modèle.

Cela peut sembler une méthode moins bénéfique, mais cela évite d'apprendre avec des données de mauvaise qualité.

À propos de la théorie d'Ada Boost

Parlons maintenant de la théorie d'Ada Boost.

AdaBoost et le boosting de gradient sont tous deux un type de boost, ce sont donc des algorithmes qui génèrent séquentiellement des apprenants faibles.

Il est grossièrement divisé en quatre fonctionnalités.

• Utiliser des ensembles de données pondérés pour former les apprenants faibles

• Donne un poids important aux points de données mal classés par la machine d'apprentissage précédente

• Donner au départ le même poids à toutes les données

• Sortie de la valeur finale prévue en combinant les machines d'apprentissage faibles générées et entraînées de cette manière

De cette manière, AdaBoost peut être considéré comme un algorithme qui tente d'améliorer le système en mettant l'accent sur les données mal classées.

L'image est la suivante.

extracted from Alexander Ihler's youtube video

Voyons maintenant comment donner du poids aux données mal classées à l'aide de formules mathématiques.

Je vais vous l'expliquer aussi facilement que possible, alors faites de votre mieux.

Prenons le cas de la génération de M apprenants faibles pour classer N données.

Le résultat final de la machine d'apprentissage forte est le suivant.

H(x) = sign(\sum_{m=1}^{M}α_my_m(x))

sign est appelé une fonction de signe et est une fonction qui renvoie -1 si l'argument est inférieur à 0 et 1 si l'argument est supérieur à 0. $ y_m (x) $ est l'apprenant faible, et $ α_m $ est le poids de chaque apprenant faible.

En d'autres termes, l'apprenant faible est pondéré et additionné, et si la somme est supérieure à 0, 1 est renvoyé, et si elle est inférieure à 0, -1 est renvoyé, qui est le résultat final. Voyons maintenant comment nous déterminons $ y_m (x) $ et $ α_m $.

Détermination de y et α

Puisque des poids pairs sont donnés aux premières données, le coefficient de poids {$ W_n $} des données de $ n = 1,2,3, ..., N $ est $ w_n ^ {(1)} = \ frac Initialisez à {1} {N} $.

La partie inférieure droite de w est le numéro de données et la partie supérieure droite de w est le numéro de machine d'apprentissage faible. En d'autres termes, chez le premier apprenant faible, le poids de toutes les données est $ \ frac {1} {N} $.

Répétez les opérations suivantes pour toutes les machines d'apprentissage $ m = 1,2,3, ... M $.

• Définissez ce qui suit comme une fonction d'erreur et réduisez-le.

J_m = \sum_{n=1}^{N}w_n^{(m)}I(y_m(x_n)\neq t_n)

$ w_n ^ {(m)} $ est le poids dans la nième donnée du mième apprenant faible.

$ I $ est appelé une fonction de support et renvoie 1 lorsque $ y_m (x_n) \ neq t_n $, c'est-à-dire lorsque la valeur prédite et le libellé de réponse correct dans une donnée ne correspondent pas, et $ y_m (x_n) = t_n $ Lorsque, c'est-à-dire, lorsque la valeur prédite et l'étiquette de réponse correcte dans une certaine donnée correspondent, 0 est renvoyé.

En d'autres termes, $ J_m $ est la somme des poids des points de données qui ont fait une erreur de prédiction dans une machine d'apprentissage faible $ m $.

• Calculer α en utilisant la formule suivante

\epsilon_m = \frac{\sum_{n=1}^{N}w_n^{(m)}I(y_m(x_n)\neq t_n)}{\sum_{n=1}^{N}w_n^(m)}

\alpha_m = ln \bigl(\frac{1-\epsilon_m}{\epsilon_m} \bigr)

Le dénominateur de $ \ epsilon_m $ est la somme des poids des données dans l'apprenant faible $ m $, et la molécule est la somme des poids des points de données mal prédits chez un apprenant faible $ m $.

En d'autres termes, $ \ epsilon_m $ peut être considéré comme le taux d'erreur exprimé en poids.

Il est illustré ci-dessous.

La formule suivante était le résultat final.

H(x) = sign(\sum_{m=1}^{M}α_my_m(x))

En d'autres termes, le poids de l'apprenant avec un taux d'erreur élevé ($ \ epsilon_m $ est grand) $ \ alpha_m $ est négatif, et le poids de l'apprenant avec un taux d'erreur faible ($ \ epsilon_m $ est petit) est positif et additionné. Si est une valeur positive, $ H (x) = 1 $, et si la somme est une valeur négative, $ H (x) = 0 $ est la sortie finale.

• Mettre à jour les poids des points de données

Mettez à jour le poids du point de données avec la formule suivante.

w_n^{(m + 1)} = w_n^{(m)}exp \bigl(\alpha_mI(y_m(x) \neq t_n) \bigr)

Si la valeur prédite des données $ n $ th dans l'apprenant faible $ m $ correspond à l'étiquette de réponse correcte, les données ne sont pas mises à jour, et seulement si la valeur prédite et l'étiquette de réponse correcte sont différentes, $ exp (\ alpha_m) $ Multipliez pour mettre à jour le poids.

La relation entre $ \ alpha $ et $ exp (\ alpha_m) $ est illustrée ci-dessous.

Sur une machine d'apprentissage avec un taux d'erreur élevé $ \ epsilon_m $, $ \ alpha_m $ sera plus petit, donc $ w ^ {(m + 1)} $ sera plus petit.

Sur un apprenant avec un faible taux d'erreur de $ \ epsilon_m $, c'est-à-dire un apprenant précis, $ \ alpha_m $ sera grand, donc $ w ^ {(m + 1)} $ sera grand.

En d'autres termes, en résumé, dans une machine d'apprentissage précise, le poids des mauvaises données est augmenté et transmis à la machine d'apprentissage suivante, et dans une machine d'apprentissage inexacte, le poids des mauvaises données est réduit et la prochaine machine d'apprentissage Sera transmis à.

Ce qui précède est la théorie d'Ada Boost.

À la fin

Merci d'avoir lu jusqu'ici.

Si vous en avez envie, je voudrais résumer la mise en œuvre.