5.5. Gradient Boosting và XGBoost Regression 

5.5.1. Triết lý Boosting: "Học từ những sai lầm"

Gradient Boosting là một thuật toán thuộc nhóm Học kết hợp (Ensemble Learning), được thiết kế để kết hợp nhiều mô hình yếu (Weak Learners) – thường là các cây quyết định đơn giản – thành một siêu mô hình dự báo mạnh mẽ (Strong Learner). Điểm làm nên sự khác biệt và sức mạnh tuyệt đối của phương pháp này nằm ở triết lý học tập của nó.

1. Phân biệt Bagging (Rừng ngẫu nhiên) và Boosting Để hiểu rõ bản chất của Boosting, chúng ta cần đặt nó lên bàn cân so sánh với phương pháp Bagging (mà đại diện tiêu biểu là Random Forest):

• Bagging (Rừng ngẫu nhiên): Hoạt động theo cơ chế xây dựng các cây song song và hoàn toàn độc lập với nhau. Triết lý của Bagging là "nhiều chuyên gia độc lập", mô hình sẽ gom kết quả dự báo của tất cả các cây lại rồi lấy trung bình cộng để đưa ra kết quả cuối cùng, qua đó giúp làm giảm phương sai.

• Boosting: Hoạt động theo cơ chế huấn luyện cây tuần tự (sequentially), nghĩa là cây phía sau được sinh ra dựa trên kết quả và sai sót của cây phía trước. Triết lý cốt lõi của Boosting chính là "học từ những sai lầm, cải thiện dần".

💡 Ví dụ trực quan: Nếu Bagging giống như việc bạn mời 100 học sinh cùng giải một bài toán rồi lấy đáp án số đông, thì Boosting lại giống hệt như quá trình một học sinh ôn thi: lần đầu làm đề, học sinh đó ghi lại các câu làm sai; lần hai, thay vì học lại từ đầu, học sinh chỉ tập trung vào việc học cách giải đúng những câu đã sai đó; lần ba lại tiếp tục rà soát xem còn sai sót gì nhỏ hơn không... Cứ thế cải thiện dần cho đến khi đạt điểm tối đa.

2. Cơ chế xây dựng mô hình tuần tự: Cây mới sinh ra để sửa lỗi (Phần dư - Residuals) Trong thuật toán Gradient Boosting, thay vì để mỗi cây tự cố gắng dự báo trực tiếp giá trị mục tiêu $y$, thuật toán áp dụng một kỷ luật học tập nối tiếp cực kỳ khắt khe: mỗi cây mới ra đời chỉ gánh vác duy nhất nhiệm vụ học phần lỗi còn lại (Residuals hoặc Errors) mà tập hợp các cây phía trước chưa giải quyết được.

Về mặt toán học, Gradient Boosting tổng quát hóa ý tưởng này dưới dạng thuật toán Gradient Descent trong không gian hàm. Cụ thể, tại mỗi vòng lặp, cơ chế này diễn ra như sau:

• Bước 1: Mô hình hiện tại đưa ra một dự báo dựa trên sự tích hợp của các cây trước đó.

• Bước 2: Hệ thống tính toán độ dốc (Gradient) của hàm mất mát. Đối với bài toán hồi quy sử dụng hàm mất mát là Sai số bình phương trung bình (MSE), gradient âm này chính là phần dư (residual): r_im = y_i - F_m-1(x_i). Nó cho biết mô hình đang sai ở đâu và lệch bao nhiêu so với thực tế.

• Bước 3: Huấn luyện một cây quyết định mới (thường là cây nông) bám theo đúng hướng gradient đó, tức là "fit" (khớp) trực tiếp vào phần dư.

• Bước 4: Cập nhật lại mô hình tổng thể bằng cách lấy mô hình cũ cộng thêm kết quả dự báo của cây mới vừa tạo.

Quá trình sửa sai này diễn ra liên tục qua từng bước. Do đó, kết quả dự báo (Prediction) cuối cùng thu được chính là tổng các kết quả dự báo của tất cả các cây trong hệ thống cộng lại. Nhờ bám sát và liên tục triệt tiêu các sai số của thế hệ trước, mô hình Gradient Boosting đạt được sức mạnh hội tụ rất nhanh và mang lại độ chính xác dự báo vượt trội.

