Membangun Model Random Forest dengan mlr3 di R

Pustaka mlr3 di R merupakan salah satu framework yang lengkap serta fleksibel untuk membangun dan mengevaluasi model machine learning. Berbeda dengan pendekatan klasik di R seperti caret atau penggunaan fungsi model langsung seperti randomForest(), mlr3 menghadirkan struktur modular dan konsisten untuk seluruh pipeline machine learning, mulai dari pemilihan data, preprocessing, training, evaluasi, hingga tuning hyperparameter.

Pada tulisan ini, kita akan fokus memahami bagaimana menggunakan mlr3 untuk membangun model machine learning. Sebagai ilustrasi, Random Forest akan digunakan, namun pada prinsipnya pendekatannya akan dapat diterapkan ke model-model lain dengan mudah.

Sebelum mulai, pastikan kita memiliki R dan RStudio versi terbaru. Instal paket mlr3 dan beberapa ekstensi penting yang dapat semakin melengkapi proses pembangunan model. Pada tulisan ini memang tidak semua paket tersebut akan digunakan namun tentunya pembaca dapat mengeksplorasi secara mandiri jika diinginkan.

Beberapa paket tersebut yaitu:

• mlr3: paket inti dari ekosistem mlr3, menyediakan struktur dasar untuk task, learner, resampling, dan evaluasi.
• mlr3learners: menyediakan kumpulan learner atau algoritma pembelajaran mesin populer yang dapat langsung digunakan, termasuk di dalamnya yaitu model Random Forest (classif.ranger).
• mlr3verse: bundel paket yang sering digunakan bersama mlr3, seperti mlr3pipelines, mlr3tuning, mlr3filters, dan lainnya. Penggunaan paket ini dapat lebih memudahkan manajemen dan penggunaan bersama.
• mlr3viz: menyediakan fungsi visualisasi untuk evaluasi performa model, misalnya untuk membuat ROC curve, confusion matrix, dsb.
• data.table: digunakan untuk manipulasi data yang efisien. Sangat cepat dan kompatibel dengan mlr3, terutama dalam load data dan preprocessing.
• mlr3tuning: modul untuk melakukan tuning hyperparameter secara sistematis dengan berbagai metode seperti grid search, random search, Bayesian optimization.
• mlr3pipelines: memungkinkan pembentukan alur preprocessing dan modeling yang kompleks, termasuk penggabungan berbagai operasi seperti normalisasi data, feature selection, hingga model stacking.
• paradox: mendefinisikan ruang pencarian hyperparameter (parameter space) dalam bentuk objek yang dapat digunakan oleh mlr3tuning

install.packages(c("mlr3", "mlr3learners", "mlr3verse", "mlr3viz", "mlr3tuning", "mlr3pipelines", "paradox", "data.table"))

Ekosistem mlr3 dibangun berdasarkan tiga komponen inti, meliputi:

• Task: merepresentasikan dataset dan tujuan analisis. Dalam konteks supervised learning, task mencakup variabel target dan fitur prediktor.
• Learner: objek yang mewakili algoritma machine learning tertentu. Learner memiliki parameter dan fungsi untuk melakukan pelatihan model hingga menggunakannya untuk prediksi.
• Resampling: metode untuk memvalidasi model yang mencakup pembagian data seperti cross-validation, holdout, bootstrap, dan lainnya.

Selain itu, terdapat pula beberapa komponen lain yang juga penting, yaitu:

• Measure: metrik evaluasi seperti akurasi, AUC, logloss, dll
• Tuning: mekanisme untuk pencarian model terbaik melalui tuning hyperparameter
• Pipeline: untuk membangun workflow/tahapan secara lengkap mulai dari preprocessing hingga evaluasi model

Langkah pertama dalam mlr3 adalah membuat objek TaskClassif yang merepresentasikan tugas untuk pemodelan klasifikasi. Pastikan target klasifikasi bertipe faktor. Terdapat dua parameter penting yang perlu ditentukan, pertama backend yaitu data frame atau data.table yang menjadi input model, dan kedua adalah target yaitu nama kolom yang ingin diprediksi.

Data yang akan digunakan adalah dataset Heart Failure yang diunduh pada halaman berikut: Heart Failure Prediction Dataset.

library(mlr3)
library(mlr3verse)

# loading dataset
data_heart <- read.csv('https://raw.githubusercontent.com/sainsdataid/dataset/main/heart.csv')

# merubah tipe data output menjadi factor
data_heart$HeartDisease <- as.factor(data_heart$HeartDisease)

str(data)

head(data)

