Python Tutorial

Python Machine Learning – Agrégation Bootstrap (Bagging)


Sur cette page, Infodewi.com collabore avec
Académie des sciences des données de NYC
pour délivrer des contenus de formation numériques à nos étudiants.


Ensachage

Des méthodes telles que les arbres de décision peuvent être sujettes à un surajustement de l’ensemble d’apprentissage, ce qui peut entraîner de mauvaises prédictions sur de nouvelles données.

Bootstrap Aggregation (bagging) est une méthode d’assemblage qui tente de résoudre le surajustement pour les problèmes de classification ou de régression. Le bagging vise à améliorer la précision et les performances des algorithmes d’apprentissage automatique. Pour ce faire, il prend des sous-ensembles aléatoires d’un ensemble de données d’origine, avec remplacement, et adapte soit un classificateur (pour la classification) soit un régresseur (pour la régression) à chaque sous-ensemble. Les prédictions pour chaque sous-ensemble sont ensuite agrégées par vote majoritaire pour la classification ou la moyenne pour la régression, ce qui augmente la précision des prédictions.


Évaluation d’un classificateur de base

Pour voir comment le bagging peut améliorer les performances du modèle, nous devons commencer par évaluer les performances du classificateur de base sur l’ensemble de données. Si vous ne savez pas ce que sont les arbres de décision, revoyez la leçon sur les arbres de décision avant d’aller plus loin, car l’ensachage est une continuation du concept.

Nous chercherons à identifier différentes classes de vins trouvées dans l’ensemble de données sur les vins de Sklearn.

Commençons par importer les modules nécessaires.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.tree import DecisionTreeClassifier

Ensuite, nous devons charger les données et les stocker dans X (entités d’entrée) et y (cible). Le paramètre as_frame est égal à True afin de ne pas perdre les noms des fonctionnalités lors du chargement des données. (sklearn version antérieure à 0.23 doit ignorer le
as_frame argument car il n’est pas pris en charge)

data = datasets.load_wine(as_frame = True)

X = données.données
y = données.cible

Afin d’évaluer correctement notre modèle sur des données invisibles, nous devons diviser X et y en ensembles d’apprentissage et de test. Pour plus d’informations sur le fractionnement des données, consultez la leçon Apprentissage/Test.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 22)

Une fois nos données préparées, nous pouvons maintenant instancier un classificateur de base et l’adapter aux données d’apprentissage.

dtree = DecisionTreeClassifier(random_state = 22)
dtree.fit(X_train,y_train)

Résultat:

DecisionTreeClassifier(random_state=22)

Nous pouvons maintenant prédire la classe de vin de l’ensemble de test invisible et évaluer les performances du modèle.

y_pred = dtree.predict(X_test)

print(“Précision des données de train :”,accuracy_score(y_true = y_train, y_pred = dtree.predict(X_train)))
print(“Tester la précision des données :”,accuracy_score(y_true = y_test, y_pred = y_pred))

Résultat:

Train data accuracy: 1.0
Test data accuracy: 0.8222222222222222

Exemple

Importez les données nécessaires et évaluez les performances du classificateur de base.

à partir d’ensembles de données d’importation sklearn
depuis sklearn.model_selection importer train_test_split
depuis sklearn.metrics importer precision_score
depuis sklearn.tree importer DecisionTreeClassifier

data = datasets.load_wine(as_frame = True)

X = données.données
y = données.cible

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 22)

dtree = DecisionTreeClassifier (random_state = 22)
dtree.fit(X_train,y_train)

y_pred = dtree.predict(X_test)

print(“Précision des données de train :”,accuracy_score(y_true = y_train, y_pred = dtree.predict(X_train)))
print(“Tester la précision des données :”,accuracy_score(y_true = y_test, y_pred = y_pred))

Exemple d’exécution »

Le classificateur de base fonctionne raisonnablement bien sur l’ensemble de données, atteignant une précision de 82 % sur l’ensemble de données de test avec les paramètres actuels (des résultats différents peuvent se produire si vous n’avez pas le random_state jeu de paramètres).

