Les méthodes d'ensemble sont des techniques qui créent plusieurs modèles, puis les combinent pour produire de meilleurs résultats. Les méthodes d'ensemble produisent généralement des solutions plus précises qu'un modèle unique. Cela a été le cas dans un certain nombre de concours d'apprentissage automatique, où les solutions gagnantes ont utilisé des méthodes d'ensemble. Dans le populaire concours Netflix, le gagnant a utilisé une méthode d'ensemble pour implémenter un puissant algorithme de filtrage collaboratif. Un autre exemple est KDD 2009 où le gagnant a également méthodes d'ensemble utilisées . Vous pouvez également trouver des gagnants qui ont utilisé ces méthodes dans les concours Kaggle, par exemple Ici est l'entretien avec le gagnant de Concours CrowdFlower .

Il est important que nous comprenions quelques terminologies avant de continuer avec cet article. Tout au long de l'article, j'ai utilisé le terme «modèle» pour décrire la sortie de l'algorithme qui s'est entraîné avec des données. Ce modèle est ensuite utilisé pour faire des prédictions. Cet algorithme peut être n'importe quel apprentissage automatique algorithme tel que régression logistique, arbre de décision, etc. Ces modèles, lorsqu'ils sont utilisés comme entrées de méthodes d'ensemble, sont appelés «modèles de base».

Dans cet article de blog, je couvrirai les méthodes d'ensemble pour la classification et décrirai quelques méthodes d'ensemble largement connues: vote, empilement, ensachage et boosting.

Méthodes d'ensemble basées sur le vote et la moyenne

Le vote et la moyenne sont deux des méthodes d'ensemble les plus simples. Ils sont tous deux faciles à comprendre et à mettre en œuvre. Le vote est utilisé pour la classification et la moyenne est utilisée pour la régression.

Dans les deux méthodes, la première étape consiste à créer plusieurs modèles de classification / régression à l'aide d'un ensemble de données d'entraînement. Chaque modèle de base peut être créé en utilisant différentes divisions du même jeu de données d'apprentissage et du même algorithme, ou en utilisant le même jeu de données avec différents algorithmes, ou toute autre méthode. Le pseudocode Python-esque suivant montre l'utilisation du même jeu de données d'entraînement avec différents algorithmes.

Meilleures pratiques en matière d'architecture d'applications Android

train = load_csv('train.csv') target = train['target'] train = train.drop('target') test = load_csv('test.csv') algorithms = [logistic_regression, decision_tree_classification, ...] #for classification algorithms = [linear_regression, decision_tree_regressor, ...] #for regression predictions = matrix(row_length=len(target), column_length=len(algorithms)) for i,algorithm in enumerate(algorithms): predictions[,i] = algorithm.fit(train, target).predict(test)

Selon le pseudocode ci-dessus, nous avons créé des prédictions pour chaque modèle et les avons sauvegardées dans une matrice appelée prédictions où chaque colonne contient des prédictions d'un modèle.

Vote majoritaire

Chaque modèle fait une prédiction (votes) pour chaque instance de test et la prédiction de sortie finale est celle qui reçoit plus de la moitié des votes. Si aucune des prédictions n'obtient plus de la moitié des votes, on peut dire que la méthode d'ensemble ne pourrait pas faire une prédiction stable pour cette instance. Bien que ce soit une technique largement utilisée, vous pouvez essayer la prédiction la plus votée (même si cela représente moins de la moitié des votes) comme prédiction finale. Dans certains articles, cette méthode peut être appelée «vote à la pluralité».

Vote pondéré

Contrairement au vote majoritaire, où chaque modèle a les mêmes droits, nous pouvons augmenter l'importance d'un ou plusieurs modèles. Dans le vote pondéré, vous comptez plusieurs fois la prédiction des meilleurs modèles. Il vous appartient de trouver un ensemble de poids raisonnable.

Moyenne simple

