Gradient boosting

Ý tưởng: cộng dồn những bản vá

Mô hình cuối cùng là tổng của nhiều cây nhỏ:

trong đó $F_0$ là dự đoán ban đầu (ví dụ trung bình của $y$), mỗi $h_m$ là một cây nông, và $\nu \in (0, 1]$ là tốc độ học (learning rate, shrinkage).

Khác với random forest, các cây ở đây không độc lập: cây thứ $m$ được xây để sửa lỗi của $F_{m-1}$. Random forest giảm variance bằng cách trung bình nhiều cây sâu; boosting giảm bias bằng cách cộng dồn nhiều cây nông.

Với sai số bình phương: học phần dư

Với loss $L = \frac12(y - F)^2$, ở bước $m$ ta tính phần dư $r_i = y_i - F_{m-1}(\mathbf{x}_i)$, huấn luyện cây $h_m$ để dự đoán $r_i$, rồi cập nhật $F_m = F_{m-1} + \nu h_m$. Lưu ý dấu: ở đây phần dư là target trừ dự đoán, tức hướng cần sửa, ngược với bài 2.1.

Ví dụ $x = (1, 2, 3, 4)$, $y = (1, 2, 6, 7)$, $\nu = 0.5$, mỗi cây là một gốc cây (stump) chia một lần:

1. $F_0 = \bar y = 4$. Phần dư $r = (-3, -2, 2, 3)$. MSE $= 6.5$.
2. Stump tốt nhất cho $r$ chia giữa $x = 2$ và $x = 3$: lá trái dự đoán $-2.5$, lá phải $+2.5$.
3. $F_1 = 4 + 0.5 \cdot (-2.5, -2.5, 2.5, 2.5) = (2.75,\ 2.75,\ 5.25,\ 5.25)$. MSE $= 1.81$.

Phần dư mới $(-1.75, -0.75, 0.75, 1.75)$ nhỏ hơn hẳn, và cây thứ hai sẽ tiếp tục chia nhỏ chúng. Chọn $\nu = 1$ thì một bước giảm nhiều hơn, nhưng trên dữ liệu thật, bước nhỏ cùng nhiều cây thường tổng quát tốt hơn.

Tổng quát: gradient descent trong không gian hàm

Phần dư $y - F$ chính là $-\dfrac{\partial L}{\partial F}$ với loss bình phương. Friedman (2001) nhận ra điều này đúng cho mọi loss khả vi: thay vì phần dư, ta khớp cây vào gradient âm (pseudo-residuals)

Gradient descent ở bài 2.1 đi từng bước trong không gian tham số $\mathbf{w}$; gradient boosting đi từng bước trong không gian hàm, và mỗi bước là một cây. Đổi loss là đổi bài toán: log loss cho phân loại, Huber cho dữ liệu có outlier, các loss xếp hạng cho bài ranking.

XGBoost: thêm đạo hàm bậc hai và regularization

XGBoost (Chen và Guestrin, 2016) khai triển Taylor bậc hai của loss quanh $F_{m-1}$. Với mỗi mẫu, gọi $g_i$ và $h_i$ là đạo hàm bậc một và bậc hai của loss theo dự đoán. Nếu một lá $j$ chứa tập mẫu $I_j$, đặt $G_j = \sum_{i\in I_j} g_i$ và $H_j = \sum_{i \in I_j} h_i$. Khi đó giá trị tối ưu của lá và lợi ích khi chia một lá thành hai là

$\lambda$ là phạt L2 trên giá trị lá, $\gamma$ là “phí” cho mỗi lá mới: lại là “lỗi + phạt” của bài 2.2, lần này cài thẳng vào tiêu chí chia cây. Với loss bình phương, $g_i = F - y_i$ và $h_i = 1$, nên $w_j^\ast$ đúng là trung bình phần dư trong lá (co về 0 một chút nhờ $\lambda$).

Ba thư viện, ba điểm nhấn

Cả ba đều xử lý giá trị thiếu sẵn và có bản chạy GPU. Trong scikit-learn, HistGradientBoostingClassifier/Regressor theo cùng tinh thần với LightGBM.

Tham số và cách chỉnh

• learning_rate và n_estimators đi đôi với nhau: tốc độ học nhỏ cần nhiều cây hơn. Cách làm chuẩn: cố định learning_rate khoảng 0.03–0.1, đặt số cây thật lớn, dùng early stopping trên validation để thư viện tự dừng khi điểm không tăng nữa.
• Độ phức tạp từng cây: num_leaves (15–127) hoặc max_depth (4–8), cùng min_child_samples.
• Ngẫu nhiên hóa để giảm overfit: lấy mẫu dòng (subsample, bagging_fraction khoảng 0.7–0.9) và cột (colsample_bytree, feature_fraction khoảng 0.7–0.9).
• Regularization: reg_lambda, reg_alpha.

Khác random forest, boosting có thể overfit khi thêm cây. Đó là lý do early stopping gần như bắt buộc.

Một bản sửa nhìn được từng số

