Classifieurs de gradient boosting dans Scikit-Learn et Caret

install.packages('gbm')
install.packages('caret')
install.packages('palmerpenguins')

library(gbm)
library(caret)  
library(palmerpenguins)

head(penguins) # head() returns the top 6 rows of the dataframe
summary(penguins) # prints a statistical summary of the data columns

La fonction createDataPartition du package caret pour diviser le jeu de données initial en jeu d’entraînement et jeu de test, et les données en données d’entraînement (70 %) et données de test (30 %).

dim(penguins)

# get rid of any NA

penguins <- na.omit(penguins)
parts = caret::createDataPartition(penguins$species, p = 0.7, list = F)

train = penguins[parts, ]
test = penguins[-parts, ]

Maintenant vous pouvez procéder à l’entraînement et aux tests.

La méthode d’entraînement de la bibliothèque caret utilise des formules R, où la variable dépendante (souvent appelée cible) se trouve à gauche d’un tilde « ~ ». Les variables indépendantes (également appelées caractéristiques) se trouvent à droite du « ~ ». Par exemple :

height ~ age

Cette étape permet de prédire la taille en fonction de l’âge.

Pour l’entraînement caret, vous passez la formule, les données d’entraînement et la méthode à utiliser. La bibliothèque caret fournit des méthodes pour divers types d’entraînement. En définissant la méthode sur « gbm », vous indiquerez donc que vous souhaitez utiliser le gradient boosting. Le paramètre suivant configure le processus d’entraînement. La méthode « repeatedcv » effectue une validation croisée X-fold sur des sous-échantillons des points de données d’entraînement. Ici, vous spécifiez 3 répétitions de la validation croisée 5-fold en utilisant un ensemble de folds différent pour chaque validation croisée.

model_gbm <- caret::train("species ~ .",
                          data = train,
                          method = "gbm", # gbm for gradient boosting machine
                          trControl = trainControl(method = "repeatedcv", 
                                                   number = 5, 
                                                   repeats = 3, 
                                                   verboseIter = FALSE),
                          verbose = 0)

Vous pouvez maintenant utiliser le modèle prédictif pour faire des prédictions sur les données de test :

pred_test = caret::confusionMatrix(
  data = predict(model_gbm, test),
  reference = test$species
)

print(pred_test)

Cette étape imprime :

Confusion Matrix and Statistics
           Reference
Prediction  Adelie Chinstrap Gentoo
  Adelie        42         0      0
  Chinstrap      0        20      0
  Gentoo         1         0     35

Overall Statistics
                                          
               Accuracy : 0.9898          
                 95% CI : (0.9445, 0.9997)
    No Information Rate : 0.4388          
    P-Value [Acc > NIR] : < 2.2e-16       
                  Kappa : 0.984           

 Mcnemar's Test P-Value : NA              

Statistics by Class:
                     Class: Adelie Class: Chinstrap Class: Gentoo
Sensitivity                 0.9767           1.0000        1.0000
Specificity                 1.0000           1.0000        0.9841
Pos Pred Value              1.0000           1.0000        0.9722
Neg Pred Value              0.9821           1.0000        1.0000
Prevalence                  0.4388           0.2041        0.3571
Detection Rate              0.4286           0.2041        0.3571
Detection Prevalence        0.4286           0.2041        0.3673
Balanced Accuracy           0.9884           1.0000        0.9921

Étant donné la nature de la validation croisée avec folds, la sensibilité et la spécificité de chaque classe peuvent être légèrement différentes de ce qui est observé ici, bien que la précision soit la même. La précision est assez bonne, même avec le pingouin Chinstrap, qui représente 20 % du jeu de données d’entraînement.

Cette étape installe les bibliothèques que vous utiliserez pour entraîner et tester votre modèle de classification par gradient boosting. L’entraînement se fait avec scikit-learn, et les données proviennent de la bibliothèque palmerpenguins.

!pip install seaborn pandas scikit-learn palmerpenguins

Installez maintenant les bibliothèques dans l’environnement du notebook :

