Bài 31: Support Vector Machine (SVM) — margin tối ưu

Support Vector Machine (SVM) — Cortes & Vapnik (1995) — là họ model classification (và regression qua biến thể SVR) tìm hyperplane phân chia hai class sao cho khoảng cách từ hyperplane tới điểm gần nhất của mỗi class là lớn nhất. Khoảng cách đó gọi là margin; SVM là một maximum margin classifier.

Khác với họ tree-based (bài 28–30) chia không gian feature theo từng split trục, SVM tìm một mặt phẳng duy nhất trong không gian feature (hoặc trong không gian được biến đổi qua kernel). Khác với Logistic Regression (bài 22) chỉ tối ưu likelihood, SVM tối ưu khoảng cách hình học.

Ba ý tưởng cốt lõi cần nhớ trong bài này:

1. Maximum margin — chọn hyperplane cách xa hai class nhất, không chỉ phân chia đúng.
2. Support vectors — chỉ một số ít điểm gần biên quyết định hyperplane; phần còn lại không ảnh hưởng.
3. Kernel trick — fit boundary phi tuyến bằng cách map ngầm sang không gian cao chiều, không cần tính explicit.

SVM dominate giai đoạn 1995–2010 (đặc biệt cho text classification và image classification trước deep learning), nay vẫn là lựa chọn tốt cho dataset nhỏ-trung bình và bài toán high-dimensional sparse.

Bài toán binary classification có hai class với label \( y_i \in \{-1, +1\} \) (SVM dùng \( \pm 1 \) thay vì \( \{0, 1\} \) để công thức margin gọn). Linear SVM tìm hyperplane:

Trong đó \( \mathbf{w} \) là vector pháp tuyến (định hướng mặt phẳng), \( b \) là bias (dịch chuyển). Một điểm \( \mathbf{x} \) được phân loại theo dấu của \( \mathbf{w}^T \mathbf{x} + b \): dương → class \( +1 \), âm → class \( -1 \).

Với hai class phân chia tuyến tính, có vô số hyperplane phân chia đúng. SVM chọn hyperplane sao cho margin — khoảng cách từ hyperplane tới điểm gần nhất của cả hai class — là lớn nhất. Khoảng cách hình học từ điểm \( \mathbf{x}_i \) đến hyperplane là:

Trực giác: hyperplane cách xa cả hai class càng nhiều thì càng robust với noise — nếu một điểm test bị nhiễu lệch một chút, nó vẫn nằm đúng phía. Hyperplane sát điểm thì chỉ cần một dao động nhỏ là sai class.

Hệ quả quan trọng của bài toán maximum margin: chỉ các điểm nằm trên hoặc trong margin mới ảnh hưởng đến hyperplane. Những điểm đó gọi là support vectors.

• Điểm xa hyperplane (đã classify chắc chắn) — không matter. Bỏ điểm đó ra khỏi training set, hyperplane vẫn y nguyên.
• Điểm trên margin (đúng \( |\mathbf{w}^T \mathbf{x} + b| = 1 \)) hoặc trong margin (kể cả classify sai sau soft margin) — quyết định hyperplane.

Model sau khi train là sparse theo điểm: chỉ cần lưu support vectors cùng hệ số tương ứng, không cần lưu toàn bộ training data. Số support vectors thường << số sample training với bài toán có margin rõ; nếu support vectors xấp xỉ bằng toàn bộ data, đó là dấu hiệu dataset khó tách hoặc tham số \( C \) đang quá nhỏ.

Trong sklearn, sau khi fit có thể truy cập svm.support_vectors_ (mảng các support vector), svm.support_ (index trong training set), svm.n_support_ (số support vector mỗi class).

Trường hợp lý tưởng — hai class phân chia tuyến tính hoàn toàn — gọi là hard margin SVM. Bài toán tối ưu phát biểu như sau:

Giải thích:

• Constraint \( y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1 \) ép tất cả điểm class \( +1 \) thoả \( \mathbf{w}^T \mathbf{x}_i + b \geq 1 \), và tất cả điểm class \( -1 \) thoả \( \mathbf{w}^T \mathbf{x}_i + b \leq -1 \). Tức là không có điểm nào nằm trong margin.
• Với constraint trên, độ rộng margin bằng \( \frac{2}{\|\mathbf{w}\|} \). Maximize \( \frac{2}{\|\mathbf{w}\|} \) tương đương minimize \( \frac{1}{2}\|\mathbf{w}\|^2 \) — dạng quadratic dễ tối ưu hơn.