# Membuat Task model klasifikasi 
task <- TaskClassif$new(id = "heart", backend = data_heart, target = "HeartDisease")

task

# OUTPUT

'data.frame':	918 obs. of  12 variables:
 $ Age           : int  40 49 37 48 54 39 45 54 37 48 ...
 $ Sex           : chr  "M" "F" "M" "F" ...
 $ ChestPainType : chr  "ATA" "NAP" "ATA" "ASY" ...
 $ RestingBP     : int  140 160 130 138 150 120 130 110 140 120 ...
 $ Cholesterol   : int  289 180 283 214 195 339 237 208 207 284 ...
 $ FastingBS     : int  0 0 0 0 0 0 0 0 0 0 ...
 $ RestingECG    : chr  "Normal" "Normal" "ST" "Normal" ...
 $ MaxHR         : int  172 156 98 108 122 170 170 142 130 120 ...
 $ ExerciseAngina: chr  "N" "N" "N" "Y" ...
 $ Oldpeak       : num  0 1 0 1.5 0 0 0 0 1.5 0 ...
 $ ST_Slope      : chr  "Up" "Flat" "Up" "Flat" ...
 $ HeartDisease  : Factor w/ 2 levels "0","1": 1 2 1 2 1 1 1 1 2 1 ...


  Age Sex ChestPainType   ...   Oldpeak ST_Slope HeartDisease
1  40   M           ATA   ...   0.0       Up            0
2  49   F           NAP   ...   1.0     Flat            1
3  37   M           ATA   ...   0.0       Up            0
4  48   F           ASY   ...   1.5     Flat            1
5  54   M           NAP   ...   0.0       Up            0
6  39   M           NAP   ...   0.0       Up            0


• Target: HeartDisease
• Target classes: 0 (positive class, 45%), 1 (55%)
• Properties: twoclass
• Features (11):
  • int (5): Age, Cholesterol, FastingBS, MaxHR, RestingBP
  • chr (5): ChestPainType, ExerciseAngina, RestingECG, ST_Slope, Sex
  • dbl (1): Oldpeak

Langkah berikutnya adalah penentuan algoritma yang digunakan atau learner. mlr3 memiliki kamus learner yang bisa diakses melalui paket mlr_learners. Misalkan pada contoh ini, kita akan menggunakan paket ranger untuk membangun model random forest. Parameter predict_type = "prob" memungkinkan model memberikan output berupa probabilitas, yang berguna untuk evaluasi berbasis probabilitas, misalnya metrik AUC.

# Membuat learner model klasifikasi dengan random forest (dari paket ranger)
learner <- lrn("classif.ranger", predict_type = "prob")

Langkah validasi model dilakukan dengan membagi data menjadi set pelatihan dan pengujian. Pembagian data dilakukan dengan fungsi partition. Semudian lakukan pelatihan model random forest pada data latih dan evaluasi pada data uji. Untuk mengukur hasil evaluasi, terdapat berbagai metrik yang dapat digunakan misalnya akurasi

set.seed(42)

# Membagi data menjadi train-test (80-20)
split <- partition(task, ratio = 0.8)

train_set <- split$train
test_set <- split$test

# Latih model pada data latih
learner$train(task, row_ids = train_set)

# Prediksi pada data uji
prediction <- learner$predict(task, row_ids = test_set)

# Evaluasi dengan beberapa metrik
prediction$score(list(
  msr("classif.acc"),                               # mengukur nilai akurasi model
  msr("classif.auc")                                # mengukur nilai AUC model
))

# OUTPUT

classif.acc classif.auc 
  0.8967391   0.9546218

Selain metode holdout (train-test), kita juga dapat mengevaluasi model menggunakan teknik cross-validation (CV), misalnya dengan 5-fold CV. Teknik ini sangat bermanfaat saat ukuran data terbatas serta untuk mendapatkan estimasi nilai kinerja model yang lebih tergeneralisasi.

resampling <- rsmp("cv", folds = 5)
resampling$instantiate(task)

# Melakukan pemodelan dengan validasi silang
rr <- resample(task, learner, resampling, store_models = TRUE)

# Evaluasi dengan beberapa metrik
rr$aggregate(list(
  msr("classif.acc"),
  msr("classif.auc")
))

# OUTPUT

classif.acc classif.auc 
  0.8725410   0.9293403 

Pada bagian sebelumnya, kita membangun model random forest dengan menggunakan pengaturan default (berdasarkan paket ranger). Praktiknya, tentu kita dapat mengatur nilai-nilai hyperparameter model atau melakukan pencarian hyperparameter tersebut untuk mendapatkan kinerja model yang optimal.

