Classificadores do gradient boosting no 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

A função createDataPartition do pacote de caret para dividir o conjunto de dados original em um conjunto de treinamento e testes e dividir os dados em conjunto de treinamento (70%) e teste (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, ]

Agora você já pode treinar e testar.

O método de treinamento da biblioteca caret utiliza fórmulas do R, onde a variável dependente (muitas vezes também chamada de alvo) está no lado esquerdo de um til '~.' As variáveis independentes (muitas vezes também chamadas de funcionalidade) estão no lado direito do '~'. Por exemplo:

height ~ age

esta etapa prevê a altura com base na idade.

Para treinar a caret, você passa a fórmula, os dados de treinamento e o método a ser usado. A biblioteca caret fornece métodos para muitos tipos diferentes de treinamento; portanto, definir o método como "gbm" é onde você especificará o uso do gradient boosting. O próximo parâmetro configura o processo de treinamento. O método "repeatedcv" executa validação cruzada de X vezes em subamostras dos pontos de dados do conjunto de treinamento. Aqui, você especifica três repetições de validação cruzada de cinco vezes usando um conjunto diferente de vezes para cada validação 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)

Agora você pode usar o modelo preditivo para fazer previsões sobre dados de teste:

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

print(pred_test)

Esta etapa 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

Devido à natureza da validação cruzada com vezes, a sensibilidade e a especificidade de cada classe podem ser ligeiramente diferentes do que é observado aqui, embora a precisão seja a mesma. A precisão é muito boa, mesmo com o pinguim de Chinstrap, que representa 20% do conjunto de dados de treinamento.

Esta etapa instala as bibliotecas que você usará para treinar e testar o classificador do gradient boosting. O treinamento em si é feito com o scikit-learn, e os dados são provenientes da biblioteca palmarpenguins.

!pip install seaborn pandas scikit-learn palmerpenguins

Agora instale as bibliotecas no ambiente do 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

Como no código R, há alguns NAs no conjunto de dados dos pinguins que precisam ser removidos. Esse trecho de código carrega o conjunto de dados, remove todas as linhas de NA e, em seguida, divide os dados em funcionalidades e destinos.

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

Agora, crie uma divisão de treinamento e teste do conjunto de dados, com 70% dos dados extraídos para treinamento e 30% reservados para teste.

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

Em seguida, você reunirá duas listas de nomes de colunas, uma para as funcionalidades categóricas de X e outra para as funcionalidades numéricas, por exemplo, float64 ou int64. Em seguida, use o ColumnTransformer do scikit-learn para aplicar um pré-processamento diferente a tipos de coluna diferentes. Um OneHotEncoder é aplicado a funcionalidades categóricas para convertê-las em vetores binários. Um StandardScaler é aplicado a funcionalidades numéricas para padronizá-las em torno de uma média f 0 e uma variância 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),
   ]
)

Agora que você criou os conjuntos de funcionalidades e o pré-processador, pode criar um pipeline para treinar o modelo. Esse pipeline usa o pré-processador nos dados de entrada e os passa para o algoritmo do gradient boosting para criar o classificador. Com um conjunto de dados maior ou mais complexo, existem outros parâmetros de treinamento que talvez você queira configurar. Por exemplo, max_features, que define o número de funcionalidades a serem consideradas ao procurar a melhor divisão ou max_depth, que limita o número de nós na árvore. Esse fragmento de código define o parâmetro do critério, que mede a qualidade de uma divisão para treinamento. Neste caso, estamos usando o erro quadrático médio com pontuação de melhoria por Jerry Friedman (link externo a ibm.com)

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

Em seguida, execute a validação cruzada para avaliar o desempenho do seu pipeline de aprendizado de máquina nos dados de treinamento. Chamada do método de ajuste do pipeline que você criou treina o modelo. A função de perda usa o erro médio quadrático (ou MSE) por padrão.

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

Agora que o modelo foi treinado, preveja o conjunto de testes e verifique o desempenho:

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

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

Imprima os resultados:

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

Essa etapa imprime os seguintes 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

Esses resultados estão muito próximos da precisão relatada pelos métodos R na primeira parte deste tutorial.