Memahami Algoritma Random Forest dari Teori sampai Implementasi dengan Scikit-learn untuk Klasifikasi dan Regresi

Ensemble Learning dan Konsep Dasar Random Forest

Dalam machine learning, tidak ada satu algoritma pun yang selalu unggul di semua skenario. Pendekatan ensemble learning muncul untuk menjawab tantangan ini — alih-alih mengandalkan satu model, kita menggabungkan beberapa model untuk mendapatkan prediksi yang lebih akurat dan stabil. Random Forest adalah salah satu implementasi ensemble learning yang paling populer, termasuk dalam kategori _bagging_ (Bootstrap Aggregating).

Konsep dasarnya sederhana: Random Forest membangun banyak decision tree pada subset data yang berbeda, lalu menggabungkan hasil prediksi mereka. Untuk tugas klasifikasi, Random Forest menggunakan mekanisme _voting_ — setiap pohon memberikan suara, dan kelas dengan suara terbanyak menjadi prediksi akhir. Untuk tugas regresi, hasilnya adalah rata-rata dari prediksi seluruh pohon.

Keunggulan utama Random Forest dibanding decision tree tunggal terletak pada kemampuannya mengurangi _overfitting_. Decision tree cenderung belajar terlalu dalam pada data latih, sehingga performanya buruk pada data baru. Random Forest mengatasi ini melalui variasi antar pohon yang dihasilkan oleh _bootstrap sampling_ dan _random feature selection_. Algoritma ini juga mampu menangani data non-linear, memberikan _feature importance_ untuk interpretasi model, dan cukup robust terhadap outlier.

Gambar: Perbandingan visual antara decision tree tunggal dan random forest dengan banyak pohon — Sumber: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Decision_Tree_vs._Random_Forest.png)

Bagaimana Random Forest Membangun Pohon Keputusannya

Proses pembangunan Random Forest melibatkan dua mekanisme utama yang memastikan setiap pohon dalam hutan berbeda satu sama lain.

Pertama, _bootstrap sampling_. Setiap pohon dilatih pada dataset yang dibuat dengan mengambil sampel acak dari data asli dengan pengembalian (_with replacement_). Artinya, satu instance data bisa muncul lebih dari sekali dalam satu sampel, sementara instance lainnya mungkin tidak terpilih sama sekali. Instance yang tidak terpilih ini disebut _out-of-bag_ (OOB) samples, dan dapat digunakan sebagai validation set internal — kita bisa mengukur error tanpa perlu membagi data secara terpisah.

Kedua, _random feature selection_. Pada setiap percabangan (_split_) dalam decision tree, algoritma tidak mempertimbangkan seluruh fitur yang tersedia. Sebaliknya, ia memilih secara acak subset fitur (sebanyak max_features) dan memilih fitur terbaik dari subset tersebut untuk melakukan split. Parameter max_features umumnya diatur ke sqrt(n_features) untuk klasifikasi dan n_features/3 untuk regresi.

Kombinasi kedua teknik ini menghasilkan pohon-pohon yang cukup beragam — masing-masing melihat data dari sudut pandang berbeda. Ketika semua pohon selesai dilatih, prediksi akhir dihasilkan melalui mekanisme voting (mayoritas) untuk klasifikasi atau averaging (rata-rata) untuk regresi. Inilah mengapa Random Forest mampu menghasilkan prediksi yang lebih stabil dan akurat dibandingkan decision tree tunggal.

Gambar: Ilustrasi algoritma Random Forest yang terdiri dari banyak decision tree dengan bootstrap sampling dan voting — Sumber: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Random_forest_explain.png)

Implementasi Random Forest untuk Klasifikasi dengan Scikit-learn

Mari kita praktikkan implementasi Random Forest untuk tugas klasifikasi menggunakan Scikit-learn. Kita akan menggunakan dataset Iris yang sudah tersedia di library tersebut.

!pip install scikit-learn matplotlib seaborn

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Load dataset
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Build Random Forest model
rf_clf = RandomForestClassifier(
    n_estimators=100,
    max_depth=None,
    random_state=42
)
rf_clf.fit(X_train, y_train)

# Predict and evaluate
y_pred = rf_clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Akurasi: {accuracy:.4f}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=target_names))

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=target_names, yticklabels=target_names)
plt.title('Confusion Matrix - Random Forest Iris')
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()

# Feature importance
importances = rf_clf.feature_importances_
indices = np.argsort(importances)[::-1]

plt.figure(figsize=(8, 5))
plt.title('Feature Importance - Random Forest')
plt.bar(range(len(importances)), importances[indices])
plt.xticks(range(len(importances)), [feature_names[i] for i in indices])
plt.tight_layout()
plt.show()

Output:

Akurasi: 0.9000

Classification Report:
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       0.82      0.90      0.86        10
   virginica       0.89      0.80      0.84        10

    accuracy                           0.90        30
   macro avg       0.90      0.90      0.90        30
weighted avg       0.90      0.90      0.90        30

Setelah menjalankan kode di atas, kita melihat akurasi model mencapai 90% pada test set dengan classification report yang menampilkan precision, recall, dan f1-score untuk setiap kelas. Confusion matrix memberikan gambaran visual tentang distribusi prediksi yang benar dan salah. Feature importance menunjukkan fitur mana yang paling berpengaruh dalam pengambilan keputusan — informasi berharga ketika kita ingin memahami faktor dominan dalam dataset.

Menerapkan Random Forest untuk Tugas Regresi

Random Forest juga dapat digunakan untuk tugas regresi, yaitu memprediksi nilai kontinu seperti harga rumah atau suhu. Perbedaan utamanya terletak pada mekanisme prediksi akhir: regresi menggunakan rata-rata dari seluruh pohon, bukan voting.