Cho bốn mẫu với target 1, 1, 3, 3. Mô hình ban đầu dự đoán trung bình là 2. Phần dư target trừ dự đoán là $-1, -1, 1, 1$: hai mẫu đầu cần hạ xuống, hai mẫu sau cần nâng lên. Bài 2.1 định nghĩa phần dư là dự đoán trừ target; ở đây đổi dấu để nó chỉ hướng cần sửa. Chép công thức từ tài liệu khác thì phải xem họ dùng quy ước nào, kẻo cập nhật ngược dấu.

import numpy as np
from sklearn.tree import DecisionTreeRegressor

xb = np.array([[0.], [1.], [2.], [3.]])
yb = np.array([1., 1., 3., 3.])
prediction = np.full(len(yb), yb.mean())
learning_rate = 0.5
for stage in range(3):
    residual_to_fix = yb - prediction
    correction = DecisionTreeRegressor(max_depth=1, random_state=0)
    correction.fit(xb, residual_to_fix)
    prediction = prediction + learning_rate * correction.predict(xb)
    mse_now = np.mean((prediction - yb) ** 2)
    print(stage + 1, prediction.tolist(), round(float(mse_now), 6))

Kết quả1 [1.5, 1.5, 2.5, 2.5] 0.25
2 [1.25, 1.25, 2.75, 2.75] 0.0625
3 [1.125, 1.125, 2.875, 2.875] 0.015625

Lần đầu mô hình đi từ 2 về 1.5 hoặc 2.5. Phần còn thiếu chỉ bằng một nửa nên vòng sau dự đoán 1.25 hoặc 2.75. MSE giảm 1 → 0.25 → 0.0625 → 0.015625. Đây là dữ liệu hoàn hảo cho stump, không có nhiễu; thêm nhiều cây trên dữ liệu thật có thể tiếp tục giảm train loss nhưng làm validation xấu đi.

Theo dõi validation theo số cây

Ta cần xem hai đường loss chứ không chỉ số cuối cùng. Với GradientBoostingRegressor, staged_predict trả dự đoán sau từng vòng, nên một lần fit cho cả đường cong và mô hình tốt có thể nằm trước vòng cuối. Thí nghiệm dưới dùng dữ liệu phi tuyến có nhiễu lớn và cây sâu 3, đủ để thấy boosting học thuộc.

from sklearn.datasets import make_friedman1
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split

X_stage, y_stage = make_friedman1(n_samples=250, noise=4.0, random_state=3)   # phi tuyến, nhiễu lớn
X_train, X_valid, y_train, y_valid = train_test_split(X_stage, y_stage, test_size=0.3, random_state=8)
boost = GradientBoostingRegressor(n_estimators=300, max_depth=3, learning_rate=0.1, random_state=0)
boost.fit(X_train, y_train)
train_losses = [np.mean((pred - y_train) ** 2) for pred in boost.staged_predict(X_train)]
valid_losses = [np.mean((pred - y_valid) ** 2) for pred in boost.staged_predict(X_valid)]
best_round = int(np.argmin(valid_losses)) + 1
print("vòng chọn:", best_round)
print("MSE train, vòng chọn và vòng cuối:", round(float(train_losses[best_round - 1]), 2), round(float(train_losses[-1]), 2))
print("MSE valid, vòng chọn và vòng cuối:", round(float(valid_losses[best_round - 1]), 2), round(float(valid_losses[-1]), 2))

Kết quảvòng chọn: 31
MSE train, vòng chọn và vòng cuối: 6.84 0.08
MSE valid, vòng chọn và vòng cuối: 20.86 23.05

Train MSE đi từ $6.84$ ở vòng 31 xuống $0.08$ ở vòng 300: mô hình gần như thuộc lòng 175 mẫu train. Validation thấp nhất ở vòng 31 ($20.86$), rồi tăng lên $23.05$: 269 cây cuối chủ yếu học nhiễu. Nếu cứ chạy hết 300 vòng, ta trả thêm thời gian để có mô hình tệ hơn khoảng 10%. Vì vòng 31 được chọn bằng chính tập validation này, con số $20.86$ hơi lạc quan; muốn ước lượng độc lập cần một test để riêng.

Dùng thư viện

from sklearn.datasets import make_friedman1
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.model_selection import train_test_split

X, y = make_friedman1(n_samples=5000, noise=1.0, random_state=0)   # quan hệ phi tuyến có tương tác
X_tr, X_va, y_tr, y_va = train_test_split(X, y, test_size=0.2, random_state=0)
model = HistGradientBoostingRegressor(learning_rate=0.05, max_iter=2000, max_leaf_nodes=31,
                                      early_stopping=True, validation_fraction=0.1,
                                      n_iter_no_change=50, random_state=0)
model.fit(X_tr, y_tr)
print("số cây:", model.n_iter_, " R2 validation:", round(model.score(X_va, y_va), 3))

Kết quảsố cây: 285  R2 validation: 0.944

Với LightGBM, đoạn tương đương là LGBMRegressor(learning_rate=0.05, n_estimators=5000, num_leaves=31) kèm callbacks=[lightgbm.early_stopping(100)] khi fit.

