Clasificadores de boosting de gradiente en Scikit-Learn y 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 función createDataPartition del paquete caret para dividir el conjunto de datos original en un conjunto de entrenamiento y prueba y dividir los datos en un conjunto de entrenamiento (70 %) y un conjunto de prueba (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, ]

Ahora está listo para entrenar y probar .

El método de entrenar de la biblioteca de intercalación utiliza fórmulas R, donde la variable dependiente (a menudo también llamada objetivo) está en el lado izquierdo de una tilde '~'. Las variables independientes (a menudo también llamadas características) están en el lado derecho del '~'. Por ejemplo:

height ~ age

este paso predice la altura en función de la edad.

Para entrenar con intercalación, debe pasar la fórmula, los datos de entrenamiento y el método que se utilizará. La biblioteca de intercalación proporciona métodos para muchos tipos diferentes de entrenamiento, por lo que establecer el método como "gbm" es donde especificará utilizar el boosting de gradiente. El siguiente parámetro configura el proceso de entrenamiento. El método "repeatedcv" realiza una validación cruzada X-fold en submuestras de los puntos de datos del conjunto de entrenamiento. Aquí, especifique 3 repeticiones de validación cruzada de 5 pliegues utilizando un conjunto diferente de pliegues para cada validación cruzada.

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)

Ahora puede utilizar el modelo predictivo para hacer predicciones sobre los datos de prueba:

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

print(pred_test)

Este paso 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

Debido a la naturaleza de la validación cruzada con pliegues, la sensibilidad y la especificidad de cada clase pueden ser ligeramente diferentes de las se observa aquí, aunque la precisión será la misma. La precisión es bastante buena, incluso con el pingüino barbijo, que constituye el 20 % del conjunto de datos de entrenamiento.

Este paso instala las bibliotecas que utilizará para entrenar y probar su clasificador de boosting de gradiente. El entrenamiento en sí se realiza con scikit-learn y los datos provienen de la biblioteca palmerpenguins.

!pip install seaborn pandas scikit-learn palmerpenguins

Ahora instale las bibliotecas en el entorno del cuaderno:

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

al igual que en el código R, hay algunas NA en el conjunto de datos de los pingüinos que deben eliminarse. Este fragmento de código carga el conjunto de datos, elimina las filas NA y, a continuación, divide los datos en características y destino.

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

Ahora cree una división de entrenamiento y prueba del conjunto de datos, con el 70 % de los datos extraídos para entrenamiento y el 30 % reservados para pruebas.

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

A continuación, reunirá dos listas de nombres de columnas, una para las características categóricas de X y otra para las características numéricas, por ejemplo float64 o int64. A continuación, utilice ColumnTransformer de scikit-learn para aplicar diferentes preprocesamientos a distintos tipos de columnas. Se aplica un OneHotEncoder a las características categóricas para convertirlas en vectores binarios. Se aplica un StandardScaler a las características numéricas para estandarizarlas en torno a una media f 0 y una varianza 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),
   ]
)

Ahora que ha creado los conjuntos de características y el preprocesador, puede crear una canalización para entrenar el modelo. Ese pipeline utiliza el preprocesador en los datos de entrada y luego los pasa al algoritmo boosting de gradiente para construir el clasificador. Con un conjunto de datos más grande o más complejo, hay otros parámetros de entrenamiento que quizás desee configurar. Por ejemplo, max_features, que establece el número de características a tener en cuenta al buscar la mejor división o max_profundidad, que limita el número de nodos en el árbol. Este fragmento de código establece el parámetro de criterio, que mide la calidad de una división para el entrenamiento. En este caso, estamos utilizando el error cuadrático medio con puntuación de mejora de Jerry Friedman (reside fuera de IBM)

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

A continuación, realice validación cruzada para evaluar el rendimiento de su pipeline de machine learning en los datos de entrenamiento. La llamada al método de ajuste del pipeline que ha creado entrena el modelo. La función de pérdida utiliza el error cuadrático medio (o MSE) de forma predeterminada.

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

Ahora que el modelo ha sido entrenado, prediga el conjunto de pruebas y comprobar el rendimiento:

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

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

Imprimir los resultados:

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

Este paso imprime los siguientes resultados:

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

Estos resultados están muy cerca de la precisión notificada por los métodos R en la primera parte de este tutorial.