Dalam algoritma random forest yang diimplementasikan oleh paket ranger, terdapat beberapa hyperparameter penting yang dapat disesuaikan untuk mengoptimalkan performa model. Tiga di antaranya adalah:

1. num.trees: jumlah pohon (trees) dalam model ensemble. Semakin banyak pohon, biasanya model menjadi lebih stabil tetapi juga pelatihan menjadi lebih lambat
2. min.node.size: jumlah minimum observasi yang dibutuhkan di tiap node terminal. Semakin kecil nilainya, semakin dalam pohon dan potensi overfitting meningkat
3. mtry: jumlah fitur yang dipilih secara acak untuk dipertimbangkan pada setiap split. Parameter ini akan mempengaruhi variasi antar pohon dan merupakan parameter kunci dalam Random Forest

Ketiga parameter ini (dan parameter lainnya dari ranger) tersedia dan dapat dituning melalui learner classif.ranger di mlr3.

Untuk melakukan tuning, mlr3 menyediakan fungsi tnr() (tuner) yang merupakan antarmuka untuk berbagai metode pencarian hyperparameter. Beberapa pilihan yang umum digunakan antara lain:

• grid_search: melakukan pencarian dengan menjelajahi seluruh kombinasi nilai dalam grid parameter yang ditentukan
• random_search: memilih kombinasi nilai secara acak dalam ruang parameter, cocok untuk ruang yang besar atau tidak beraturan.
• irace, mbo, hyperband: metode pencarian yang lebih canggih menggunakan algoritma seperti iterated racing, Bayesian optimization, dan bandit-based search. Metode ini membutuhkan instalasi tambahan tetapi dapat memberikan hasil lebih optimal lagi, terutama jika hyperparameter semakin kompleks.

Daftar lengkap metode tuning yang tersedia dapat diperoleh dengan perintah mlr_tuners$keys()

library(mlr3tuning)
library(paradox)

set.seed(42)

# Menentukan batas bawah dan batas atas setiap hyperparameter
search_space <- ps(
  num.trees = p_int(lower = 100, upper = 500),
  min.node.size = p_int(lower = 1, upper = 10),
  mtry = p_int(lower = 2, upper = 10)
)

# Membuat tuner dengan metode random search
# resolution = 5 -> setiap hyperparameter terdiri dari 5 nilai
tuner <- tnr("grid_search", resolution = 5)

# Membuat instance tuning untuk optimasi satu metrik (misalnya akurasi)
instance <- TuningInstanceSingleCrit$new(
  task = task$clone()$filter(rows = train_set),  # tuning hanya pada data latih
  learner = learner,
  resampling = rsmp("cv", folds = 3),            # validasi silang 3-fold
  measure = msr("classif.acc"),                  # metrik yang digunakan: akurasi
  search_space = search_space,
  terminator = trm("evals", n_evals = 20)        # batasi proses tuning hingga 20 kombinasi
)

# Menjalankan proses tuning
tuner$optimize(instance)

# OUTPUT

Proses tuning akan menghasilkan kombinasi parameter dengan performa terbaik berdasarkan batasan yang diberikan. Berikutnya, kita bisa menerapkannya kembali ke learner dan melatih ulang model pada seluruh data latih, serta mengevaluasinya pada data uji.

# Terapkan parameter terbaik hasil tuning
learner$param_set$values <- instance$result_learner_param_vals

# Menampilkan kombinasi optimal
instance$result_learner_param_vals

# Latih ulang model pada data latih dengan parameter terbaik
learner$train(task, row_ids = train_set)

# Prediksi pada data uji
prediction <- learner$predict(task, row_ids = test_set)

# Evaluasi model akhir pada data uji
prediction$score(list(
  msr("classif.acc"),
  msr("classif.auc")
))

# OUTPUT

$num.threads
[1] 1

$num.trees
[1] 400

$min.node.size
[1] 1

$mtry
[1] 4

classif.acc classif.auc 
  0.9076087   0.9528765  

• Dokumentasi mlr3: https://mlr3.mlr-org.com
• Dokumentasi mlr3tuning: https://mlr3tuning.mlr-org.com
• Dokumentasi paradox: https://paradox.mlr-org.com
• Referensi learner ranger di mlr3: https://mlr3learners.mlr-org.com/reference/mlr_learners_classif.ranger.html

• Membangun Model Machine Learning dengan tidymodels R
• Tuning Hyperparameter Model Random Forest dengan Bayesian Optimization di R
• Tuning Hyperparameter Model Random Forest dengan Bahasa R