Maintenant que nous avons une précision de base pour l’ensemble de données de test, nous pouvons voir comment le classificateur d’ensachage effectue un seul classificateur d’arbre de décision.


PUBLICITÉ


Création d’un classificateur d’ensachage

Pour le bagging, nous devons définir le paramètre n_estimators, c’est le nombre de classificateurs de base que notre modèle va agréger ensemble.

Pour cet échantillon de données, le nombre d’estimateurs est relativement faible, il arrive souvent que des plages beaucoup plus larges soient explorées. Le réglage des hyperparamètres est généralement effectué avec une recherche de grille, mais pour l’instant, nous utiliserons un ensemble sélectionné de valeurs pour le nombre d’estimateurs.

Nous commençons par importer le modèle nécessaire.

from sklearn.ensemble import BaggingClassifier

Créons maintenant une plage de valeurs qui représentent le nombre d’estimateurs que nous voulons utiliser dans chaque ensemble.

estimator_range = [2,4,6,8,10,12,14,16]

Pour voir comment le classificateur d’ensachage fonctionne avec différentes valeurs de n_estimators, nous avons besoin d’un moyen d’itérer sur la plage de valeurs et de stocker les résultats de chaque ensemble. Pour ce faire, nous allons créer une boucle for, stockant les modèles et les scores dans des listes séparées pour des visualisations ultérieures.

Remarque : Le paramètre par défaut du classificateur de base dans BaggingClassifier est le DicisionTreeClassifier par conséquent, nous n’avons pas besoin de le définir lors de l’instanciation du modèle d’ensachage.

models = []
scores = []

pour n_estimators dans estimateur_range :

# Créer un classificateur d’ensachage
clf = BaggingClassifier(n_estimators = n_estimators, random_state = 22)

# Adapter le modèle
clf.fit(X_train, y_train)

# Ajoutez le modèle et le score à leur liste respective
modèles.append(clf)
scores.append(accuracy_score(y_true = y_test, y_pred = clf.predict(X_test)))

Avec les modèles et les scores stockés, nous pouvons maintenant visualiser l’amélioration des performances du modèle.

import matplotlib.pyplot as plt

# Générer le tracé des scores en fonction du nombre d’estimateurs
plt.figure(figsize=(9,6))
plt.plot(estimator_range, scores)

# Ajuster les étiquettes et la police (pour rendre visible)
plt.xlabel(“n_estimators”, fontsize = 18)
plt.ylabel(“score”, fontsize = 18)
plt.tick_params(labelsize = 16)

# Visualiser le tracé
plt.show()

Exemple

Importez les données nécessaires et évaluez BaggingClassifier performance.

importer matplotlib.pyplot en tant que plt
à partir d’ensembles de données d’importation sklearn
depuis sklearn.model_selection importer train_test_split
depuis sklearn.metrics importer precision_score
depuis sklearn.ensemble importer BaggingClassifier

data = datasets.load_wine(as_frame = True)

X = données.données
y = données.cible

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 22)

estimateur_range = [2,4,6,8,10,12,14,16]

modèles = []
scores = []

pour n_estimators dans estimateur_range :

# Créer un classificateur d’ensachage
clf = BaggingClassifier(n_estimators = n_estimators, random_state = 22)

# Adapter le modèle
clf.fit(X_train, y_train)

# Ajoutez le modèle et le score à leur liste respective
modèles.append(clf)
scores.append(accuracy_score(y_true = y_test, y_pred = clf.predict(X_test)))

# Générer le tracé des scores en fonction du nombre d’estimateurs
plt.figure(figsize=(9,6))
plt.plot(estimator_range, scores)

# Ajuster les étiquettes et la police (pour rendre visible)
plt.xlabel(“n_estimators”, fontsize = 18)
plt.ylabel(“score”, fontsize = 18)
plt.tick_params(labelsize = 16)

# Visualiser le tracé
plt.show()

