[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.

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.

image.png

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 $.

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 $.

\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.

image.png 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.

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.

image.png

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.

Recommended Posts

[Apprentissage automatique] J'ai essayé de résumer la théorie d'Adaboost
J'ai essayé de résumer la forme de base de GPLVM
J'ai essayé de compresser l'image en utilisant l'apprentissage automatique
J'ai essayé de résumer les opérations de chaîne de Python
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Introduction ~
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Implémentation ~
J'ai essayé de prédire la présence ou l'absence de neige par apprentissage automatique.
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Battle Edition ~
J'ai essayé de résumer la commande umask
[Linux] J'ai essayé de résumer les commandes de confirmation des ressources
J'ai essayé de résumer la méthode de mise en œuvre fréquemment utilisée de pytest-mock
J'ai essayé de vérifier la classification yin et yang des membres hololive par apprentissage automatique
J'ai essayé de corriger la forme trapézoïdale de l'image
LeetCode j'ai essayé de résumer les plus simples
J'ai essayé de vectoriser les paroles de Hinatazaka 46!
J'ai essayé d'appeler l'API de prédiction du modèle d'apprentissage automatique de WordPress
J'ai essayé de résumer la manière logique de penser l'orientation objet.
J'ai essayé de visualiser le modèle avec la bibliothèque d'apprentissage automatique low-code "PyCaret"
J'ai essayé l'histoire courante de l'utilisation du Deep Learning pour prédire la moyenne Nikkei
J'ai essayé de bien le comprendre en implémentant l'algorithme Adaboost en machine learning (+ j'ai approfondi ma compréhension du calcul de tableaux)
J'ai essayé de résumer SparseMatrix
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
J'ai essayé de résumer comment utiliser matplotlib de python
J'ai essayé de visualiser les informations spacha de VTuber
J'ai essayé d'effacer la partie négative de Meros
J'ai essayé de classer les voix des acteurs de la voix
J'ai essayé de prédire l'évolution de la quantité de neige pendant 2 ans par apprentissage automatique
J'ai essayé de traiter et de transformer l'image et d'élargir les données pour l'apprentissage automatique
Je n'ai pas compris le redimensionnement de TensorFlow, alors je l'ai résumé visuellement.
[Courses de chevaux] J'ai essayé de quantifier la force du cheval de course
[Première API COTOHA] J'ai essayé de résumer l'ancienne histoire
J'ai essayé d'obtenir les informations de localisation du bus Odakyu
Essayez d'évaluer les performances du modèle d'apprentissage automatique / de régression
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai essayé l'apprentissage automatique avec liblinear
Essayez d'évaluer les performances du modèle d'apprentissage automatique / de classification
J'ai essayé de résumer le code souvent utilisé dans Pandas
J'ai essayé l'apprentissage automatique pour convertir des phrases en style XX
Comment augmenter le nombre d'images de jeux de données d'apprentissage automatique
[Python] J'ai essayé de visualiser la relation de suivi de Twitter
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
J'ai essayé de résumer les commandes souvent utilisées en entreprise
J'ai essayé de comprendre attentivement la fonction d'apprentissage dans le réseau de neurones sans utiliser la bibliothèque d'apprentissage automatique (première moitié)
J'ai essayé de combattre le minimum local de la fonction Goldstein-Price
J'ai essayé de déplacer le ballon
J'ai essayé d'estimer la section.
J'ai essayé de résumer comment utiliser à nouveau le référentiel EPEL
Application correspondante, j'ai essayé de prendre des statistiques de personnes fortes et j'ai essayé de créer un modèle d'apprentissage automatique
J'ai essayé d'obtenir l'index de la liste en utilisant la fonction énumérer
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
J'ai essayé de créer l'image de démarrage SD de LicheePi Nano
J'ai essayé de résumer les commandes utilisées par les ingénieurs débutants aujourd'hui
Comment utiliser l'apprentissage automatique pour le travail? 01_ Comprendre l'objectif de l'apprentissage automatique
J'ai essayé d'agrandir la taille du volume logique avec LVM
[Apprentissage automatique] J'ai essayé de faire quelque chose comme passer des images
J'ai essayé d'améliorer l'efficacité du travail quotidien avec Python
J'ai essayé de visualiser la condition commune des téléspectateurs de la chaîne VTuber
J'ai essayé de résumer la gestion des exceptions Python