Thay vì cộng toàn bộ giá trị dự báo của cây mới, mô hình chỉ lấy một tỷ lệ nhỏ bằng với Learning Rate. Vai trò của Learning Rate vô cùng quan trọng:

• Học chậm nhưng chắc: Một Learning Rate nhỏ buộc thuật toán phải đi từng bước cẩn thận hơn, kìm hãm tốc độ cập nhật để tránh việc phản ứng thái quá với các sai số của cây trước đó.

• Cân bằng Bias-Variance: Việc hãm tốc độ học giúp mô hình khái quát hóa (generalize) tốt hơn trên dữ liệu kiểm thử, mang lại hiệu quả dự báo cao hơn. Tuy nhiên, sự đánh đổi ở đây là bạn sẽ cần phải xây dựng một số lượng cây nhiều hơn (thiết lập tham số n_estimators lớn hơn) để mô hình có thể đạt được độ chính xác mong muốn.

5.5.3. Sự tiến hóa mang tên XGBoost (Extreme Gradient Boosting)

XGBoost (Extreme Gradient Boosting) được phát triển bởi Chen & Guestrin (2016) và nhanh chóng khẳng định vị thế là một trong những thuật toán học máy mạnh mẽ nhất hiện nay đối với dữ liệu dạng bảng (tabular data). Đây là phiên bản cải tiến vượt bậc của Gradient Boosting Decision Trees (GBDT) truyền thống, được thiết kế tối ưu nhằm gia tăng độ chính xác, tăng tốc độ huấn luyện và đặc biệt là giảm thiểu tối đa hiện tượng "Quá khớp" (Overfitting).

Sự vượt trội của XGBoost đến từ hai cải tiến cốt lõi về mặt toán học và cấu trúc sau đây:

1. Tối ưu hóa bậc hai (Second-Order Optimization) giúp hội tụ nhanh hơn Trong thuật toán GBDT truyền thống, mô hình chủ yếu sử dụng đạo hàm bậc nhất (Gradient) của hàm mất mát để định hướng sửa lỗi. Tuy nhiên, XGBoost đã tạo ra một bước tiến quan trọng khi áp dụng chuỗi khai triển Taylor bậc hai (Second-Order Taylor Expansion) để xấp xỉ hàm mục tiêu. Điều này có nghĩa là XGBoost sử dụng đồng thời cả thông tin từ đạo hàm bậc nhất (Gradient) và đạo hàm bậc hai (Hessian).

Để dễ hình dung, quá trình này tương tự như việc bạn đang lái xe: Gradient đóng vai trò chỉ cho bạn biết hướng cần rẽ, trong khi Hessian cung cấp thêm thông tin chi tiết về độ dốc và lộ trình an toàn, giúp bạn nhận định chính xác khi nào có thể tăng tốc và khi nào cần phanh kịp thời. Sự kết hợp toán học này mang lại lợi thế khổng lồ:

• Tốc độ hội tụ (Convergence) của mô hình trở nên nhanh hơn rất nhiều.

• Quá trình tối ưu hóa diễn ra cực kỳ ổn định, giúp thuật toán dễ dàng tránh được các bẫy cực tiểu cục bộ (local minima) để đạt được độ chính xác cao hơn.

2. Tích hợp kỹ thuật Regularization (L1, L2) trực tiếp vào Hàm mục tiêu Điểm cải tiến mang tính đột phá thứ hai của XGBoost chính là việc đưa trực tiếp thành phần Chính quy hóa (Regularization term) vào bên trong Hàm mục tiêu (Objective Function). Khi đó, hàm mục tiêu của XGBoost luôn phải giữ một sự cân bằng khắt khe giữa hai yếu tố:

• Hàm Loss: Đảm bảo độ chính xác của mô hình (khớp với dữ liệu huấn luyện).

• Thành phần Regularization: Đo lường và trừng phạt độ phức tạp của các cây quyết định.