Đây là một bài toán Quadratic Programming (QP) với hàm mục tiêu lồi và constraint tuyến tính → có nghiệm tối ưu toàn cục duy nhất. Trong thực tế sklearn dùng solver chuyên biệt (LIBSVM, LIBLINEAR) chứ không phải gradient descent generic.

Hạn chế: hard margin yêu cầu data thật sự phân chia tuyến tính. Với một outlier nằm sai phía, bài toán vô nghiệm. Đây là lý do thực tế luôn dùng soft margin.

Soft margin SVM (Cortes & Vapnik 1995) cho phép một số điểm vi phạm constraint, đo bằng slack variable \( \xi_i \geq 0 \) cho từng điểm:

Ý nghĩa slack:

• \( \xi_i = 0 \): điểm \( i \) ngoài margin, classify đúng — không phạt.
• \( 0 < \xi_i \leq 1 \): điểm trong margin nhưng đúng phía hyperplane — phạt nhẹ.
• \( \xi_i > 1 \): điểm classify sai — phạt nặng.

Hyperparameter \( C > 0 \) là trade-off giữa hai mục tiêu cạnh tranh:

• Margin lớn (\( \|\mathbf{w}\|^2 \) nhỏ) — model đơn giản, robust.
• Ít vi phạm (\( \sum \xi_i \) nhỏ) — model fit training tốt.

Soft margin biến SVM thành công cụ thực dụng cho mọi dataset, kể cả khi không phân chia tuyến tính.

Cần nắm chắc hai trường hợp cực:

• \( C \) lớn (ví dụ 100, 1000) — phạt vi phạm rất nặng. Model cố không cho điểm nào vi phạm → margin nhỏ, hyperplane bám sát điểm. Risk: overfit, đặc biệt với outlier.
• \( C \) nhỏ (ví dụ 0.01, 0.1) — phạt vi phạm nhẹ. Model chấp nhận nhiều vi phạm để giữ margin rộng → margin lớn. Risk: underfit, classify sai nhiều training point.

Trong sklearn, mặc định \( C = 1.0 \) là khởi đầu hợp lý cho hầu hết bài toán. Khi tune, quét \( C \) trên thang log: \( [0.01, 0.1, 1, 10, 100] \).

Quan hệ với regularization strength:

• Trong Logistic Regression / Ridge (bài 21, 23), tham số \( \lambda \) lớn = regularization mạnh = model đơn giản.
• Trong SVM, \( C \) nghịch đảo: \( C \) lớn = regularization yếu = model phức tạp. Có thể coi \( C \propto 1/\lambda \).

Đây là điểm rất hay bị nhầm khi chuyển từ regression sang SVM.

Linear SVM chỉ phân chia được boundary thẳng. Với data có cấu trúc phi tuyến (ví dụ hai class xếp thành vòng đồng tâm), không có hyperplane nào tách được.

Cách giải truyền thống: map data sang không gian cao chiều thông qua hàm \( \phi(\mathbf{x}) \), nơi hai class trở nên phân chia tuyến tính. Vấn đề: với \( \phi \) có chiều đầu ra rất lớn (thậm chí vô hạn), tính \( \phi(\mathbf{x}) \) trực tiếp là không khả thi.

Kernel trick tận dụng đặc điểm: bài toán SVM dạng dual chỉ phụ thuộc vào dot product \( \phi(\mathbf{x}_i)^T \phi(\mathbf{x}_j) \), không phụ thuộc vào \( \phi(\mathbf{x}) \) riêng lẻ. Nếu có hàm kernel:

tính trực tiếp bằng các phép trên \( \mathbf{x}_i, \mathbf{x}_j \) trong không gian gốc, ta không cần biết \( \phi \) là gì. Hệ quả:

• Có thể "ngầm" làm việc trong không gian có chiều rất lớn (RBF kernel ứng với \( \phi \) vô hạn chiều) mà không tốn bộ nhớ.
• Chỉ cần kernel \( K \) hợp lệ (đối xứng và positive semi-definite, theo định lý Mercer).
• Boundary trong không gian gốc trở thành phi tuyến, được điều khiển bởi loại kernel và tham số kernel.

