Gradient Boosting Classifiers in Scikit-Learn und 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

Mit der Funktion „createDataPartition“ aus dem Caret-Paket kann der ursprüngliche Datensatz in einen Trainings- und einen Testsatz aufgeteilt werden. Dabei werden 70 % der Daten dem Trainingssatz und 30 % dem Testsatz zugeordnet.

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, ]

Jetzt können Sie trainieren und testen.

Die Methode zum Trainieren aus der Caret-Bibliothek verwendet R-Formeln, bei denen sich die abhängige Variable (oft auch Ziel genannt) auf der linken Seite einer Tilde „~“ befindet. Die unabhängigen Variablen (oft auch Funktion genannt) befinden sich auf der rechten Seite des „~“. Zum Beispiel:

height ~ age

In diesem Schritt wird die Größe anhand des Alters vorhergesagt.

Beim Caret-Training übermitteln Sie die Formel, die Trainingsdaten und die zu verwendende Methode. Die Caret-Bibliothek bietet Methoden für viele verschiedene Arten von Training. Wenn Sie die Methode also auf „gbm“ festlegen, geben Sie an, dass Gradient Boosting verwendet werden soll. Der nächste Parameter konfiguriert den Trainingsprozess. Die Methode „repeatedcv“ führt eine X-fache Kreuzvalidierung auf Teilstichproben der Datenpunkte des Trainingssatzes durch. Hier geben Sie 3 Wiederholungen der 5-fachen Kreuzvalidierung an, indem Sie für jede Kreuzvalidierung einen anderen Satz von Faltungen verwenden.

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)

Jetzt können Sie das Vorhersagemodell verwenden, um Vorhersagen für Testdaten zu treffen:

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

print(pred_test)

In diesem Schritt wird Folgendes ausgegeben:

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

Aufgrund der Art der Kreuzvalidierung mit Faltungen können die Sensitivität und die Spezifität für jede Klasse leicht von den beobachteten Werten abweichen, wobei die Genauigkeit dieselbe bleibt. Die Genauigkeit ist recht gut, selbst mit dem Chinstrap-Pinguin, der 20 % des Datensatzes ausmacht.

In diesem Schritt werden die Bibliotheken installiert, die Sie zum Trainieren und Testen Ihres Gradient Boosting Classifiers verwenden. Das Training selbst wird mit scikit-learn durchgeführt und die Daten stammen aus der palmerpenguins-Bibliothek.

!pip install seaborn pandas scikit-learn palmerpenguins

Installieren Sie nun die Bibliotheken in der Notebook-Umgebung:

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

Wie im R-Code gibt es einige NAs im Pinguin-Datensatz, die entfernt werden müssen. Dieser Codeausschnitt lädt den Datensatz, entfernt alle NA-Zeilen und teilt die Daten dann in Funktionen und Ziel auf.

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

Jetzt erstellen Sie eine Trainings- und Testaufteilung des Datensatzes, wobei 70 % der Daten für das Training abgerufen und 30 % für Tests reserviert werden.

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

Als nächstes erstellen Sie zwei Listen mit den Spaltennamen, eine für die kategorialen Funktionen von X und eine weitere für die numerischen Funktionen, z. B. float64 oder int64. Verwenden Sie dann den ColumnTransformer von scikit-learn, um unterschiedliche Vorverarbeitungen auf verschiedene Spaltentypen anzuwenden. Ein OneHotEncoder wird auf kategorische Funktionen angewendet, um sie in binäre Vektoren umzuwandeln. Ein StandardScaler wird auf numerische Funktionen angewendet, um sie um einen Mittelwert f 0 und eine Varianz von 1 zu standardisieren.

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

Nachdem Sie nun die Funktionssätze und den Vorprozessor erstellt haben, können Sie eine Pipeline erstellen, um das Modell zu trainieren. Diese Pipeline verwendet den Präprozessor für Eingabedaten und übergibt sie dann an den Gradient-Boosting-Algorithmus, um den Classifier zu erstellen. Bei einem größeren oder komplexeren Datensatz gibt es weitere Trainingsparameter, die Sie konfigurieren können. Zum Beispiel max_features, das die Anzahl der Funktionen festlegt, die bei der Suche nach der besten Aufteilung berücksichtigt werden sollen, oder max_depth, das die Anzahl der Knoten im Baum begrenzt. Dieser Codeausschnitt legt den criterion-Parameter fest, der die Qualität einer Teilung für das Training misst. In diesem Fall verwenden wir den mittleren quadratischen Fehler mit der Verbesserungsbewertung von Jerry Friedman (befindet sich außerhalb von IBM).

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

Führen Sie als Nächstes eine Kreuzvalidierung durch, um zu bewerten, wie gut Ihre Machine-Learning-Pipeline bei den Trainingsdaten abschneidet. Durch den Aufruf der Anpassungsmethode der von Ihnen erstellten Pipeline wird das Modell trainiert. Die Verlustfunktion verwendet standardmäßig den mittleren quadratischen Fehler (oder MSE).

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

Jetzt, wo das Modell trainiert wurde, lassen Sie den Testsatz voraussagen und überprüfen Sie die Leistung:

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

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

Die Ergebnisse drucken:

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

In diesem Schritt werden die folgenden Ergebnisse gedruckt:

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

Diese Ergebnisse liegen sehr nahe an der Genauigkeit, die von den R-Methoden im ersten Teil dieses Tutorials gemeldet wurde.