Cụ thể, XGBoost áp dụng đồng thời các kỹ thuật L1 và L2 Regularization để phạt trực tiếp vào các trọng số tại các nút lá (Leaf Nodes). Cơ chế này ngăn chặn việc một số nút lá chiếm trọng số quá cực đoan, đồng thời trừng phạt các cây có cấu trúc quá sâu hoặc có quá nhiều nút lá. Bằng cách tự động kiểm soát chặt chẽ độ phức tạp của cây ngay từ trong quá trình học, XGBoost hạn chế tối đa thảm họa Overfitting và gia tăng mạnh mẽ khả năng tổng quát hóa (Generalization) khi mô hình dự báo trên các tập dữ liệu mới trong thực tế.

5.5.4. 💻 Ví dụ Code thực chiến: Dự đoán giá nhà (House Price Prediction)

Trong lĩnh vực định giá bất động sản, việc xây dựng mô hình dự báo chính xác có ý nghĩa sống còn đối với các nhà đầu tư và tổ chức tài chính. Ở ví dụ này, chúng ta sẽ sử dụng bộ dữ liệu kinh điển House Prices - Advanced Regression Techniques (tải xuống). Mục tiêu là đối chiếu hiệu suất của các siêu thuật toán học kết hợp (Gradient Boosting, XGBoost) với mô hình cơ sở là Hồi quy tuyến tính (Linear Regression).

1. Kỷ luật Tiền xử lý dữ liệu đặc thù: Biến đổi Logarit (Log-transform) Một đặc điểm phổ biến của bộ dữ liệu giá nhà là biến mục tiêu SalePrice (Giá nhà) có phân phối lệch phải (Right-skewed) cực kỳ mạnh,. Phần lớn các căn nhà nằm ở mức giá phổ thông, nhưng lại tồn tại một số ít các siêu biệt thự có giá cao bất thường. Nếu đưa trực tiếp dữ liệu thô này vào mô hình, thuật toán sẽ bị "kéo lệch" bởi các giá trị ngoại lai, làm tăng sai số dự báo tổng thể,.

Để khắc phục, kỹ thuật chuẩn mực là áp dụng phép biến đổi Logarit tự nhiên np.log1p() cho biến SalePrice,. Kỹ thuật này giúp "nén" các giá trị cực đoan lại, kéo phân phối của giá nhà về gần với dạng phân phối chuẩn, giúp mô hình học ổn định hơn và đáp ứng tiêu chí đánh giá sai số logarit của Kaggle. Các giá trị khuyết thiếu trong biến định lượng sẽ được điền bằng giá trị trung vị (median).

2. Triển khai Mã nguồn Python hoàn chỉnh

Lưu ý cho độc giả: Đảm bảo tệp train.csv của bộ dữ liệu House Prices đã được lưu trong cùng thư mục với notebook. Trong ví dụ này, chúng ta chủ ý trích xuất 6 biến định lượng cơ bản có tương quan tuyến tính mạnh với giá nhà để minh họa.

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.ensemble import GradientBoostingRegressor

from xgboost import XGBRegressor

from sklearn.metrics import mean_squared_error, r2_score

# =====================================================================

# BƯỚC 1: ĐỌC VÀ TIỀN XỬ LÝ DỮ LIỆU

# =====================================================================

# Đọc file dữ liệu House Prices

df = pd.read_csv('https://drive.google.com/uc?export=download&id=1coggcvNOfUQxRCu4LXqArbLdMnODN3rN')

# Trích xuất nhanh một số đặc trưng định lượng quan trọng nhất để minh họa

features = ['OverallQual', 'GrLivArea', 'TotalBsmtSF', 'GarageCars', '1stFlrSF', 'YearBuilt']

X = df[features].copy()

# Điền giá trị khuyết thiếu bằng trung vị (Median)

X.fillna(X.median(), inplace=True)

# =====================================================================

# BƯỚC 2: TIỀN XỬ LÝ ĐẶC THÙ (LOG-TRANSFORM)

# =====================================================================

# Biến đổi Logarit giá nhà để giảm độ lệch phải (Skewness)

y_log = np.log1p(df['SalePrice'])

# Chia tập Train/Test (80% huấn luyện, 20% kiểm tra)

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

# =====================================================================

# BƯỚC 3: KHỞI TẠO VÀ HUẤN LUYỆN CÁC MÔ HÌNH