Trick này biến SVM từ classifier tuyến tính đơn thuần thành công cụ phi tuyến linh hoạt — và là lý do SVM nổi tiếng giai đoạn 1995–2010.

Bốn kernel có sẵn trong sklearn (kernel="linear" | "poly" | "rbf" | "sigmoid"):

• Linear: \[ K(\mathbf{x}, \mathbf{y}) = \mathbf{x}^T \mathbf{y} \] Tương đương SVM không kernel. Phù hợp khi đặc trưng nhiều và sparse (text TF-IDF, bag-of-words). Nhanh nhất.
• Polynomial: \[ K(\mathbf{x}, \mathbf{y}) = (\gamma \, \mathbf{x}^T \mathbf{y} + r)^d \] Boundary đa thức bậc \( d \). Tham số: degree=d, gamma=\( \gamma \), coef0=r. Ít dùng so với RBF.
• RBF (Gaussian / Radial Basis Function): \[ K(\mathbf{x}, \mathbf{y}) = \exp\bigl(-\gamma \, \|\mathbf{x} - \mathbf{y}\|^2\bigr) \] Phổ biến nhất, default trong sklearn. Tương đương map vào không gian vô hạn chiều. Linh hoạt cho boundary phi tuyến bất kỳ. Tham số: gamma=\( \gamma \).
• Sigmoid: \[ K(\mathbf{x}, \mathbf{y}) = \tanh(\gamma \, \mathbf{x}^T \mathbf{y} + r) \] Ít dùng — không phải lúc nào cũng positive semi-definite. Có liên hệ lịch sử với neural network 1 lớp ẩn.

Quy tắc lựa chọn thực dụng: thử linear trước (đặc biệt khi số feature lớn so với số sample), nếu không đủ tốt thì chuyển sang RBF. Polynomial và sigmoid hiếm khi là lựa chọn tối ưu.

Với RBF kernel \( K(\mathbf{x}, \mathbf{y}) = \exp(-\gamma \|\mathbf{x} - \mathbf{y}\|^2) \), tham số \( \gamma \) điều khiển tầm ảnh hưởng của mỗi support vector:

• \( \gamma \) lớn — hàm Gaussian hẹp, mỗi support vector chỉ ảnh hưởng đến vùng nhỏ xung quanh nó. Boundary trở nên cong sát từng điểm training → risk overfit.
• \( \gamma \) nhỏ — hàm Gaussian rộng, mỗi support vector ảnh hưởng đến vùng lớn. Boundary mượt, tiệm cận linear → risk underfit.

Default sklearn là gamma="scale":

Heuristic này điều chỉnh theo cả số chiều và phương sai data, thường chạy tốt mà không cần tune ban đầu. Tuỳ chọn gamma="auto" dùng \( \frac{1}{n_{\text{features}}} \) — phụ thuộc vào scale data, lý do nữa để luôn standardize.

Khi tune, quét \( \gamma \) trên thang log: \( [0.001, 0.01, 0.1, 1, 10] \) cùng với \( C \). Hai tham số tương tác — không tune độc lập.

Ba class chính trong sklearn.svm:

• SVC — Support Vector Classifier, hỗ trợ mọi kernel. Backend LIBSVM.
• SVR — Support Vector Regressor, version cho regression.
• LinearSVC — implementation chuyên biệt cho linear kernel, backend LIBLINEAR. Nhanh hơn nhiều cho dataset lớn.

from sklearn.svm import SVC, SVR, LinearSVC

svm = SVC(C=1.0, kernel="rbf", gamma="scale")
svm.fit(X_train, y_train)
print(svm.score(X_test, y_test))
print("So support vector:", svm.n_support_)

API .fit() / .predict() / .score() theo chuẩn sklearn estimator (bài 18), tích hợp trực tiếp vào Pipeline (bài 19) và GridSearchCV.

• C — regularization (mục 5–6). Default 1.0. Tune trên thang log.
• kernel — "linear" | "poly" | "rbf" | "sigmoid" hoặc callable. Default "rbf".
• gamma — cho RBF, poly, sigmoid. "scale" (default) | "auto" | float.
• degree — bậc đa thức (chỉ áp dụng cho kernel="poly"). Default 3.
• coef0 — hệ số \( r \) trong poly/sigmoid. Default 0.
• class_weight — None | "balanced" | dict. Cho dataset imbalanced (bài 24).
• probability — bật Platt scaling để có predict_proba(). Default False vì làm chậm fit (cần thêm 5-fold CV bên trong).
• decision_function_shape — "ovr" (default) hoặc "ovo" cho multi-class.
• cache_size — RAM cho kernel cache, mặc định 200MB. Tăng (1000–2000) khi RAM cho phép để fit nhanh hơn.
• max_iter — giới hạn iteration cho solver. Default -1 (không giới hạn). Set giá trị hữu hạn khi solver không hội tụ.

