Đánh giá mô hình

Mục tiêu thật của machine learning là generalization — dự đoán tốt trên dữ liệu mới trong tương lai, chứ không phải học thuộc lòng tập huấn luyện. Một mô hình đạt 99% accuracy trên tập train nhưng 60% trên dữ liệu thực tế là vô dụng. Vì vậy toàn bộ quy trình đánh giá được thiết kế để ước lượng không thiên lệch hiệu năng trên dữ liệu chưa thấy.

Ba sai lầm phổ biến khiến con số đánh giá đẹp một cách giả tạo:

• Đánh giá trên chính tập train: mô hình đã nhìn thấy đáp án, điểm luôn cao và vô nghĩa.
• Data leakage: thông tin từ tập test/tương lai rò rỉ vào quá trình huấn luyện (chuẩn hoá trên toàn bộ dữ liệu, dùng feature chứa nhãn...).
• Chọn sai metric: dùng accuracy cho dữ liệu mất cân bằng, dùng RMSE khi bài toán quan tâm sai số tương đối...

Cách chia dữ liệu chuẩn gồm ba phần, mỗi phần một vai trò khác nhau:

Vì sao phải tách test riêng biệt? Vì khi bạn dùng validation để tinh chỉnh hàng chục lần, bạn đang gián tiếp "học" theo validation — nó dần mất tính khách quan. Test set được giữ trong "két sắt", chỉ mở ra khi mọi quyết định đã chốt, để cho con số cuối cùng phản ánh trung thực dữ liệu tương lai.

from sklearn.model_selection import train_test_split

# Tách test 20% trước, giữ nguyên tỉ lệ lớp với stratify
X_temp, X_test, y_temp, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y)
# Từ phần còn lại tách validation
X_train, X_val, y_train, y_val = train_test_split(
    X_temp, y_temp, test_size=0.25, random_state=42, stratify=y_temp)
# 0.25 * 0.8 = 0.2 -> train 60% / val 20% / test 20%

Data leakage là kẻ thù âm thầm nhất. Ví dụ kinh điển: chuẩn hoá dữ liệu (StandardScaler) bằng mean/std tính trên toàn bộ dataset trước khi split — thống kê của test đã "rò" vào train. Cách đúng là fit scaler chỉ trên train rồi transform phần còn lại, tốt nhất là bọc trong một Pipeline.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipe = Pipeline([
    ("scaler", StandardScaler()),   # chỉ fit trên fold train
    ("clf", LogisticRegression())
])
pipe.fit(X_train, y_train)      # scaler học thống kê từ train mà thôi

Một lần split ngẫu nhiên có thể "may/rủi". Cross-validation (CV) chia dữ liệu thành nhiều phần, luân phiên dùng mỗi phần làm validation, rồi lấy trung bình — cho ước lượng ổn định hơn và tận dụng toàn bộ dữ liệu.

from sklearn.model_selection import (cross_val_score,
    StratifiedKFold, TimeSeriesSplit)

# 5-fold phân tầng, đo bằng F1
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipe, X, y, cv=cv, scoring="f1")
print(scores.mean(), "+/-", scores.std())

# CV cho chuỗi thời gian: fold sau luôn nằm ở tương lai
tscv = TimeSeriesSplit(n_splits=5)
scores_ts = cross_val_score(model, X, y, cv=tscv,
                            scoring="neg_root_mean_squared_error")

Sai số kỳ vọng của mô hình phân rã thành ba phần: Error = Bias² + Variance + Noise.

• Bias cao (underfit): mô hình quá đơn giản, không nắm được quy luật — sai cả trên train lẫn test.
• Variance cao (overfit): mô hình quá phức tạp, học cả nhiễu — tốt trên train nhưng tệ trên test.
• Noise: sai số không thể giảm được, thuộc về bản chất dữ liệu.

Giảm bias thường làm tăng variance và ngược lại — đây là tradeoff. Mục tiêu là điểm cân bằng tối ưu.

Learning curve vẽ điểm train & validation theo kích thước tập huấn luyện, giúp chẩn đoán: nếu hai đường hội tụ ở mức thấp → underfit; nếu có khoảng gap lớn dai dẳng → overfit (và thêm dữ liệu có thể giúp).

from sklearn.model_selection import learning_curve
import numpy as np

sizes, train_sc, val_sc = learning_curve(
    model, X, y, cv=5, scoring="accuracy",
    train_sizes=np.linspace(0.1, 1.0, 10))
# So sánh train_sc.mean(1) với val_sc.mean(1) theo sizes

Mọi metric phân loại nhị phân bắt nguồn từ confusion matrix — bảng đối chiếu dự đoán với thực tế:

Từ bốn ô này ta định nghĩa các metric (viết dạng công thức text):

Accuracy    = (TP + TN) / (TP + TN + FP + FN)
Precision   = TP / (TP + FP)          # trong số báo Positive, bao nhiêu đúng?
Recall/TPR  = TP / (TP + FN)          # trong số Positive thật, bắt được bao nhiêu?
Specificity = TN / (TN + FP)          # tỉ lệ Negative thật được nhận đúng
F1          = 2 * (P * R) / (P + R)   # trung bình điều hoà của P và R