# =====================================================================

models = {

    "Linear Regression"   : LinearRegression(),

    "Gradient Boosting"   : GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, random_state=42),

    "XGBoost Regression"  : XGBRegressor(n_estimators=100, learning_rate=0.1, random_state=42, objective='reg:squarederror')

}

# =====================================================================

# BƯỚC 4: ĐÁNH GIÁ VÀ SO SÁNH (RMSE & R2)

# =====================================================================

print("--- KẾT QUẢ ĐÁNH GIÁ MÔ HÌNH (TRÊN THANG ĐO LOGARIT) ---")

for name, model in models.items():

    # Huấn luyện mô hình

    model.fit(X_train, y_train)

    # Dự báo trên tập Test

    y_pred_log = model.predict(X_test)

    # Đánh giá bằng RMSE và Hệ số xác định R2

    rmse_log = np.sqrt(mean_squared_error(y_test, y_pred_log))

    r2 = r2_score(y_test, y_pred_log)

    print(f"[{name}]")

    print(f" - RMSE (Log): {rmse_log:.4f}")

    print(f" - R2 Score  : {r2:.4f}\n")

3. Phân tích kết quả: Nghịch lý của sự phức tạp (Model Complexity Paradox)

Khi thực thi đoạn mã trên, người học thường kỳ vọng XGBoost sẽ chiến thắng tuyệt đối. Tuy nhiên, kết quả thực nghiệm có thể cho thấy Hồi quy tuyến tính (Linear Regression) đạt R^2 = 0.8383, bám sát hoặc đôi khi nhỉnh hơn mức 0.8375 của XGBoost mặc định.

Đây là một bài học thực chiến kinh điển trong Khoa học Dữ liệu, được giải thích qua các nguyên lý quản trị dữ liệu sau:

• Đặc tính của dữ liệu định đoạt mô hình: Trong đoạn code trên, chúng ta đã cố tình thu gọn bài toán bằng cách chỉ sử dụng 6 biến định lượng (như Chất lượng tổng thể, Diện tích, …). Đây đều là những đặc trưng có mối quan hệ tuyến tính vô cùng mạnh mẽ với giá nhà. Khi dữ liệu mang cấu trúc gần tuyến tính hoàn hảo, một mô hình đơn giản như Hồi quy tuyến tính là hoàn toàn đủ năng lực để mô tả xuất sắc xu hướng chính, giúp nó đạt hiệu suất cực cao,.

• Cái bẫy Quá khớp (Overfitting) của thuật toán mạnh: Khi áp dụng các siêu thuật toán phân nhánh cây như XGBoost vào một không gian dữ liệu đã bị đơn giản hóa, cỗ máy này có xu hướng học quá sâu vào các chi tiết nhỏ lẻ, dẫn đến việc ghi nhớ cả những "điểm nhiễu" (noise) cục bộ thay vì xu hướng chung,. Việc lựa chọn mô hình không nên chỉ dựa vào mức độ phức tạp của thuật toán, mà phải dựa trên đặc điểm cụ thể của bộ dữ liệu.

• Điều kiện để "Mãnh thú" XGBoost thức tỉnh: Để XGBoost thực sự thể hiện sức mạnh áp đảo đúng với danh xưng "vua dữ liệu bảng", người phân tích cần làm hai việc. Thứ nhất, đưa toàn bộ gần 80 biến của bộ dữ liệu (đặc biệt là các biến phân loại phi tuyến như khu vực, kiểu mái nhà) vào mô hình. Thứ hai, hiệu suất của XGBoost phụ thuộc cực lớn vào quá trình tinh chỉnh siêu tham số (Hyperparameter tuning). Nếu chỉ chạy với cấu hình mặc định, mô hình không thể phát huy hết lợi thế tối ưu hóa bậc hai và cơ chế phạt (Regularization) của nó.

(Ghi chú ứng dụng: Do biến mục tiêu đã được log-transform, sai số RMSE ở đây phản ánh sai số trên không gian logarit.) Để tính ra con số chênh lệch tiền USD thực tế, nhà phân tích bắt buộc phải dùng hàm np.expm1() để nghịch chuyển đổi (Inverse Transform) giá trị dự báo về đơn vị gốc trước khi báo cáo cho ban lãnh đạo.