Hai cách tạo linear SVM trong sklearn cho kết quả gần nhau nhưng không đồng nhất:

• SVC(kernel="linear") — backend LIBSVM, generic cho mọi kernel. Tốc độ \( O(n^2) \) đến \( O(n^3) \) theo số sample. Chậm với dataset lớn.
• LinearSVC — backend LIBLINEAR, chuyên biệt linear. Tối ưu primal problem trực tiếp, scaling gần tuyến tính theo số sample. Nhanh hơn nhiều lần trên dataset > 10k sample.

Khác biệt chi tiết cần biết:

• LinearSVC mặc định dùng squared hinge loss và L2 penalty (đổi qua loss="hinge" và penalty="l1").
• LinearSVC phạt cả bias \( b \) theo mặc định (khác SVC), có thể tắt bằng fit_intercept=True + intercept_scaling.
• LinearSVC không có predict_proba(). Cần CalibratedClassifierCV bọc ngoài nếu cần probability.
• Multi-class: LinearSVC default One-vs-Rest; SVC default One-vs-One.

Quy tắc: dataset < 10k sample → SVC(kernel="linear") hay LinearSVC đều được. Dataset lớn hơn → ưu tiên LinearSVC.

SVM là distance-based: kernel tính dot product (\( \mathbf{x}^T \mathbf{y} \)) hoặc khoảng cách Euclid (\( \|\mathbf{x} - \mathbf{y}\|^2 \) trong RBF). Cả hai đều cực kỳ nhạy với scale feature.

Ví dụ: feature "tuổi" trong [20, 80] và "thu nhập" trong [10000, 100000]. Trong RBF, \( \|\mathbf{x} - \mathbf{y}\|^2 \) bị thu nhập át hoàn toàn; tuổi gần như không đóng góp gì. Trong linear, tham số \( w \) của tuổi phải lớn gấp ~1000 lần thu nhập để cân — solver hội tụ chậm và không ổn định.

Luôn dùng Pipeline StandardScaler + SVM (bài 17, 19):

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("svc", SVC(C=1.0, kernel="rbf", gamma="scale")),
])
pipe.fit(X_train, y_train)
print(pipe.score(X_test, y_test))

Pipeline tự fit scaler trên train rồi áp dụng lên test, tránh data leakage. Đây là pattern không thương lượng khi dùng SVM — quên scaler thường khiến accuracy thấp hơn 10–20% so với nên có.

SVM bản gốc là binary classifier. Mở rộng multi-class bằng hai cách (sklearn xử lý tự động khi y có > 2 class):

• One-vs-Rest (OvR) — train \( K \) classifier binary, mỗi cái phân biệt một class với tất cả class còn lại. Predict bằng class có decision score cao nhất. Số model = \( K \).
• One-vs-One (OvO) — train \( \binom{K}{2} = K(K-1)/2 \) classifier, mỗi cái phân biệt một cặp class. Predict bằng voting. Số model = \( K(K-1)/2 \).

Mặc định sklearn:

• SVC: One-vs-One (decision_function_shape="ovr" chỉ reshape output chứ vẫn train OvO bên trong).
• LinearSVC: One-vs-Rest.

OvO tổng số model nhiều hơn nhưng mỗi model train trên dataset nhỏ hơn (chỉ 2 class), tổng thời gian thường tương đương hoặc nhanh hơn OvR khi \( K \) lớn. Khác biệt accuracy giữa hai chiến lược thường < 1%.

SVM mở rộng cho regression qua SVR. Ý tưởng đối ngẫu với classification:

• Thay vì tối đa margin giữa hai class, SVR tìm hàm \( f(\mathbf{x}) = \mathbf{w}^T \mathbf{x} + b \) sao cho hầu hết training point nằm trong \( \epsilon \)-tube quanh \( f \), tức \( |y_i - f(\mathbf{x}_i)| \leq \epsilon \).
• Chỉ phạt những điểm ngoài tube — sai số bên trong \( \epsilon \) được coi là 0 (\( \epsilon \)-insensitive loss).
• Hai tham số chính: \( C \) (như SVC) và \( \epsilon \) (độ rộng nửa tube). Mặc định epsilon=0.1.

