Pengklasifikasi gradient boosting di Scikit-Learn dan 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

Fungsi createDataPartition dari paket caret untuk membagi kumpulan data asli menjadi kumpulan pelatihan dan pengujian serta membagi data menjadi kumpulan pelatihan (70%) dan pengujian (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, ]

Sekarang Anda siap untuk melatih dan menguji.

Metode pelatihan dari pustaka caret menggunakan rumus R, di mana variabel dependen (sering juga disebut target) berada di sisi kiri tilde '~'. Variabel independen (sering juga disebut fitur) berada di sisi kanan '~'. Misalnya:

height ~ age

Langkah ini memprediksi tinggi badan berdasarkan usia.

Untuk melatih caret, Anda memberikan rumus, data pelatihan, dan metode yang akan digunakan. Pustaka caret menyediakan metode untuk berbagai jenis pelatihan, jadi mengatur metode sebagai "gbm" adalah tempat di mana Anda akan menentukan penggunaan gradient boosting. Parameter berikutnya mengonfigurasi proses pelatihan. Metode "repeatedcv" melakukan validasi silang X-fold pada subsampel titik data kumpulan pelatihan. Di sini, Anda menentukan 3 pengulangan validasi silang 5 bagian dengan menggunakan kumpulan bagian berbeda untuk setiap validasi silang.

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)

Sekarang Anda dapat menggunakan model prediktif untuk membuat prediksi pada data uji:

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

print(pred_test)

Hasil cetakan langkah ini:

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

Akibat sifat validasi silang dengan bagian, sensitivitas dan kespesifikan untuk setiap kelas dapat sedikit berbeda dari yang diamati di sini, meskipun akurasinya akan sama. Akurasinya cukup bagus, bahkan dengan penguin Chinstrap, yang merupakan 20% dari kumpulan data pelatihan.

Langkah ini menginstal pustaka yang akan Anda gunakan untuk melatih dan menguji pengklasifikasi gradient boosting. Pelatihan itu sendiri dilakukan dengan scikit-learn dan datanya berasal dari pustaka palmerpenguins.

!pip install seaborn pandas scikit-learn palmerpenguins

Sekarang instal pustaka ke lingkungan 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

Seperti dalam kode R, ada beberapa NA dalam kumpulan data penguins yang perlu dihapus. Cuplikan kode ini memuat kumpulan data, menghapus baris NA apa pun, dan kemudian membagi data menjadi fitur dan target.

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

Sekarang buat pemisahan pelatihan dan pengujian dari kumpulan data, dengan 70% data ditarik untuk pelatihan dan 30% dicadangkan untuk pengujian.

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

Selanjutnya, Anda akan mengumpulkan dua daftar nama kolom, satu untuk fitur kategoris X dan satu lagi untuk fitur numerik, misalnya float64 atau int64. Kemudian, gunakan ColumnTransformer dari scikit-learn untuk menerapkan prapemrosesan berbeda ke jenis kolom yang berbeda. OneHotEncoder diterapkan pada fitur kategoris untuk mengubahnya menjadi vektor biner. StandardScaler diterapkan pada fitur numerik untuk menstandarkannya di sekitar rata-rata f 0 dan varians 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),
   ]
)

Sekarang setelah membuat kumpulan fitur dan preprosesor, Anda dapat membuat saluran untuk melatih model. Saluran tersebut menggunakan preprosesor pada data input dan kemudian meneruskannya ke algoritma Gradient Boosting untuk membangun pengklasifikasi. Dengan kumpulan data yang lebih besar atau lebih kompleks, ada parameter pelatihan lain yang mungkin ingin Anda konfigurasikan. Misalnya, max_features, yang menetapkan jumlah fitur yang perlu dipertimbangkan saat mencari pemisahan terbaik atau max_deep yang membatasi jumlah node di pohon. Cuplikan kode ini menetapkan parameter kriteria yang mengukur kualitas pemisahan untuk pelatihan. Dalam hal ini, kami menggunakan rata-rata kuadrat kesalahan dengan skor peningkatan oleh [Jerry Friedman] (https://jerryfriedman.su.domains/ftp/trebst.pdf) (berada di luar IBM)

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

Selanjutnya, lakukan validasi silang untuk mengevaluasi seberapa baik saluran machine learning Anda pada data pelatihan. Memanggil metode penyesuaian saluran yang Anda buat akan melatih model. Fungsi kesalahan menggunakan Rata-rata Kuadrat Kesalahan (atau MSE) secara default.

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

Sekarang setelah model dilatih, prediksi kumpulan uji dan periksa kinerjanya:

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

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

Cetak hasilnya:

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

Langkah ini mencetak hasil berikut:

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

Hasil ini sangat dekat dengan akurasi yang dilaporkan oleh metode R di bagian pertama tutorial ini.