5.5.5. 💻 Nâng cao: Đánh thức sức mạnh XGBoost với Toàn bộ đặc trưng và Tinh chỉnh siêu tham số (Hyperparameter Tuning)

Trong thực tế, giá của một căn nhà không chỉ được quyết định bởi 6 yếu tố cơ bản, mà là sự tổng hòa của hàng chục đặc điểm từ diện tích, vị trí, vật liệu mái nhà, chất lượng tầng hầm, cho đến hệ thống sưởi ấm. Khi chúng ta đưa toàn bộ gần 80 biến số vào mô hình, không gian dữ liệu sẽ phình to thành hàng trăm chiều sau khi mã hóa One-Hot Encoding.

Trong không gian khổng lồ này, Hồi quy tuyến tính (Linear Regression) sẽ gặp thất bại nặng nề do vướng phải hiện tượng đa cộng tuyến (Multicollinearity). Ngược lại, đây chính là "sân nhà" của XGBoost.

Để XGBoost phát huy tối đa sức mạnh, chúng ta không thể dùng cấu hình mặc định mà bắt buộc phải sử dụng công cụ GridSearchCV kết hợp Kiểm chứng chéo (Cross-Validation) nhằm tìm ra bộ siêu tham số (Hyperparameters) tối ưu nhất.

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split, GridSearchCV

from xgboost import XGBRegressor

from sklearn.metrics import mean_squared_error, r2_score

import warnings

warnings.filterwarnings('ignore')

# =====================================================================

# BƯỚC 1: ĐỌC DỮ LIỆU VÀ TÁCH BIẾN

# =====================================================================

df = pd.read_csv('https://drive.google.com/uc?export=download&id=1coggcvNOfUQxRCu4LXqArbLdMnODN3rN')

# Tách biến đầu vào X (Bỏ cột Id vì không có ý nghĩa dự báo) và biến mục tiêu y

X = df.drop(columns=['Id', 'SalePrice'])

y_log = np.log1p(df['SalePrice']) # Log-transform để giảm độ lệch phải [10, 11]

# =====================================================================

# BƯỚC 2: TIỀN XỬ LÝ TOÀN BỘ ĐẶC TRƯNG TỰ ĐỘNG

# =====================================================================

# Phân loại biến định lượng và biến định tính

numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns

categorical_cols = X.select_dtypes(include=['object']).columns

# Điền giá trị khuyết thiếu (Missing Values)

# Biến số: Điền bằng Trung vị (Median) [12, 13]

X[numeric_cols] = X[numeric_cols].fillna(X[numeric_cols].median())

# Biến phân loại: Điền bằng 'None' (Đại diện cho việc không có đặc điểm đó, vd: không có Hồ bơi) [12, 14]

X[categorical_cols] = X[categorical_cols].fillna('None')

# Mã hóa One-Hot Encoding cho toàn bộ biến phân loại [15, 16]

X_encoded = pd.get_dummies(X, columns=categorical_cols, drop_first=True)

# Chia tập Train/Test (80/20) [17, 18]

X_train, X_test, y_train, y_test = train_test_split(X_encoded, y_log, test_size=0.2, random_state=42)

print(f"Không gian dữ liệu sau khi mã hóa: {X_train.shape[1]} đặc trưng đầu vào.")

# =====================================================================

# BƯỚC 3: THIẾT LẬP LƯỚI TÌM KIẾM SIÊU THAM SỐ (GRID SEARCH)

# =====================================================================

# Định nghĩa không gian siêu tham số cần thử nghiệm [20]

param_grid = {

    'n_estimators': [100, 200, 300],       # Số lượng cây quyết định, phải là số dương

    'learning_rate': [0.01, 0.05, 0.1],    # Tốc độ học (Bước cập nhật)

    'max_depth': [3, 5, 7],                # Độ sâu tối đa của cây (Chống Overfitting), phải là số dương

    'subsample': [0.8],                    # Tỷ lệ lấy mẫu dòng dữ liệu

    'colsample_bytree': [0.8]              # Tỷ lệ lấy mẫu cột (đặc trưng) tại mỗi cây

}