from sklearn.svm import SVR

reg = SVR(C=1.0, kernel="rbf", gamma="scale", epsilon=0.1)
reg.fit(X_train, y_train)
print(reg.score(X_test, y_test))  # R^2

Áp dụng được kernel trick như SVC. Cũng cần standardize cả \( X \) lẫn \( y \) (SVR nhạy với scale target). Phù hợp cho dataset nhỏ-trung bình, ít dùng cho dataset lớn vì cùng nhược điểm tốc độ.

Pros:

• Hiệu quả ở không gian high-dimensional (feature \( \gg \) sample) — đặc biệt với linear kernel cho text TF-IDF.
• Kernel trick linh hoạt — fit boundary phi tuyến bất kỳ qua RBF.
• Sparse theo điểm — chỉ lưu support vectors, mô hình gọn.
• Theoretically backed — VC dimension, margin theory cho generalization bound rõ ràng.

Cons:

• Chậm với dataset lớn — fit time \( O(n^2) \) đến \( O(n^3) \) với SVC kernel hoá. Không khả thi cho \( n > 100\text{k} \) sample.
• Không trực tiếp ra probability — cần Platt scaling (probability=True) làm chậm thêm vì phải chạy CV bên trong, calibration không phải lúc nào cũng tốt.
• Nhạy với scale → bắt buộc standardize.
• Nhiều hyperparameter (\( C \), kernel, \( \gamma \), \( \epsilon \) cho SVR) tương tác phức tạp.
• Khó interpret so với linear model hay tree.

Use case thực tế:

• Text classification — TF-IDF cho ra feature high-dim sparse, linear SVM (LinearSVC) là baseline mạnh trước khi tới transformer.
• Image classification trước deep learning — HOG/SIFT feature + SVM RBF dominate giai đoạn 2000–2012.
• Bioinformatics — gene expression, protein classification (sample ít, feature nhiều).
• Dataset nhỏ-trung bình (< 100k sample) nói chung, đặc biệt khi tree-based không đạt yêu cầu.

Ví dụ chuẩn — Pipeline + SVC RBF, in số support vector:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("svc", SVC(C=1.0, kernel="rbf", gamma="scale", random_state=42)),
])
pipe.fit(X_train, y_train)

acc = accuracy_score(y_test, pipe.predict(X_test))
svc = pipe.named_steps["svc"]
print(f"Accuracy:        {acc:.4f}")
print(f"So support vec:  {svc.support_vectors_.shape[0]} / {X_train.shape[0]}")
print(f"Per class:       {svc.n_support_}")

Output điển hình (random_state=42):

Accuracy:        0.9737
So support vec:  88 / 455
Per class:       [44 44]

Số support vector ≈ 19% training set — model gọn, chỉ lưu một phần nhỏ data. Nếu thử bỏ StandardScaler, accuracy thường rơi xuống khoảng 0.60–0.65 (gần baseline đoán class major) và số support vector nhảy lên gần bằng toàn bộ training set — minh chứng cho mục 13.

So sánh nhanh linear vs RBF trên cùng dataset:

for kernel in ["linear", "rbf"]:
    pipe = Pipeline([
        ("scaler", StandardScaler()),
        ("svc", SVC(C=1.0, kernel=kernel, gamma="scale", random_state=42)),
    ])
    pipe.fit(X_train, y_train)
    acc = accuracy_score(y_test, pipe.predict(X_test))
    n_sv = pipe.named_steps["svc"].support_vectors_.shape[0]
    print(f"kernel={kernel:6s}  acc={acc:.4f}  n_sv={n_sv}")

Trên Breast Cancer, hai kernel cho accuracy gần như nhau (~0.96–0.97) vì dataset phân chia tốt bằng boundary tuyến tính. Khác biệt sẽ rõ trên dataset có cấu trúc phi tuyến (ví dụ make_moons, make_circles).

Preview GridSearchCV tune \( C \) và \( \gamma \) (chi tiết ở Module 6):

from sklearn.model_selection import GridSearchCV

