Classification / régression par empilement (scikit-learn)

L'empilement est un moyen de combiner plusieurs modèles d'apprentissage automatique, mais j'ai essayé d'utiliser scikit-learn StackingClassifier et StackingRegressor de Python.

StackingClassifier

Classification par empilement

Utilisons les données du cancer du sein pour vérifier les performances du modèle de classification.

from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y)

Il y a place à l'amélioration car je n'ai pas réglé tous les paramètres, mais pour le moment

from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.ensemble import StackingClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.linear_model import LogisticRegression

estimators = [
        ('svc', make_pipeline(StandardScaler(), SVC())),
        ('rf', RandomForestClassifier()),
        ('mlp', MLPClassifier(max_iter=10000))
        ]
clf = StackingClassifier(
    estimators=estimators,
    final_estimator=LogisticRegression(max_iter=10000)
)
clf.fit(X_train, y_train)
clf.score(X_test, y_test)
0.972027972027972

Performance d'un modèle de classification unique

À titre de comparaison, calculons le taux de précision d'un seul modèle de classification.

make_pipeline(StandardScaler(), SVC()).fit(X_train, y_train).score(X_test, y_test)
0.965034965034965
RandomForestClassifier().fit(X_train, y_train).score(X_test, y_test)
0.951048951048951
MLPClassifier(max_iter=10000).fit(X_train, y_train).score(X_test, y_test)
0.9090909090909091
LogisticRegression(max_iter=10000).fit(X_train, y_train).score(X_test, y_test)
0.958041958041958

Le résultat est qu'il vaut mieux les combiner que de les utiliser seuls.

Cependant, si vous recalculez à partir de train_test_split, les performances d'un modèle de classification unique peuvent être meilleures en fonction de la façon dont il est divisé.

Pour la comparaison des performances, je pense qu'il est préférable de répéter le calcul plusieurs fois sans fixer la graine aléatoire et de vérifier la stabilité des performances.

StackingRegressor

Retour par empilement

Utilisons les données du diabète pour voir les performances du modèle de régression.

from sklearn.datasets import load_diabetes
X, y = load_diabetes(return_X_y=True)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y)

Il y a place à amélioration ici aussi parce que les paramètres n'ont pas été réglés.

from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR
from sklearn.ensemble import StackingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.cross_decomposition import PLSRegression

estimators = [
        ('svr', make_pipeline(StandardScaler(), SVR())),
        ('rf', RandomForestRegressor()),
        ('mlp', MLPRegressor(max_iter=10000))
        ]
clf = StackingRegressor(
    estimators=estimators,
    final_estimator=PLSRegression(),
)
clf.fit(X_train, y_train)
clf.score(X_test, y_test)
0.4940607294168183

Performance d'un modèle de régression unique

À titre de comparaison, calculons la valeur R2 d'un seul modèle de régression.

make_pipeline(StandardScaler(), SVR()).fit(X_train, y_train).score(X_test, y_test)
0.17571936903725216
RandomForestRegressor().fit(X_train, y_train).score(X_test, y_test)
0.46261715392586217
MLPRegressor(max_iter=10000).fit(X_train, y_train).score(X_test, y_test)
0.4936782755875562
PLSRegression().fit(X_train, y_train).score(X_test, y_test)
0.4927059150604132

Encore une fois, le résultat est qu'il vaut mieux les combiner que de les utiliser seuls.

Cependant, si vous recalculez à partir de train_test_split, les performances d'un modèle de régression unique peuvent être meilleures selon la façon dont il est divisé.

Pour la comparaison des performances, je pense qu'il est préférable de répéter le calcul plusieurs fois sans fixer la graine aléatoire et de vérifier la stabilité des performances.

Recommended Posts

Classification / régression par empilement (scikit-learn)
Classification multi-étiquettes par forêt aléatoire avec scikit-learn
Différence entre régression et classification
Classification des Pokémon par modèle de sujet
[Python] Régression linéaire avec scicit-learn
Machine learning supervisé (classification / régression)
Modèle d'empilage d'apprentissage automatique (retour)
Régression linéaire robuste avec scikit-learn
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.15. Régression isotonique
Classification et régression dans l'apprentissage automatique
Tracé de la droite de régression par tracé des résidus