LightGBM trong khuôn K-fold

Đề bảng thường cho train có nhãn và test không nhãn. Chia train thành $K$ fold; mỗi fold học trên $K-1$ phần, phần còn lại dùng cho early stopping và để chấm. Mỗi dòng train được dự đoán đúng một lần bởi model chưa thấy nó; gom lại là dự đoán out-of-fold (OOF). Dự đoán cho test là trung bình $K$ model.

Dữ liệu dưới có tám cột số và cột city kiểu category; LightGBM nhận thẳng, không cần one-hot.

import numpy as np
import pandas as pd
import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score

X_num, y = make_classification(n_samples=3000, n_features=8, n_informative=5, flip_y=0.08, random_state=1)
rng = np.random.default_rng(1)
df = pd.DataFrame(X_num, columns=[f"f{i}" for i in range(8)])
df["city"] = rng.choice(["HN", "HCM", "DN", "HP", "CT"], size=len(df))
y = np.where(df["city"].isin(["HN", "DN"]) & (rng.random(len(df)) < 0.25), 1, y)   # thành phố có ảnh hưởng thật
df["city"] = df["city"].astype("category")
train, test = df.iloc[:2400], df.iloc[2400:]
y_train, y_test = y[:2400], y[2400:]

folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
oof = np.zeros(len(train))
test_pred = np.zeros(len(test))
for k, (tr, va) in enumerate(folds.split(train, y_train)):
    model = lgb.LGBMClassifier(learning_rate=0.05, n_estimators=2000, num_leaves=15,
                               subsample=0.8, subsample_freq=1, colsample_bytree=0.8,
                               random_state=0, verbose=-1, n_jobs=1)
    model.fit(train.iloc[tr], y_train[tr], eval_set=[(train.iloc[va], y_train[va])],
              eval_metric="auc", callbacks=[lgb.early_stopping(100, verbose=False)])
    oof[va] = model.predict_proba(train.iloc[va])[:, 1]
    test_pred += model.predict_proba(test)[:, 1] / folds.n_splits
    print(f"fold {k}: cây tốt nhất {model.best_iteration_}, AUC {roc_auc_score(y_train[va], oof[va]):.3f}")
print("AUC out-of-fold:", round(roc_auc_score(y_train, oof), 3))
print("AUC test (trung bình 5 model):", round(roc_auc_score(y_test, test_pred), 3))

Kết quảfold 0: cây tốt nhất 104, AUC 0.929
fold 1: cây tốt nhất 98, AUC 0.898
fold 2: cây tốt nhất 79, AUC 0.920
fold 3: cây tốt nhất 74, AUC 0.905
fold 4: cây tốt nhất 89, AUC 0.934
AUC out-of-fold: 0.917
AUC test (trung bình 5 model): 0.923

Mỗi fold chọn số cây riêng (74 đến 104); n_estimators=2000 chỉ là trần. AUC từng fold lệch nhau tới 0.036, nên một lần chia train/valid có thể sai cỡ ±0.02. Điểm OOF 0.917 gộp cả 2400 dòng và sát điểm test 0.923. Khi thử đặc trưng hay tham số mới, so điểm OOF, không so điểm một fold.

Sau early stopping, predict_proba tự dùng số cây tốt nhất. Mảng oof còn dùng để trộn model, vì không model nào đã thấy nhãn của dòng mình dự đoán.

Với XGBoost chỉ cần thay model; giữ nguyên folds để hai bộ OOF so được từng dòng:

import xgboost as xgb

oof_xgb = np.zeros(len(train))
for k, (tr, va) in enumerate(folds.split(train, y_train)):
    model = xgb.XGBClassifier(learning_rate=0.05, n_estimators=2000, max_depth=4, subsample=0.8,
                              colsample_bytree=0.8, enable_categorical=True, tree_method="hist",
                              early_stopping_rounds=100, eval_metric="auc", random_state=0, n_jobs=1)
    model.fit(train.iloc[tr], y_train[tr], eval_set=[(train.iloc[va], y_train[va])], verbose=False)
    oof_xgb[va] = model.predict_proba(train.iloc[va])[:, 1]
print("AUC OOF XGBoost:", round(roc_auc_score(y_train, oof_xgb), 3))
print("AUC OOF trung bình hai thư viện:", round(roc_auc_score(y_train, (oof + oof_xgb) / 2), 3))

Kết quảAUC OOF XGBoost: 0.918
AUC OOF trung bình hai thư viện: 0.919

Trung bình hai bộ OOF chỉ tăng 0.001: hai model cùng loại cây, cùng đặc trưng nên sai ở những dòng giống nhau. Trộn có lợi khi các model sai ở chỗ khác nhau (bài 8.4). Mức tăng nhỏ như vậy còn dưới độ dao động giữa các seed.

enable_categorical=True cho XGBoost đọc cột category, đi cùng tree_method="hist". CatBoost nhận cột phân loại qua cat_features; máy chưa có thì pip install catboost.