!pip install scikit-learn matplotlib seaborn

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score

# Load dataset
housing = fetch_california_housing()
X = housing.data
y = housing.target
feature_names = housing.feature_names

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Build Random Forest Regressor
rf_reg = RandomForestRegressor(
    n_estimators=100,
    max_depth=15,
    random_state=42
)
rf_reg.fit(X_train, y_train)

# Predict and evaluate
y_pred = rf_reg.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"MSE: {mse:.4f}")
print(f"R² Score: {r2:.4f}")

# Actual vs Predicted scatter
plt.figure(figsize=(7, 6))
plt.scatter(y_test, y_pred, alpha=0.5, s=10)
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2)
plt.xlabel('Actual Price')
plt.ylabel('Predicted Price')
plt.title('Actual vs Predicted - Random Forest Regressor')
plt.tight_layout()
plt.show()

Output:

MSE: 0.2613
R² Score: 0.8006

Kode ini menunjukkan bahwa Random Forest Regressor mampu memprediksi nilai kontinu dengan cukup baik, terlihat dari nilai R² sebesar 0.80. Scatter plot perbandingan prediksi vs aktual membantu kita memvalidasi secara visual seberapa dekat prediksi model dengan nilai sebenarnya.

Hyperparameter Tuning untuk Performa Maksimal

Meskipun Random Forest memiliki performa yang baik secara default, kita bisa meningkatkan akurasinya secara signifikan melalui hyperparameter tuning. Parameter utama yang perlu diperhatikan meliputi:

• n_estimators: jumlah pohon dalam forest. Semakin banyak umumnya semakin baik, tapi dengan _diminishing returns_.
• max_depth: kedalaman maksimum setiap pohon. Membatasi kedalaman membantu mencegah overfitting.
• min_samples_split: jumlah minimum sampel yang diperlukan untuk melakukan split internal.
• min_samples_leaf: jumlah minimum sampel yang harus ada di leaf node.
• max_features: jumlah fitur yang dipertimbangkan untuk setiap split.

Kita bisa menggunakan RandomizedSearchCV untuk mencari kombinasi parameter terbaik secara efisien.

!pip install scikit-learn

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Load data
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# Define parameter grid
param_dist = {
    'n_estimators': [50, 100, 200, 300],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
    'max_features': ['sqrt', 'log2']
}

# Randomized search
rf_base = RandomForestClassifier(random_state=42)
random_search = RandomizedSearchCV(
    rf_base, param_distributions=param_dist,
    n_iter=20, cv=5, scoring='accuracy',
    random_state=42, n_jobs=-1
)
random_search.fit(X_train, y_train)

print(f"Best Parameters: {random_search.best_params_}")
print(f"Best CV Score: {random_search.best_score_:.4f}")

# Evaluate on test set
best_rf = random_search.best_estimator_
y_pred = best_rf.predict(X_test)
test_acc = accuracy_score(y_test, y_pred)
print(f"Test Accuracy (after tuning): {test_acc:.4f}")

# Compare with default
rf_default = RandomForestClassifier(random_state=42)
rf_default.fit(X_train, y_train)
y_pred_default = rf_default.predict(X_test)
default_acc = accuracy_score(y_test, y_pred_default)
print(f"Test Accuracy (default): {default_acc:.4f}")

Output:

Best Parameters: {'n_estimators': 300, 'min_samples_split': 2, 'min_samples_leaf': 2, 'max_features': 'log2', 'max_depth': 15}
Best CV Score: 0.9583
Test Accuracy (after tuning): 1.0000
Test Accuracy (default): 1.0000

Dengan tuning, kita mendapatkan parameter optimal yang meningkatkan skor validasi silang. Pada dataset Iris yang relatif sederhana, baik model default maupun model yang di-tuning sama-sama mencapai akurasi sempurna — namun pada dataset yang lebih kompleks, perbedaan performa akan terlihat lebih signifikan.

Kelebihan, Kekurangan, dan Kapan Menggunakan Random Forest

Random Forest memiliki beberapa kelebihan yang membuatnya menjadi pilihan utama dalam banyak kompetisi machine learning. Algoritma ini robust terhadap outliers karena setiap pohon hanya melihat subset data, tidak memerlukan scaling atau normalisasi fitur karena berbasis threshold, dan cukup toleran terhadap missing values. Selain itu, Random Forest memberikan _feature importance_ secara bawaan yang memudahkan interpretasi.

Namun, Random Forest juga memiliki keterbatasan. Ukuran model bisa sangat besar karena menyimpan seluruh pohon, sehingga membutuhkan memori yang signifikan. Waktu inference juga lebih lambat dibanding model sederhana seperti logistic regression — setiap prediksi harus melewati ratusan pohon. Dari segi interpretabilitas, Random Forest lebih sulit dijelaskan dibandingkan decision tree tunggal karena kita tidak bisa melacak jalur keputusan dari satu pohon saja.

Kapan sebaiknya menggunakan Random Forest? Algoritma ini sangat cocok untuk dataset dengan dimensi sedang (puluhan hingga ratusan fitur), ketika hubungan antara fitur dan target bersifat non-linear, dan ketika kita membutuhkan model yang cukup akurat tanpa menghabiskan terlalu banyak waktu untuk tuning. Untuk dataset yang sangat besar atau ketika kecepatan inference menjadi prioritas, algoritma seperti XGBoost atau LightGBM bisa menjadi alternatif yang lebih baik.

Tertarik memperdalam Machine Learning lebih lanjut? Rumah Coding menyediakan bootcamp dan bimbingan yang mencakup ensemble methods, hyperparameter tuning, hingga deployment model ke production. Mulailah perjalanan Anda dari dasar hingga siap menghadapi tantangan data di dunia nyata.