0Pricing
R Academy · Pelajaran

Peningkatan Gradien dengan xgboost

Konfigurasikan parameter xgboost, penghentian dini, dan jadwal laju pembelajaran.

Peningkatan Gradien dengan xgboost adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Apa Itu Gradient Boosting?

Gradient boosting membangun ansambel secara berurutan. Setiap pohon baru memperbaiki galat residual ansambel sebelumnya dengan menyesuaikan diri pada gradien negatif fungsi kerugian. Berbeda dari hutan acak (pohon yang dibangun secara paralel), boosting membangun pohon satu per satu, dan setiap pohon belajar dari kesalahan pohon sebelumnya.

library(xgboost)

# XGBoost expects data in a special matrix format
# We'll build a simple example step by step
cat('XGBoost version:', packageVersion('xgboost'))

# Key concept: each tree reduces the ensemble error
# Final prediction = sum of all tree predictions

xgb.DMatrix()

xgb.DMatrix(data, label) adalah format data internal XGBoost yang dioptimalkan. Format ini menyimpan matriks fitur dan vektor label secara bersamaan, sehingga memungkinkan komputasi yang cepat dan hemat memori. Selalu konversikan data Anda ke DMatrix sebelum pelatihan.

library(xgboost)
library(MASS)

X_train <- as.matrix(Boston[1:400, -14])  # features
y_train <- Boston[1:400, 14]              # medv (target)

X_test  <- as.matrix(Boston[401:506, -14])
y_test  <- Boston[401:506, 14]

dtrain <- xgb.DMatrix(data = X_train, label = y_train)
dtest  <- xgb.DMatrix(data = X_test,  label = y_test)

cat('DMatrix rows:', nrow(dtrain))

xgboost() — Pelatihan Dasar

xgboost(data, nrounds, eta, max_depth, objective) melatih model. Parameter utama: eta (laju pembelajaran, lebih kecil = lebih tangguh tetapi lebih lambat), max_depth (kedalaman pohon, mengendalikan kompleksitas model), nrounds (jumlah pohon).

params <- list(
  objective  = 'reg:squarederror',
  eta        = 0.1,     # learning rate
  max_depth  = 6,       # tree depth
  subsample  = 0.8,     # row subsampling
  colsample_bytree = 0.8  # column subsampling
)

set.seed(42)
model <- xgboost(
  data    = dtrain,
  params  = params,
  nrounds = 100,
  verbose = 0
)

cat('Model trained with', model$niter, 'rounds')

Watchlist — Memantau Kerugian Validasi

Argumen watchlist menerima daftar bernama yang berisi objek DMatrix. XGBoost mengevaluasi dan mencetak kerugian pada setiap kumpulan data yang tercantum setelah setiap putaran boosting. Gunakan ini untuk melacak kerugian pelatihan dibandingkan validasi dan mendeteksi kapan overfitting mulai terjadi.

watchlist <- list(train = dtrain, eval = dtest)

model <- xgb.train(
  params    = params,
  data      = dtrain,
  nrounds   = 200,
  watchlist = watchlist,
  verbose   = 1
)

# The log shows train-rmse and eval-rmse per round
# Watch for eval-rmse increasing (overfitting signal)

early_stopping_rounds

early_stopping_rounds = 20 menghentikan pelatihan jika metrik validasi tidak membaik selama 20 putaran berturut-turut. Ini secara otomatis menemukan jumlah pohon yang optimal, sehingga menghindari underfitting dan overfitting tanpa penyetelan manual yang menyeluruh.

model <- xgb.train(
  params              = params,
  data                = dtrain,
  nrounds             = 1000,      # max rounds
  watchlist           = list(train = dtrain, eval = dtest),
  early_stopping_rounds = 20,      # stop if no improvement
  print_every_n       = 50,
  verbose             = 1
)

cat('Best iteration:', model$best_iteration)
cat('Best eval RMSE:', model$best_score)

Klasifikasi Biner

Untuk klasifikasi biner, gunakan objective = 'binary:logistic', yang menghasilkan probabilitas prediksi. Label harus berupa nilai numerik 0/1. Evaluasilah dengan AUC atau log-loss menggunakan parameter eval_metric.

# Binary classification example
library(MASS)
Pima <- MASS::Pima.tr

X_cl <- as.matrix(Pima[, -8])
y_cl <- as.numeric(Pima$type) - 1  # factor to 0/1

dt_cl <- xgb.DMatrix(data = X_cl, label = y_cl)

mod_cl <- xgboost(
  data       = dt_cl,
  objective  = 'binary:logistic',
  eval_metric = 'auc',
  eta        = 0.05,
  max_depth  = 4,
  nrounds    = 100,
  verbose    = 0
)

Prediksi

predict(model, dtest) mengembalikan nilai prediksi mentah—probabilitas untuk klasifikasi atau prediksi bernilai riil untuk regresi. Terapkan ambang 0,5 untuk mengubah probabilitas menjadi label kelas dalam tugas klasifikasi.

# Regression predictions
reg_preds <- predict(model, dtest)
rmse <- sqrt(mean((reg_preds - y_test)^2))
cat('Test RMSE:', round(rmse, 3))

# Classification predictions
prob_preds  <- predict(mod_cl, dt_cl)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
accuracy <- mean(class_preds == y_cl)
cat('Training Accuracy:', round(accuracy, 3))

xgb.cv() — Validasi Silang