Dans la méthode de calcul de moyenne simple, pour chaque instance de l'ensemble de données de test, les prévisions moyennes sont calculées. Cette méthode réduit souvent le surajustement et crée un modèle de régression plus fluide. Le code de pseudocode suivant montre cette méthode de calcul de moyenne simple:

final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]) )

Moyenne pondérée

La moyenne pondérée est une version légèrement modifiée de la moyenne simple, où la prédiction de chaque modèle est multipliée par le poids, puis leur moyenne est calculée. Le code de pseudocode suivant montre la moyenne pondérée:

weights = [..., ..., ...] #length is equal to len(algorithms) final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]*weights) )

Empilement de plusieurs modèles d'apprentissage automatique

L'empilement, également connu sous le nom de généralisation empilée, est une méthode d'ensemble où les modèles sont combinés à l'aide d'un autre apprentissage automatique algorithme. L'idée de base est de former des algorithmes d'apprentissage automatique avec un ensemble de données d'entraînement, puis de générer un nouvel ensemble de données avec ces modèles. Ensuite, ce nouvel ensemble de données est utilisé comme entrée pour l'algorithme d'apprentissage automatique du combineur.

comment créer une application pour les enfants

Le pseudocode d'une procédure d'empilement est résumé comme suit:

base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): stacking_train_dataset[,i] = base_algorithm.fit(train, target).predict(train) stacking_test_dataset[,i] = base_algorithm.predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Comme vous pouvez le voir dans le pseudocode ci-dessus, le jeu de données d'apprentissage pour l'algorithme de combinaison est généré à l'aide des sorties des algorithmes de base. Dans le pseudocode, l'algorithme de base est généré à l'aide de l'ensemble de données d'entraînement, puis le même ensemble de données est utilisé à nouveau pour faire des prédictions. Mais comme nous le savons, dans le monde réel, nous n'utilisons pas le même jeu de données d'entraînement pour la prédiction, donc pour surmonter ce problème, vous pouvez voir certaines implémentations de l'empilement où le jeu de données d'entraînement est divisé. Ci-dessous, vous pouvez voir un pseudocode où le jeu de données d'entraînement est divisé avant d'entraîner les algorithmes de base:

mise en place d'un plan comptable

base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): for trainix, testix in split(train, k=10): #you may use sklearn.cross_validation.KFold of sklearn library stacking_train_dataset[testcv,i] = base_algorithm.fit(train[trainix], target[trainix]).predict(train[testix]) stacking_test_dataset[,i] = base_algorithm.fit(train).predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Agrégation Bootstrap

Le nom Bootstrap Aggregating, également appelé «Bagging», résume les éléments clés de cette stratégie. Dans l'algorithme d'ensachage, la première étape consiste à créer plusieurs modèles. Ces modèles sont générés à l'aide du même algorithme avec des sous-échantillons aléatoires de l'ensemble de données qui sont tirés de l'ensemble de données d'origine de manière aléatoire avec la méthode d'échantillonnage bootstrap. Dans l'échantillonnage bootstrap, certains exemples originaux apparaissent plusieurs fois et certains exemples originaux ne sont pas présents dans l'échantillon. Si vous souhaitez créer un sous-ensemble de données avec m éléments, vous devez sélectionner un élément aléatoire dans l'ensemble de données d'origine m fois. Et si l'objectif est de générer n ensemble de données, vous suivez cette étape n fois.

À la fin, nous avons n ensembles de données où le nombre d'éléments dans chaque ensemble de données est m. Le pseudocode Python-esque suivant montre un échantillonnage bootstrap:

def bootstrap_sample(original_dataset, m): sub_dataset = [] for i in range(m): sub_dataset.append( random_one_element(original_dataset) ) return sub_dataset

La deuxième étape de l'ensachage consiste à regrouper les modèles générés. Des méthodes bien connues, telles que le vote et la moyenne, sont utilisées à cette fin.

Le pseudocode global ressemble à ceci:

def bagging(n, m, base_algorithm, train_dataset, target, test_dataset): predictions = matrix(row_length=len(target), column_length=n) for i in range(n): sub_dataset = bootstrap_sample(train_dataset, m) predictions[,i] = base_algorithm.fit(original_dataset, target).predict(test_dataset) final_predictions = voting(predictions) # for classification final_predictions = averaging(predictions) # for regression return final_predictions

Lors de l'ensachage, chaque sous-échantillon peut être généré indépendamment les uns des autres. La génération et la formation peuvent donc se faire en parallèle.

Vous pouvez également trouver la mise en œuvre de la stratégie d'ensachage dans certains algorithmes. Par exemple, Forêt aléatoire L'algorithme utilise la technique d'ensachage avec quelques différences. Random Forest utilise une sélection aléatoire de caractéristiques, et son algorithme de base est un algorithme d'arbre de décision.

En relation: Un tutoriel d'apprentissage en profondeur: des perceptrons aux réseaux profonds

Boosting: Conversion de modèles faibles en modèles forts

Le terme «boosting» est utilisé pour décrire une famille d'algorithmes capables de convertir des modèles faibles en modèles forts. Le modèle est faible s'il a un taux d'erreur important, mais la performance n'est pas aléatoire (ce qui entraîne un taux d'erreur de 0,5 pour la classification binaire). Boosting construit de manière incrémentielle un ensemble en entraînant chaque modèle avec le même jeu de données, mais où les poids des instances sont ajustés en fonction de l'erreur de la dernière prédiction. L'idée principale est de forcer les modèles à se concentrer sur les instances qui sont difficiles. Contrairement à l'ensachage, le boosting est une méthode séquentielle, et vous ne pouvez donc pas utiliser d'opérations parallèles ici.

La procédure générale de l'algorithme d'amplification est définie comme suit:

def adjust_dataset(_train, errors): #create a new dataset by using the hardest instances ix = get_highest_errors_index(train) return concat(_train[ix], random_select(train)) models = [] _train = random_select(train) for i in range(n): #n rounds model = base_algorithm.fit(_train) predictions = model.predict(_train) models.append(model) errors = calculate_error(predictions) _train = adjust_dataset(_train, errors) final_predictions = combine(models, test)

La fonction Adjust_dataset renvoie un nouvel ensemble de données contenant les instances les plus difficiles, qui peuvent ensuite être utilisées pour forcer l'algorithme de base à apprendre.

technologie et avenir des applications de l'histoire de la réalité virtuelle

Adaboost est un algorithme largement connu qui est une méthode de stimulation. Les fondateurs d'Adaboost ont remporté le Prix ​​Gödel pour leur travail. Généralement, l'algorithme d'arbre de décision est préféré comme algorithme de base pour Adaboost et dans la bibliothèque sklearn, l'algorithme de base par défaut pour Adaboost est l'arbre de décision ( AdaBoostRegressor et AdaBoostClassifier ). Comme nous l'avons vu dans le paragraphe précédent, la même méthode incrémentielle s'applique à Adaboost. Les informations recueillies à chaque étape de l’algorithme AdaBoost sur la «dureté» de chaque échantillon d’apprentissage sont introduites dans le modèle. L'étape «d'ajustement de l'ensemble de données» est différente de celle décrite ci-dessus et l'étape de «combinaison de modèles» est calculée en utilisant le vote pondéré.

Conclusion

Bien que les méthodes d'ensemble puissent vous aider à gagner des concours d'apprentissage automatique en concevant des algorithmes sophistiqués et en produisant des résultats avec une grande précision, elles ne sont souvent pas préférées dans les industries où l'interprétabilité est plus importante. Néanmoins, l'efficacité de ces méthodes est indéniable et leurs avantages dans des applications appropriées peuvent être énormes. Dans des domaines tels que la santé, même la plus petite amélioration de la précision des algorithmes d'apprentissage automatique peut être quelque chose de vraiment précieux.

En relation:

• Une introduction à la théorie de l'apprentissage automatique et à ses applications: un didacticiel visuel avec des exemples
• Machines et confiance: comment atténuer le biais de l'IA