ROC curve vẽ TPR (recall) theo FPR = FP/(FP+TN) khi quét ngưỡng; AUC (diện tích dưới đường) đo khả năng phân tách của mô hình: 0.5 = đoán mò, 1.0 = hoàn hảo. Với dữ liệu rất lệch, Precision-Recall curve và PR-AUC phản ánh trung thực hơn ROC vì không bị số lượng TN khổng lồ làm đẹp con số.

from sklearn.metrics import (classification_report,
    confusion_matrix, roc_auc_score, average_precision_score,
    log_loss)

y_pred  = pipe.predict(X_test)
y_proba = pipe.predict_proba(X_test)[:, 1]

print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))   # P, R, F1 mỗi lớp
print("ROC-AUC:", roc_auc_score(y_test, y_proba))
print("PR-AUC :", average_precision_score(y_test, y_proba))
print("LogLoss:", log_loss(y_test, y_proba))

Chọn threshold: mặc định 0.5 hiếm khi tối ưu. Model xuất ra xác suất; ta chọn ngưỡng cắt dựa trên mục tiêu nghiệp vụ — hạ ngưỡng để tăng recall (bắt nhiều positive hơn, chấp nhận nhiều báo động giả), nâng ngưỡng để tăng precision. Có thể chọn ngưỡng tối đa hoá F1 hoặc theo ràng buộc "recall ≥ 90%".

Log-loss (cross-entropy) phạt nặng các dự đoán tự tin nhưng sai; nó đánh giá chất lượng xác suất, không chỉ nhãn cuối — quan trọng khi bạn dùng chính xác suất đó để ra quyết định.

MAE  = mean(|y - ŷ|)                 # sai số tuyệt đối trung bình
MSE  = mean((y - ŷ)²)                # phạt bình phương -> nhạy outlier
RMSE = sqrt(MSE)                     # cùng đơn vị với y
R²   = 1 - SS_res / SS_tot           # tỉ lệ phương sai được giải thích
MAPE = mean(|y - ŷ| / |y|) * 100%    # sai số phần trăm

Khác biệt cốt lõi: MAE coi mọi sai số như nhau; MSE/RMSE phạt sai số lớn nặng hơn (do bình phương) nên rất nhạy với outlier. Nếu dữ liệu có ngoại lệ và bạn không muốn chúng chi phối, ưu tiên MAE. Nếu sai số lớn đặc biệt nguy hiểm, dùng RMSE. Dùng MAPE khi quan tâm sai số tương đối (dự báo doanh số theo %).

from sklearn.metrics import (mean_absolute_error,
    mean_squared_error, r2_score, mean_absolute_percentage_error)

mae  = mean_absolute_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False)
r2   = r2_score(y_test, y_pred)
mape = mean_absolute_percentage_error(y_test, y_pred)

Khi một lớp áp đảo (gian lận 0.1%, bệnh hiếm...), mô hình có xu hướng "phớt lờ" lớp thiểu số. Ba nhóm giải pháp:

• Resampling: Oversample lớp thiểu số (SMOTE sinh mẫu tổng hợp bằng nội suy giữa các điểm lân cận) hoặc undersample lớp đa số (bỏ bớt mẫu). SMOTE chỉ áp trên tập train, bên trong pipeline CV — tuyệt đối không trên toàn bộ dữ liệu (gây leakage).
• class_weight: đặt class_weight="balanced" để phạt sai lớp thiểu số nặng hơn, không cần đổi dữ liệu — có sẵn trong LogisticRegression, SVM, RandomForest, XGBoost (scale_pos_weight).
• Chọn metric đúng: bỏ accuracy, dùng F1, PR-AUC, recall của lớp thiểu số; điều chỉnh threshold theo mục tiêu.

from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.over_sampling import SMOTE

pipe = ImbPipeline([
    ("scaler", StandardScaler()),
    ("smote", SMOTE(random_state=42)),   # chỉ tác động fold train
    ("clf", LogisticRegression(class_weight="balanced"))
])

Hyperparameter (số cây, độ sâu, learning rate, C...) không được học từ dữ liệu mà phải dò tìm. Ba chiến lược:

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV

param_grid = {"clf__C": [0.1, 1, 10], "clf__penalty": ["l1", "l2"]}
grid = GridSearchCV(pipe, param_grid, cv=5,
                    scoring="f1", n_jobs=-1)
grid.fit(X_train, y_train)
print(grid.best_params_, grid.best_score_)

# Optuna: tối ưu Bayesian
import optuna
from sklearn.model_selection import cross_val_score

def objective(trial):
    C = trial.suggest_float("C", 1e-3, 1e2, log=True)
    model = LogisticRegression(C=C, max_iter=1000)
    return cross_val_score(model, X_train, y_train,
                           cv=5, scoring="f1").mean()

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50)

Nested CV: nếu bạn vừa tune hyperparameter vừa muốn báo cáo hiệu năng trung thực, một vòng CV là chưa đủ (điểm best_score_ đã bị "lạc quan" vì đã chọn theo nó). Nested CV dùng hai vòng lồng nhau: vòng trong chọn hyperparameter, vòng ngoài đo hiệu năng trên fold mà vòng trong chưa thấy.

from sklearn.model_selection import cross_val_score, KFold

inner = KFold(5, shuffle=True, random_state=1)
outer = KFold(5, shuffle=True, random_state=2)
search = GridSearchCV(pipe, param_grid, cv=inner, scoring="f1")
nested = cross_val_score(search, X, y, cv=outer)   # ước lượng không thiên lệch
print(nested.mean(), nested.std())