Rule Fit.id

Diperbarui 2026-02-16 Baca 3 menit

Ringkasan

RuleFit mengekstrak aturan dari ensemble pohon lalu menggabungkannya dengan fitur asli dalam model linear sparse.
Regularisasi L1 memilih aturan dan fitur yang paling informatif sehingga interpretasi model lebih mudah.
Kedalaman aturan, jumlah aturan, dan kekuatan regularisasi sangat memengaruhi generalisasi serta sparsity model.

Intuisi #

RuleFit mengubah jalur pohon menjadi indikator if-then yang mudah dibaca, lalu memberi bobot linear pada indikator tersebut. Hasilnya adalah kombinasi fleksibilitas nonlinier dan interpretasi berbasis koefisien.

Penjelasan Rinci #

1. Ide (dengan rumus) #

Ekstrak aturan: setiap jalur menuju daun menjadi (r_j(x) \in {0,1}).
Tambahkan istilah linear ter-skala (z_k(x)).
Regresi linear dengan L1:

$$ \hat{y}(x) = \beta_0 + \sum_j \beta_j r_j(x) + \sum_k \gamma_k z_k(x) $$

Regularisasi L1 membuat model jarang (sparse) dan menyorot aturan penting.

2. Dataset (OpenML: house_sales) #

Data harga rumah King County (OpenML data_id=42092). Hanya kolom numerik yang dipakai.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import japanize_matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

dataset = fetch_openml(data_id=42092, as_frame=True)
X = dataset.data.select_dtypes("number").copy()
y = dataset.target.astype(float)

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

3. Melatih RuleFit #

Implementasi Python: christophM/rulefit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from rulefit import RuleFit
import warnings
warnings.simplefilter("ignore")

rf = RuleFit(max_rules=200, tree_random_state=27)
rf.fit(X_train.values, y_train.values, feature_names=list(X_train.columns))

pred_tr = rf.predict(X_train.values)
pred_te = rf.predict(X_test.values)

def report(y_true, y_pred, name):
    rmse = mean_squared_error(y_true, y_pred, squared=False)
    mae  = mean_absolute_error(y_true, y_pred)
    r2   = r2_score(y_true, y_pred)
    print(f"{name:8s}  RMSE={rmse:,.0f}  MAE={mae:,.0f}  R2={r2:.3f}")

report(y_train, pred_tr, "Train")
report(y_test,  pred_te, "Test")

4. Meninjau aturan penting #

1
2
3
rules = rf.get_rules()
rules = rules[rules.coef != 0].sort_values(by="importance", ascending=False)
rules.head(10)

rule: kondisi if-then (type=linear berarti istilah linear)
coef: koefisien regresi (satuan sama dengan target)
support: proporsi sampel yang memenuhi aturan
importance: skor gabungan berdasarkan koefisien dan support

5. Validasi dengan visualisasi #

1
2
3
4
5
6
7
plt.figure(figsize=(6, 5))
plt.scatter(X_train["sqft_above"], y_train, s=10, alpha=0.5)
plt.xlabel("sqft_above")
plt.ylabel("price")
plt.title("Hubungan sqft_above dan price")
plt.grid(alpha=0.3)
plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
rule_mask = X["sqft_living"].le(3935.0) & X["lat"].le(47.5315)

applicable_data = np.log(y[rule_mask])
not_applicable  = np.log(y[~rule_mask])

plt.figure(figsize=(8, 5))
plt.boxplot([applicable_data, not_applicable],
            labels=["Aturan terpenuhi", "Aturan tidak terpenuhi"])
plt.ylabel("log(price)")
plt.title("Distribusi harga berdasarkan aturan")
plt.grid(alpha=0.3)
plt.show()

6. Tips praktis #

Tangani outlier (Winsorize, clipping) untuk membuat aturan stabil.
Bersihkan kategori langka sebelum encoding satu-panas.
Transformasi target yang sangat miring (misal log(y)).
Batasi jumlah/kedalaman aturan agar mudah dibaca; tetapkan batas via validasi silang.
Rangkum aturan teratas dalam bahasa bisnis untuk laporan ringkas.

7. Referensi #

Friedman, J. H., & Popescu, B. E. (2008). Predictive Learning via Rule Ensembles. The Annals of Applied Statistics, 2(3), 916–954.
Christoph Molnar. (2020). Interpretable Machine Learning. https://christophm.github.io/interpretable-ml-book/rulefit.html