param_grid = {
    "svc__C":     [0.1, 1, 10, 100],
    "svc__gamma": [0.001, 0.01, 0.1, 1],
}
grid = GridSearchCV(
    Pipeline([
        ("scaler", StandardScaler()),
        ("svc", SVC(kernel="rbf", random_state=42)),
    ]),
    param_grid=param_grid,
    cv=5,
    scoring="accuracy",
    n_jobs=-1,
)
grid.fit(X_train, y_train)
print("Best params:", grid.best_params_)
print("Best CV acc:", grid.best_score_)
print("Test acc:   ", grid.score(X_test, y_test))

Lưu ý cú pháp svc__C dùng double underscore — chuẩn sklearn cho tham số bên trong Pipeline. Trên Breast Cancer, grid 16 cấu hình × 5-fold CV chạy trong vài giây.

Bài 1 — Linear vs RBF trên Iris. Load load_iris(), split 80/20 stratify. Train hai Pipeline (StandardScaler + SVC) với kernel="linear" và kernel="rbf", default tham số khác. So sánh accuracy test. Kernel nào tốt hơn? Giải thích dựa trên đặc điểm dataset Iris (xem bài 16).

Bài 2 — Quét tham số C. Trên Iris, dùng SVC RBF với C ∈ {0.1, 1, 10, 100}, các tham số khác mặc định, bọc trong Pipeline có StandardScaler. Đo accuracy train và test cho mỗi giá trị. Plot accuracy theo \( \log_{10}(C) \). Khi nào model bắt đầu overfit (train tăng, test giảm)?

Bài 3 — Số support vector và kích thước dataset. Trên Breast Cancer, train SVC RBF (Pipeline) với subset train cỡ \( n \in \{50, 100, 200, 400\} \) (lấy ngẫu nhiên stratify từ training set). Với mỗi \( n \), in tỷ lệ n_sv / n. Tỷ lệ thay đổi thế nào theo \( n \)? Liên hệ với phát biểu "model sparse theo điểm".

Bài 4 — Quên StandardScaler. Trên Breast Cancer, train hai version SVC RBF: một có Pipeline StandardScaler, một fit trực tiếp lên \( X \) gốc. So sánh accuracy và số support vector. Bao nhiêu phần trăm accuracy mất đi khi quên scale?

Bài 5 — Tune C và gamma bằng GridSearchCV. Trên Wine dataset (load_wine()), dùng GridSearchCV 5-fold quét C ∈ \( \{0.1, 1, 10, 100\} \) và gamma ∈ \( \{0.001, 0.01, 0.1, 1\} \) cho SVC RBF. In best params, best CV accuracy, test accuracy. Vẽ heatmap (16 ô) accuracy CV theo \( (C, \gamma) \).

Module 4 đã đi qua 10 bài, phủ hệ sinh thái Classification cổ điển trong sklearn:

• Bài 22 — Logistic Regression: baseline tuyến tính, log-loss, sigmoid, output probability.
• Bài 23 — Confusion matrix: ma trận TP/FP/FN/TN — nền cho mọi metric phân loại.
• Bài 24 — Accuracy, Precision, Recall: ba metric cơ bản, khi nào ưu tiên cái nào (imbalanced data).
• Bài 25 — F1-score: trung bình harmonic precision/recall, single number cho imbalanced.
• Bài 26 — ROC curve và AUC: threshold-independent, đánh giá ranking quality.
• Bài 27 — KNN: lazy learner, no training, distance-based, baseline đơn giản.
• Bài 28 — Decision Tree: tree single, interpretable, dễ overfit.
• Bài 29 — Random Forest: bagging ensemble, giảm variance, default mạnh cho tabular.
• Bài 30 — Gradient Boosting và XGBoost: boosting ensemble, dominate Kaggle tabular.
• Bài 31 — SVM (bài này): maximum margin, kernel trick, mạnh cho high-dim và dataset nhỏ.

Đến đây toàn bộ supervised learning phần Classification cổ điển đã hoàn tất. Module 5 (bài 32+) bắt đầu vào Unsupervised Learning — không còn label \( y \), thay vào đó là clustering (K-Means, DBSCAN, hierarchical), dimensionality reduction (PCA, t-SNE, UMAP), anomaly detection.

Bài 32: K-Means Clustering — thuật toán clustering kinh điển nhất: chia data thành \( k \) cluster bằng cách lặp gán điểm theo centroid gần nhất.