xgb.cv(params, data, nrounds, nfold) menjalankan validasi silang k-lipat di dalam XGBoost. Ini lebih cepat daripada menggunakan rsample karena XGBoost menangani lipatan tersebut secara internal. Keluaran menampilkan mean dan SD metrik untuk setiap putaran.

cv_result <- xgb.cv(
  params    = params,
  data      = dtrain,
  nrounds   = 200,
  nfold     = 5,
  early_stopping_rounds = 15,
  print_every_n = 20,
  verbose   = 1
)

# Best nrounds from CV
best_nrounds <- cv_result$best_iteration
cat('Optimal nrounds:', best_nrounds)

# CV RMSE at best iteration
cat('CV RMSE:', cv_result$evaluation_log[best_nrounds, 'test_rmse_mean'][[1]])

Hiperparameter Utama

Hiperparameter XGBoost yang paling berpengaruh:

  • eta: Laju pembelajaran (0.01-0.3). Lebih rendah = memerlukan lebih banyak pohon dan lebih tangguh.
  • max_depth: Kedalaman pohon (3-10). Lebih besar = lebih kompleks dan lebih cepat mengalami overfitting.
  • subsample: Fraksi baris per pohon (0.5-1.0). Mengurangi overfitting.
  • colsample_bytree: Fraksi fitur per pohon (0.5-1.0).
  • lambda: Regularisasi L2 pada bobot daun.
  • alpha: Regularisasi L1 pada bobot daun.
params_tuned <- list(
  objective         = 'reg:squarederror',
  eta               = 0.05,
  max_depth         = 5,
  subsample         = 0.75,
  colsample_bytree  = 0.75,
  lambda            = 1.0,    # L2 regularization
  alpha             = 0.1,    # L1 regularization
  min_child_weight  = 3       # min samples in leaf
)

model_tuned <- xgboost(
  data = dtrain, params = params_tuned,
  nrounds = best_nrounds, verbose = 0
)

Menyimpan dan Memuat Model

Model XGBoost dapat disimpan ke disk dalam format biner dengan xgb.save(model, 'model.xgb') dan dimuat kembali dengan xgb.load('model.xgb'). Ini adalah format yang direkomendasikan untuk penerapan produksi dan menjamin reproduktibilitas yang identik hingga tingkat bit.

# Save model
xgb.save(model, '/tmp/xgb_boston.xgb')

# Reload and predict
loaded_model <- xgb.load('/tmp/xgb_boston.xgb')
new_preds <- predict(loaded_model, dtest)

# Verify predictions match
all.equal(reg_preds, new_preds)  # TRUE

Klasifikasi Multikelas

Untuk masalah multikelas, gunakan objective = 'multi:softprob' dan tetapkan num_class ke jumlah kelas. Label harus berupa bilangan bulat yang diindeks mulai dari 0. Keluarannya berupa matriks probabilitas untuk setiap kelas.

X_mc <- as.matrix(iris[, -5])
y_mc <- as.integer(iris$Species) - 1  # 0, 1, 2

dt_mc <- xgb.DMatrix(data = X_mc, label = y_mc)

params_mc <- list(
  objective  = 'multi:softprob',
  num_class  = 3,
  eta        = 0.1,
  max_depth  = 3
)

mod_mc <- xgboost(
  data = dt_mc, params = params_mc,
  nrounds = 50, verbose = 0
)

# Predictions: matrix of shape (n, num_class)
prob_matrix <- matrix(predict(mod_mc, dt_mc), ncol = 3, byrow = TRUE)
head(prob_matrix)

Pemeriksaan Singkat

Apa tujuan menetapkan early_stopping_rounds = 20 dalam xgb.train()?

Ringkasan XGBoost

Hal-hal penting dari Gradient Boosting dengan XGBoost:

  • xgb.DMatrix(data, label) membuat format data XGBoost yang dioptimalkan.
  • Parameter utama: eta (laju pembelajaran), max_depth, subsample, colsample_bytree.
  • watchlist memantau kerugian pelatihan dan validasi pada setiap putaran.
  • early_stopping_rounds menemukan jumlah pohon yang optimal secara otomatis.
  • xgb.cv() menjalankan CV k-lipat di dalam XGBoost untuk pencarian hiperparameter yang cepat.
  • Gunakan objective = 'binary:logistic' untuk biner dan 'multi:softprob' untuk multikelas.
  • Simpan/muat model dengan xgb.save() / xgb.load().
# Production XGBoost pipeline
dtrain <- xgb.DMatrix(data = X_train, label = y_train)
dtest  <- xgb.DMatrix(data = X_test,  label = y_test)

params <- list(objective = 'reg:squarederror',
               eta = 0.05, max_depth = 5, subsample = 0.8)

cv  <- xgb.cv(params, dtrain, nrounds = 500, nfold = 5,
              early_stopping_rounds = 20, verbose = 0)

model <- xgboost(data = dtrain, params = params,
                 nrounds = cv$best_iteration, verbose = 0)

preds <- predict(model, dtest)
cat('RMSE:', sqrt(mean((preds - y_test)^2)))

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Peningkatan Gradien dengan xgboost” gratis?

Ya — teks lengkap “Peningkatan Gradien dengan xgboost” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Peningkatan Gradien dengan xgboost”?

Konfigurasikan parameter xgboost, penghentian dini, dan jadwal laju pembelajaran. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Peningkatan Gradien dengan xgboost” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pohon Keputusan: Dasar Ensemble
  2. Hutan Acak dengan ranger
  3. Peningkatan Gradien dengan xgboost
  4. Kepentingan Fitur dan Interpretasi Model
← Kembali ke R Academy