Résultat

Exemple d’exécution »


Résultats expliqués

En parcourant différentes valeurs pour le nombre d’estimateurs, nous pouvons voir une augmentation des performances du modèle de 82,2 % à 95,5 %. Après 14 estimateurs, la précision commence à baisser, encore une fois si vous définissez un autre random_state les valeurs que vous voyez varieront. C’est pourquoi il est recommandé d’utiliser la validation croisée pour garantir des résultats stables.

Dans ce cas, nous constatons une augmentation de 13,3% de la précision lorsqu’il s’agit d’identifier le type de vin.


Une autre forme d’évaluation

Comme le bootstrap choisit des sous-ensembles aléatoires d’observations pour créer des classificateurs, certaines observations sont laissées de côté dans le processus de sélection. Ces observations “out-of-bag” peuvent ensuite être utilisées pour évaluer le modèle, de manière similaire à celle d’un ensemble de test. Gardez à l’esprit que l’estimation out-of-bag peut surestimer l’erreur dans les problèmes de classification binaire et ne doit être utilisée qu’en complément d’autres métriques.

Nous avons vu dans le dernier exercice que 12 estimateurs donnaient la plus grande précision, nous allons donc l’utiliser pour créer notre modèle. Cette fois en réglant le paramètre oob_score sur vrai pour évaluer le modèle avec un score hors sac.

Exemple

Créez un modèle avec une métrique hors sac.

à partir d’ensembles de données d’importation sklearn
depuis sklearn.model_selection importer train_test_split
depuis sklearn.ensemble importer BaggingClassifier

data = datasets.load_wine(as_frame = True)

X = données.données
y = données.cible

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 22)

oob_model = BaggingClassifier(n_estimators = 12, oob_score = True,random_state = 22)

oob_model.fit(X_train, y_train)

imprimer(oob_model.oob_score_)

Exemple d’exécution »

Étant donné que les échantillons utilisés dans OOB et l’ensemble de test sont différents et que l’ensemble de données est relativement petit, il existe une différence dans la précision. Il est rare qu’ils soient exactement les mêmes, encore une fois OOB devrait être utilisé comme moyen rapide pour estimer l’erreur, mais ce n’est pas la seule métrique d’évaluation.


Génération d’arbres de décision à partir du classificateur d’ensachage

Comme nous l’avons vu dans la leçon sur l’arbre de décision, il est possible de représenter graphiquement l’arbre de décision créé par le modèle. Il est également possible de voir les arbres de décision individuels qui sont entrés dans le classificateur agrégé. Cela nous aide à acquérir une compréhension plus intuitive de la façon dont le modèle d’ensachage arrive à ses prédictions.

Remarque : Ceci n’est fonctionnel qu’avec des ensembles de données plus petits, où les arbres sont relativement peu profonds et étroits, ce qui les rend faciles à visualiser.

Nous devrons importer plot_tree fonction de sklearn.tree. Les différents arbres peuvent être représentés graphiquement en changeant l’estimateur que vous souhaitez visualiser.

Exemple

Générer des arbres de décision à partir du classificateur d’ensachage

à partir d’ensembles de données d’importation sklearn
depuis sklearn.model_selection importer train_test_split
depuis sklearn.ensemble importer BaggingClassifier
de sklearn.tree importer plot_tree

X = données.données
y = données.cible

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 22)

clf = BaggingClassifier(n_estimators = 12, oob_score = True,random_state = 22)

clf.fit(X_train, y_train)

plt.figure(figsize=(30, 20))

plot_tree(clf.estimators_[0]feature_names = X.columns)

Résultat

Exemple d’exécution »

Ici, nous ne pouvons voir que le premier arbre de décision qui a été utilisé pour voter sur la prédiction finale. Encore une fois, en changeant l’index du classificateur, vous pouvez voir chacun des arbres qui ont été agrégés.


#Python #Machine #Learning #Agrégation #Bootstrap #Bagging

Related Articles

Check Also
Close
Back to top button