Classificatori di boosting del gradiente in Scikit-Learn e 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 funzione createDataPartition del pacchetto caret per dividere il set di dati originale in un set di addestramento e test e dividere i dati in set di addestramento (70%) e set di 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, ]

Ora sei pronto per addestrare e testare.

Il metodo di addestramento della libreria caret utilizza formule R, in cui la variabile dipendente (spesso chiamata anche target) si trova sul lato sinistro di una tilde "~". Le variabili indipendenti (spesso chiamate anche caratteristiche) si trovano sul lato destro della '~'. Ad esempio:

height ~ age

Questo passaggio prevede l'altezza in base all'età.

Per eseguire l'addestramento caret, si passano la formula, i dati di addestramento e il metodo da utilizzare. La libreria caret fornisce metodi per diversi tipi di addestramento, quindi impostando il metodo come "gbm" si specifica di usare il boosting del gradiente. Il parametro successivo configura il processo di addestramento. Il metodo "repeatedcv" esegue la convalida incrociata X-fold su sottocampioni dei punti dati del set di addestramento. In questo caso, si specificano 3 ripetizioni di convalida incrociata di 5-fold utilizzando un set diverso di fold per ogni convalida incrociata.

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)

Ora puoi usare il modello predittivo per fare previsioni sui dati dei test:

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

print(pred_test)

Questo passaggio stampa:

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

A causa della natura della convalida incrociata con fold, la sensibilità e la specificità per ogni classe possono essere leggermente diverse da quelle osservate qui, anche se la precisione sarà la stessa. La precisione è abbastanza buona, anche con il pinguino Chinstrap, che costituisce il 20% del set di dati di addestramento.

Questo passaggio installa le librerie che verranno usate per addestrare e testare il classificatore di boosting del gradiente. L'addestramento stesso viene eseguito con scikit-learn e i dati provengono dalla libreria palmerpenguins.

!pip install seaborn pandas scikit-learn palmerpenguins

Ora installi le librerie nell'ambiente 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

Come nel codice R, ci sono alcuni NA nel set di dati dei pinguini che devono essere rimossi. Questo frammento di codice carica il set di dati, rimuove tutte le righe NA e quindi divide i dati in caratteristiche e target.

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

Ora crei una suddivisione del set di dati per l'addestramento e il test, con il 70% dei dati raccolti per l'addestramento e il 30% riservato ai test.

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

Ora raccoglierai due elenchi dei nomi delle colonne, uno per le caratteristiche categoriche di X e un altro per le caratteristiche numeriche, ad es. float64 o int64. Quindi, usi ColumnTransformer di scikit-learn per applicare diverse pre-elaborazioni a diversi tipi di colonne. Un OneHotEncoder viene applicato alle caratteristiche categoriche per convertirle in vettori binari. Uno StandardScaler viene applicato alle caratteristiche numeriche per standardizzarle attorno a una media f 0 e una varianza di 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),
   ]
)

Ora che hai creato il set di caratteristiche e il preprocessore, puoi creare una pipeline per addestrare il modello. Questa pipeline utilizza il preprocessore sui dati di input e poi li passa all'algoritmo Gradient Boosting per creare il classificatore. Con un set di dati più grande o più complesso, potrebbero essere necessari altri parametri di addestramento da configurare. Ad esempio, max_features, che imposta il numero di caratteristiche da considerare quando si cerca la migliore divisione, o max_depth, che limita il numero di nodi nell'albero. Questo frammento di codice imposta il parametro del criterio, che misura la qualità di una divisione per l'addestramento. In questo caso, stiamo utilizzando l'errore quadratico medio con punteggio di miglioramento di [Jerry Friedman] (https://jerryfriedman.su.domains/ftp/trebst.pdf) (link esterno a IBM)

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

Successivamente, esegui la convalida incrociata per valutare le prestazioni della tua pipeline di machine learning sui dati di addestramento. Chiamando il metodo fit della pipeline creata, viene addestrato il modello. La funzione di perdita utilizza l'errore quadratico medio (o MSE) per impostazione predefinita.

# 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)

Ora che il modello è stato addestrato, prevedi il set di test e controlla le prestazioni:

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

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

Stampa i risultati:

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

Questo passaggio stampa i seguenti risultati:

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

Questi risultati sono molto vicini alla precisione riportata dai metodi R nella prima parte di questo tutorial.