# Khởi tạo mô hình gốc

xgb_base = XGBRegressor(random_state=42, objective='reg:squarederror')

# Áp dụng GridSearchCV với 5-Fold Cross Validation [9, 27]

print("\nĐang tìm kiếm bộ siêu tham số tối ưu (Quá trình này mất 1-2 phút)...")

grid_search = GridSearchCV(

    estimator=xgb_base,

    param_grid=param_grid,

    cv=5,

    scoring='r2',

    n_jobs=-1,

    verbose=1

)

grid_search.fit(X_train, y_train)

# =====================================================================

# BƯỚC 4: DỰ BÁO VÀ ĐÁNH GIÁ MÔ HÌNH TỐT NHẤU

# =====================================================================

best_xgb = grid_search.best_estimator_

print("\n--- KẾT QUẢ TỐI ƯU HÓA XGBOOST ---")

print(f"Bộ tham số tốt nhất: {grid_search.best_params_}")

# Đánh giá trên tập Test

y_pred_log = best_xgb.predict(X_test)

rmse_log = np.sqrt(mean_squared_error(y_test, y_pred_log))

r2 = r2_score(y_test, y_pred_log)

print(f" - RMSE (Log): {rmse_log:.4f}")

print(f" - R2 Score  : {r2:.4f}")

# =====================================================================

# BƯỚC 5: TRỰC QUAN HÓA TẦM QUAN TRỌNG CỦA BIẾN (TOP 10)

# =====================================================================

importances = best_xgb.feature_importances_

indices = np.argsort(importances)[-10:] # Lấy top 10 biến mạnh nhất

features = X_train.columns

plt.figure(figsize=(10, 6))

plt.title('Top 10 Đặc trưng quyết định Giá nhà (XGBoost)', fontsize=14, fontweight='bold')

plt.barh(range(len(indices)), importances[indices], color='b', align='center')

plt.yticks(range(len(indices)), [features[i] for i in indices])

plt.xlabel('Mức độ quan trọng (Relative Importance)')

plt.tight_layout()

plt.show()

Phân tích sự lột xác của mô hình:

1. Vượt trội nhờ không gian dữ liệu đa chiều: Khi chạy đoạn code trên, hàm pd.get_dummies biến gần 80 cột ban đầu thành hơn 250 cột (đặc trưng) khác nhau. Nhờ cơ chế chọn mẫu cột ngẫu nhiên (colsample_bytree) kết hợp với tối ưu hóa bậc hai (Second-Order Optimization), XGBoost dễ dàng xử lý hàng trăm chiều dữ liệu này mà không hề bị rối loạn hay bị đa cộng tuyến như các thuật toán học máy cổ điển.

2. Sức mạnh của Hyperparameter Tuning: Thông qua GridSearchCV, thuật toán đã tự động thử nghiệm hàng chục kịch bản khác nhau để tìm ra sự cân bằng hoàn hảo giữa tốc độ học (learning_rate) và độ phức tạp của cây (max_depth). Bạn sẽ thấy hệ số R^2 nhảy vọt từ mức ~0.83 (ở ví dụ bị giới hạn 6 biến) lên mức > 0.90, đồng thời ép RMSE xuống mức cực kỳ thấp. Khả năng giải thích hơn 90% sự biến thiên của thị trường nhà ở chứng minh rằng XGBoost hoàn toàn xứng đáng với danh xưng "Vua dữ liệu dạng bảng".

3. Insights kinh doanh từ Top 10 biến quan trọng: Biểu đồ Feature Importance được xuất ra lúc này không chỉ quanh quẩn ở diện tích hay chất lượng tổng thể như ví dụ trước. Nó có khả năng "bắt" được các tín hiệu vi mô đắt giá hơn nhiều (ví dụ như loại nền móng, tiện ích khu phố hoặc chất lượng nhà bếp). Đây là bằng chứng cho thấy mô hình không chỉ đoán đúng, mà còn đóng vai trò là một "cố vấn định giá" xuất sắc cho các nhà phân tích bất động sản thực thụ.

Xem tiếp CHƯƠNG 6: Học có giám sát - Các thuật toán Phân lớp (Classification)