import pandas as pd
import seaborn as sns
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from palmerpenguins import load_penguins

Comme dans le code R, certains NA dans le jeu de données des pingouins doivent être supprimés. Cet extrait de code charge le jeu de données, supprime toutes les lignes NA, puis divise les données en caractéristiques et cibles.

# Load the penguins
penguins = load_penguins() #initialize the dataset
penguins = penguins.dropna()
X = penguins.drop("species", axis=1)
y = penguins["species"]

Maintenant, répartissez le jeu de données entre l’entraînement et les tests, avec 70 % des données extraites pour l’entraînement, et 30 % pour les tests.

X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size=0.3, random_state=42
)

Ensuite, vous allez recueillir deux listes de noms de colonnes, l’une pour les caractéristiques catégorielles de X, et l’autre pour les caractéristiques numériques (par exemple, float64 ou int64). Ensuite, utilisez ColumnTransformer de scikit-learn pour appliquer différents prétraitements aux différents types de colonnes. Un OneHotEncoder est appliqué aux caractéristiques catégorielles pour les convertir en vecteurs binaires. Un StandardScaler est appliqué aux caractéristiques numériques pour les standardiser autour d’une moyenne f 0 et d’une variance de 1.

# Define categorical and numerical features
categorical_features = X.select_dtypes(
   include=["object"]
).columns.tolist()

numerical_features = X.select_dtypes(
   include=["float64", "int64"]
).columns.tolist()

preprocessor = ColumnTransformer(
   transformers=[
       ("cat", OneHotEncoder(), categorical_features),
       ("num", StandardScaler(), numerical_features),
   ]
)

Maintenant que vous avez créé les ensembles de caractéristiques et le préprocesseur, vous pouvez créer un pipeline pour entraîner le modèle. Ce pipeline utilise le préprocesseur sur les données d’entrée, puis les transmet à l’algorithme de gradient boosting pour créer le classifieur. Avec un jeu de données plus volumineux ou plus complexe, il peut être utile de configurer d’autres paramètres d’entraînement. Par exemple, max_features, qui définit le nombre de caractéristiques à prendre en compte lorsque vous recherchez la meilleure division, ou max_depth, qui limite le nombre de nœuds de l’arbre. Cet extrait de code définit le paramètre critère, qui mesure la qualité du fractionnement pour l’entraînement. Dans ce cas, nous utilisons l’erreur quadratique moyenne avec score d’amélioration de Jerry Friedman (lien externe à IBM)

pipeline = Pipeline([
       ("preprocessor", preprocessor),
       ("classifier", GradientBoostingClassifier(random_state=42, 
         criterion='friedman_mse', max_features=2)),
   ])

Ensuite, effectuez une validation croisée pour évaluer la performance de votre pipeline de machine learning sur les données d’entraînement. L’appel à la méthode d’ajustement du pipeline que vous avez créé entraîne le modèle. La fonction de perte utilise l’erreur quadratique moyenne (ou MSE) par défaut.

# Perform 5-fold cross-validation
cv_scores = cross_val_score(pipeline, X_train, y_train, cv=5)

# Fit the model on the training data
pipeline.fit(X_train, y_train)

Maintenant que le modèle a été entraîné, prédisez le test et vérifiez la performance :

# Predict on the test set
y_pred = pipeline.predict(X_test)

# Generate classification report
report = classification_report(y_test, y_pred)

Imprimez les résultats :

print(f"Mean Cross-Validation Accuracy: {cv_scores.mean():.4f}")
print("\nClassification Report:")
print(report)

Cet étape imprime les résultats suivants :

Mean Cross-Validation Accuracy: 0.9775
Classification Report:
              precision    recall  f1-score   support
      Adelie       1.00      1.00      1.00        31
   Chinstrap       1.00      1.00      1.00        18
      Gentoo       1.00      1.00      1.00        18
    accuracy                           1.00        67
   macro avg       1.00      1.00      1.00        67
weighted avg       1.00      1.00      1.00        67

Ces résultats sont très proches de la précision rapportée par les méthodes R dans la première partie de ce tutoriel.