- Khoảng cách lề cực đại (Maximal Margin): SVM tìm kiếm siêu phẳng phân cách sao cho khoảng cách từ siêu phẳng tới các điểm dữ liệu gần nhất của hai lớp là lớn nhất: \(\text{Margin} = \frac{2}{\|\mathbf{w}\|_2}\).
- Support Vectors: Vị trí siêu phẳng phân cách chỉ phụ thuộc duy nhất vào tập các điểm nằm sát đường biên (Support Vectors), độc lập với hàng nghìn mẫu dữ liệu khác.
- Soft-Margin và Hinge Loss: Bổ sung biến bù sai số \(\xi_i\) và siêu tham số \(C\) để mô hình chấp nhận một số điểm vi phạm lề, giúp thích ứng với dữ liệu thực tế có nhiều nhiễu.
- Kernel Trick: Chiếu dữ liệu phi tuyến lên không gian nhiều chiều vô hạn (như RBF Kernel) thông qua hàm hạt nhân mà không cần tính toán trực tiếp tọa độ vector mới.
1. Trực giác hình học: Bài toán tìm Siêu phẳng lề cực đại
Trong lĩnh vực học máy cổ điển (Classical Machine Learning), trước khi các kiến trúc mạng nơ-ron sâu bùng nổ, Support Vector Machine (SVM) chính là giải thuật phân loại mạnh mẽ bậc nhất từ nhận diện chữ số viết tay đến phân loại biểu hiện gen sinh học. Khác với Hồi quy Logistic chỉ tìm bất kỳ một đường ranh giới chia cắt hai lớp dữ liệu, SVM sở hữu một triết lý hình học vô cùng nghiêm ngặt: tìm kiếm siêu phẳng có khoảng cách lề (margin) lớn nhất.
Giả sử chúng ta có tập dữ liệu phân loại nhị phân gồm \(N\) quan sát \(\{(\mathbf{x}_i, y_i)\}_{i=1}^N\), trong đó \(\mathbf{x}_i \in \mathbb{R}^D\) và nhãn lớp quy ước là \(y_i \in \{-1, +1\}\).
Nếu hai lớp dữ liệu có thể phân tách hoàn hảo bằng một siêu phẳng tuyến tính, sẽ tồn tại vô số đường phân cách khả dĩ. Tuy nhiên, nếu một siêu phẳng nằm quá sát các điểm dữ liệu của lớp \(-1\), chỉ cần một biến động nhiễu nhỏ cũng khiến điểm dữ liệu tương lai bị dự đoán sai lệch.
SVM giải quyết triệt để vấn đề này bằng định nghĩa Khoảng cách lề (Margin):
- Phương trình siêu phẳng phân cách: \[\mathbf{w}^T \mathbf{x} + b = 0\]
- Hai siêu phẳng biên giới hạn hai lớp: \[\mathbf{w}^T \mathbf{x} + b = +1 \quad \text{và} \quad \mathbf{w}^T \mathbf{x} + b = -1\]
- Khoảng cách hình học từ siêu phẳng phân cách tới mỗi siêu phẳng biên là \(\frac{1}{\|\mathbf{w}\|_2}\). Do đó, tổng độ rộng của lề giữa hai lớp chính là: \[\text{Margin} = \frac{2}{\|\mathbf{w}\|_2}\]
Để tối đa hóa lề \(\frac{2}{\|\mathbf{w}\|}\), chúng ta chuyển hóa tương đương thành bài toán tối thiểu hóa độ dài vector trọng số \(\|\mathbf{w}\|^2\) với điều kiện ràng buộc mọi điểm dữ liệu đều nằm đúng về phía biên của mình: \[y_i (\mathbf{w}^T \mathbf{x}_i + b) \ge 1, \quad \forall i = 1, \dots, N\]
Những điểm dữ liệu nằm chính xác trên hai siêu phẳng biên giới thỏa mãn \(y_i (\mathbf{w}^T \mathbf{x}_i + b) = 1\) được gọi là các Vector hỗ trợ (Support Vectors). Vị trí của siêu phẳng phân cách tối ưu chỉ hoàn toàn phụ thuộc vào các Support Vectors này; nếu bạn dịch chuyển hoặc xóa bỏ hàng nghìn điểm dữ liệu khác nằm ngoài vùng lề, siêu phẳng tối ưu vẫn giữ nguyên không hề thay đổi.
2. Xử lý nhiễu với Soft-Margin SVM và Hàm Hinge Loss
Trong thực tế, hầu hết tập dữ liệu đều chứa nhiễu hoặc có vài điểm ngoại lai đan xen vào nhau khiến hai lớp không thể phân tách tuyến tính tuyệt đối. Nếu ép buộc lề cứng (Hard-margin), bài toán tối ưu sẽ vô nghiệm.
Corinna Cortes và Vladimir Vapnik (công bố năm 1995) đã giới thiệu biến phụ sai số \(\xi_i \ge 0\) (slack variable) để xây dựng bài toán Soft-Margin SVM:
- Nếu \(\xi_i = 0\): Mẫu \(\mathbf{x}_i\) nằm an toàn ngoài lề hoặc trên đường biên.
- Nếu \(0 \lt \xi_i \le 1\): Mẫu vi phạm vùng lề nhưng vẫn nằm đúng phía phân loại.
- Nếu \(\xi_i \gt 1\): Mẫu bị phân loại sai hoàn toàn.
Hàm mục tiêu trở thành việc cân bằng giữa độ rộng lề và tổng lượng vi phạm lề: \[\min_{\mathbf{w}, b, \boldsymbol{\xi}} \frac{1}{2} \|\mathbf{w}\|^2 + C \sum_{i=1}^N \xi_i\] thỏa mãn điều kiện: \[y_i (\mathbf{w}^T \mathbf{x}_i + b) \ge 1 - \xi_i \quad \text{và} \quad \xi_i \ge 0\]
Ở đây, siêu tham số \(C \gt 0\) đóng vai trò trọng yếu:
- Khi \(C\) rất lớn: Mô hình phạt rất nặng mọi vi phạm lề, tạo ra biên hẹp, dễ dẫn đến overfitting.
- Khi \(C\) nhỏ: Mô hình bao dung hơn với các điểm vi phạm, chấp nhận một số sai số nhỏ để mở rộng độ rộng lề, tăng khả năng chịu lỗi và khái quát hóa trên dữ liệu mới.
Bài toán trên có thể biểu diễn tương đương dưới dạng tối thiểu hóa hàm mất mát không ràng buộc sử dụng Hinge Loss: \[\mathcal{L}(\mathbf{w}, b) = \frac{1}{2} \|\mathbf{w}\|^2 + C \sum_{i=1}^N \max\left(0, 1 - y_i(\mathbf{w}^T \mathbf{x}_i + b)\right)\]
3. Kernel Trick: Đột phá phân loại phi tuyến tính
Khi dữ liệu có cấu trúc phi tuyến phức tạp (chẳng hạn như dữ liệu hình tròn đồng tâm), không có bất kỳ siêu phẳng phẳng nào có thể phân tách chúng trong không gian ban đầu \(\mathbb{R}^2\).
Giải pháp cổ điển là chiếu dữ liệu lên không gian có số chiều cao hơn thông qua một phép ánh xạ phi tuyến \(\phi(\mathbf{x})\). Ví dụ với \(\mathbf{x} = (x_1, x_2)\), ta có thể ánh xạ lên không gian 3 chiều: \[\phi(\mathbf{x}) = (x_1^2, \sqrt{2}x_1 x_2, x_2^2)\] Trong không gian mới, các đường elip hoặc hypebol có tâm tại gốc tọa độ (dạng \(a x_1^2 + b x_1 x_2 + c x_2^2 = d\)) sẽ trở thành một mặt phẳng, cho phép SVM phân tách dễ dàng.
Tuy nhiên, việc tính toán trực tiếp vector \(\phi(\mathbf{x})\) trong không gian hàng nghìn hoặc vô hạn chiều là bất khả thi về mặt bộ nhớ và thời gian. Đây chính là lúc Kernel Trick (Mẹo hạt nhân) tỏa sáng:
Trong bài toán đối ngẫu Lagrange của SVM, tọa độ các điểm \(\mathbf{x}_i, \mathbf{x}_j\) chỉ xuất hiện dưới dạng tích vô hướng \(\phi(\mathbf{x}_i)^T \phi(\mathbf{x}_j)\). Ta có thể thay thế tích vô hướng này bằng một hàm hạt nhân \(K(\mathbf{x}_i, \mathbf{x}_j)\) tính toán trực tiếp trong không gian gốc: \[K(\mathbf{x}_i, \mathbf{x}_j) = \phi(\mathbf{x}_i)^T \phi(\mathbf{x}_j)\]
Các hàm Kernel kinh điển bao gồm:
- Linear Kernel: \(K(\mathbf{x}, \mathbf{z}) = \mathbf{x}^T \mathbf{z}\) (không gian tuyến tính thuần túy).
- Polynomial Kernel: \(K(\mathbf{x}, \mathbf{z}) = (\gamma \mathbf{x}^T \mathbf{z} + r)^d\) (phù hợp với các bài toán thị giác máy tính).
- RBF Kernel (Radial Basis Function / Gaussian Kernel): \[K(\mathbf{x}, \mathbf{z}) = \exp\left(-\gamma \|\mathbf{x} - \mathbf{z}\|^2\right)\] Hàm RBF ngầm ánh xạ dữ liệu lên một không gian vô hạn chiều dựa trên khoảng cách Euclidean. Siêu tham số \(\gamma \gt 0\) quyết định bán kính ảnh hưởng của từng mẫu dữ liệu: \(\gamma\) càng lớn, biên phân cách càng co cụm uốn lượn quanh từng điểm; \(\gamma\) nhỏ giúp biên mềm mại hơn.
4. Ví dụ chạy tay từng bước tối ưu Soft-Margin SVM
Để thấy rõ cơ chế cập nhật tham số của SVM thông qua giải thuật Subgradient Descent trên hàm Hinge Loss, chúng ta xét một ví dụ thực tế trên 3 mẫu dữ liệu 2 chiều đơn giản:
| Chỉ số \(i\) | Đặc trưng \(x_1\) | Đặc trưng \(x_2\) | Nhãn thực tế \(y_i\) |
|---|---|---|---|
| Mẫu 1 | \(1.0\) | \(2.0\) | \(-1\) |
| Mẫu 2 | \(2.0\) | \(1.0\) | \(-1\) |
| Mẫu 3 | \(5.0\) | \(5.0\) | \(+1\) |
Giả sử hệ số điều chuẩn \(\lambda = 0.01\), tốc độ học \(\alpha = 0.1\), khởi tạo trọng số ban đầu \(\mathbf{w} = [0.0, 0.0]^T\), hệ số chệch \(b = 0.0\).
Quy tắc cập nhật cho mẫu \((\mathbf{x}_i, y_i)\):
- Tính khoảng cách lề: \(\text{margin} = y_i (\mathbf{w}^T \mathbf{x}_i + b)\).
- Nếu \(\text{margin} \ge 1\): Mẫu nằm an toàn ngoài lề, chỉ cập nhật điều chuẩn co trọng số: \[\mathbf{w} \leftarrow \mathbf{w} - \alpha (2 \lambda \mathbf{w}) = (1 - 2\alpha\lambda) \mathbf{w}\]
- Nếu \(\text{margin} \lt 1\): Mẫu vi phạm lề, cập nhật đẩy trọng số về phía đúng: \[\mathbf{w} \leftarrow \mathbf{w} - \alpha (2 \lambda \mathbf{w} - y_i \mathbf{x}_i)\] \[b \leftarrow b + \alpha y_i\]
Tiến hành duyệt qua từng mẫu ở Epoch 1:
- Xét Mẫu 1: \(\mathbf{x}_1 = [1.0, 2.0]\), \(y_1 = -1\).
- Margin \(= -1 \cdot (0 + 0) = 0 \lt 1\) (Vi phạm lề).
- \(\mathbf{w} \leftarrow [0, 0] - 0.1 \cdot (0 - (-1) \cdot [1.0, 2.0]) = [-0.1, -0.2]\).
- \(b \leftarrow 0 + 0.1 \cdot (-1) = -0.1\).
- Xét Mẫu 2: \(\mathbf{x}_2 = [2.0, 1.0]\), \(y_2 = -1\).
- \(\mathbf{w}^T \mathbf{x}_2 + b = -0.1(2) - 0.2(1) - 0.1 = -0.5\).
- Margin \(= -1 \cdot (-0.5) = 0.5 \lt 1\) (Vẫn vi phạm lề).
- \(\mathbf{w} \leftarrow [-0.1, -0.2] - 0.1 \cdot (2(0.01)[-0.1, -0.2] - (-1)[2.0, 1.0]) \approx [-0.3, -0.3]\).
- \(b \leftarrow -0.1 + 0.1(-1) = -0.2\).
- Xét Mẫu 3: \(\mathbf{x}_3 = [5.0, 5.0]\), \(y_3 = +1\).
- \(\mathbf{w}^T \mathbf{x}_3 + b = -0.3(5) - 0.3(5) - 0.2 = -3.2\).
- Margin \(= +1 \cdot (-3.2) = -3.2 \lt 1\) (Vi phạm nghiêm trọng do đoán sai lớp).
- \(\mathbf{w} \leftarrow [-0.3, -0.3] - 0.1 \cdot (0 - (+1)[5.0, 5.0]) = [-0.3, -0.3] + [0.5, 0.5] = [0.2, 0.2]\).
- \(b \leftarrow -0.2 + 0.1(+1) = -0.1\).
Sau 1 vòng lặp, trọng số \(\mathbf{w}\) đã đổi dấu từ âm sang dương nhưng mô hình chưa tách được hai lớp: với \(\mathbf{w} \approx [0.2, 0.2]\) và \(b = -0.1\) thì \(\mathbf{w}^T \mathbf{x} + b \approx 0.5\) ở cả \(\mathbf{x}_1, \mathbf{x}_2\) (vẫn bị đoán \(+1\)) và \(\approx 1.9\) ở \(\mathbf{x}_3\); cần thêm nhiều vòng lặp nữa.
Chủ đề này nằm trong Lecture 09 - Support Vector Machine (SVM) của Khóa AI. Xem đề cương
5. Cài đặt Linear SVM từ đầu bằng Python và C++
Dưới đây là mã nguồn cài đặt giải thuật Linear SVM hoàn chỉnh sử dụng Subgradient Descent:
import math
def fit_predict_linear_svm(X_train, y_train, X_test, lr=0.01, lambda_param=0.01, epochs=5000):
n_samples = len(X_train)
n_features = len(X_train[0])
w = [0.0] * n_features
b = 0.0
for _ in range(epochs):
for i in range(n_samples):
xi = X_train[i]
yi = y_train[i]
margin = yi * (sum(w[j] * xi[j] for j in range(n_features)) + b)
if margin >= 1.0:
for j in range(n_features):
w[j] -= lr * (2 * lambda_param * w[j])
else:
for j in range(n_features):
w[j] -= lr * (2 * lambda_param * w[j] - yi * xi[j])
b -= lr * (-yi)
preds = []
for x in X_test:
val = sum(w[j] * x[j] for j in range(n_features)) + b
preds.append(1 if val >= 0 else -1)
return preds, [round(val, 4) for val in w], round(b, 4)
def solve(input_data):
X_train, y_train, X_test = input_data
preds, w, b = fit_predict_linear_svm(X_train, y_train, X_test)
return preds
#include <iostream>
#include <vector>
#include <cmath>
std::vector<int> fit_predict_linear_svm(const std::vector<std::vector<double>>& X_train,
const std::vector<int>& y_train,
const std::vector<std::vector<double>>& X_test,
double lr = 0.01, double lambda_param = 0.01, int epochs = 5000) {
int n_samples = X_train.size();
int n_features = X_train[0].size();
std::vector<double> w(n_features, 0.0);
double b = 0.0;
for (int ep = 0; ep < epochs; ++ep) {
for (int i = 0; i < n_samples; ++i) {
double dot = 0.0;
for (int j = 0; j < n_features; ++j) {
dot += w[j] * X_train[i][j];
}
double margin = y_train[i] * (dot + b);
if (margin >= 1.0) {
for (int j = 0; j < n_features; ++j) {
w[j] -= lr * (2.0 * lambda_param * w[j]);
}
} else {
for (int j = 0; j < n_features; ++j) {
w[j] -= lr * (2.0 * lambda_param * w[j] - y_train[i] * X_train[i][j]);
}
b -= lr * (-y_train[i]);
}
}
}
std::vector<int> preds;
preds.reserve(X_test.size());
for (const auto& x : X_test) {
double val = b;
for (int j = 0; j < n_features; ++j) {
val += w[j] * x[j];
}
preds.push_back(val >= 0 ? 1 : -1);
}
return preds;
}
int main() {
int n_train, n_features, n_test;
if (!(std::cin >> n_train >> n_features >> n_test)) return 0;
std::vector<std::vector<double>> X_train(n_train, std::vector<double>(n_features));
std::vector<int> y_train(n_train);
for (int i = 0; i < n_train; ++i) {
for (int j = 0; j < n_features; ++j) std::cin >> X_train[i][j];
std::cin >> y_train[i];
}
std::vector<std::vector<double>> X_test(n_test, std::vector<double>(n_features));
for (int i = 0; i < n_test; ++i) {
for (int j = 0; j < n_features; ++j) std::cin >> X_test[i][j];
}
auto preds = fit_predict_linear_svm(X_train, y_train, X_test);
for (int i = 0; i < (int)preds.size(); ++i) {
if (i > 0) std::cout << " ";
std::cout << preds[i];
}
std::cout << "\n";
return 0;
}
6. Cạm bẫy thực tế khi triển khai Support Vector Machine
- Bắt buộc phải chuẩn hóa dữ liệu (Feature Scaling): SVM tính toán khoảng cách hình học trong không gian vector. Nếu đặc trưng Tuổi nằm trong khoảng \([20, 60]\) còn đặc trưng Thu nhập nằm trong \([10.000.000, 50.000.000]\), khoảng cách lề sẽ hoàn toàn bị chi phối bởi Thu nhập, khiến mô hình coi nhẹ biến Tuổi. Luôn áp dụng
StandardScalertrước khi đưa dữ liệu vào SVM. - Chi phí tính toán với tập dữ liệu lớn: Thuật toán giải bài toán đối ngẫu chuẩn (SMO) có độ phức tạp thời gian từ \(O(N^2)\) đến \(O(N^3)\). Khi dữ liệu vượt quá \(100.000\) mẫu, SVM sử dụng Kernel phi tuyến sẽ chạy rất chậm. Với dữ liệu cực lớn, nên chuyển sang
LinearSVChoặc SGDClassifier. - Cách tinh chỉnh cặp siêu tham số \((C, \gamma)\): Đối với RBF Kernel, việc tìm kiếm lưới (Grid Search) cặp tham số \((C, \gamma)\) trên không gian logarit (ví dụ \(C \in [0.1, 1, 10, 100]\) và \(\gamma \in [0.001, 0.01, 0.1, 1]\)) là bước bắt buộc để đạt hiệu năng cực đại.
7. Bảng so sánh SVM với Hồi quy Logistic và Random Forest
| Tiêu chí so sánh | Support Vector Machine (SVM) | Hồi quy Logistic | Random Forest |
|---|---|---|---|
| Bản chất toán học | Tối đa hóa khoảng cách lề hình học | Tối đa hóa hợp lý cực đại (MLE) | Tập hợp biểu quyết nhiều cây quyết định |
| Độ nhạy ngoại lai | Rất bền bỉ (chỉ phụ thuộc Support Vectors) | Khá nhạy cảm nếu không có Regularization | Rất bền vững trước ngoại lai |
| Khả năng phi tuyến | Xuất sắc nhờ Kernel Trick | Kém (cần tạo đa thức thủ công) | Tự nhiên, không cần biến đổi đặc trưng |
| Tốc độ trên dữ liệu lớn | Chậm khi dùng Kernel (\(O(N^2)\)) | Rất nhanh (\(O(N \cdot D)\)) | Nhanh, dễ dàng huấn luyện song song đa luồng |
| Khả năng giải thích | Khó giải thích khi dùng RBF Kernel | Rất cao thông qua trọng số \(\mathbf{w}\) | Trung bình thông qua Feature Importance |
8. Câu hỏi thường gặp
Tại sao nhãn của SVM lại dùng -1 và +1 thay vì 0 và 1 như Logistic Regression?
Quy ước nhãn \(y \in \{-1, +1\}\) giúp công thức kiểm tra tính đúng đắn của phân loại và độ rộng lề trở nên gọn gàng dưới dạng một biểu thức duy nhất \(y_i (\mathbf{w}^T \mathbf{x}_i + b) \ge 1\). Nếu \(y_i\) và hàm dự đoán cùng dấu thì tích của chúng dương (mẫu được phân loại đúng); ràng buộc tích \(\ge 1\) còn đòi hỏi mẫu nằm ngoài hoặc ngay trên biên lề. Cách viết gộp này giúp việc tối ưu hóa gọn hơn và dễ giải bằng đối ngẫu Lagrange.
SVM có áp dụng được cho bài toán phân loại đa lớp (Multi-class) không?
Có. SVM ban đầu được thiết kế cho bài toán nhị phân, nhưng để giải quyết bài toán đa lớp (\(K \gt 2\)), người ta sử dụng hai chiến lược: One-vs-Rest (OvR - huấn luyện \(K\) mô hình SVM nhị phân) hoặc One-vs-One (OvO - huấn luyện \(\frac{K(K-1)}{2}\) mô hình giữa từng cặp lớp). Trong thư viện Scikit-learn, lớp SVC mặc định sử dụng chiến lược OvO mang lại độ chính xác rất cao.
9. Giải thuật Tối ưu Hóa Tuần tự SMO (Sequential Minimal Optimization)
Bài toán đối ngẫu của SVM là một bài toán quy hoạch toàn phương bậc hai có ràng buộc đa chiều. Nếu giải bằng các phương pháp tối ưu tổng quát tiêu chuẩn, máy tính bắt buộc phải lưu trữ và nghịch đảo một ma trận hạt nhân khổng lồ có kích thước N nhân N. Khi tập dữ liệu có hàng trăm nghìn mẫu, dung lượng bộ nhớ RAM sẽ bị quá tải hoàn toàn và thời gian tính toán kéo dài nhiều ngày.
Để giải quyết nút thắt cổ chai này, nhà nghiên cứu John Platt của Microsoft Research đã phát minh ra giải thuật Tối ưu Hóa Tuần tự SMO (Sequential Minimal Optimization). Ý tưởng cốt lõi của SMO vô cùng thông minh: thay vì tối ưu hóa đồng thời toàn bộ N nhân tử Lagrange, thuật toán chia nhỏ bài toán khổng lồ thành chuỗi các bài toán con nhỏ nhất có thể giải được.
Do ràng buộc tổng của các nhân tử Lagrange nhân với nhãn lớp luôn bằng 0, chúng ta không thể chỉ tối ưu hóa một nhân tử đơn lẻ vì làm như vậy sẽ vi phạm ràng buộc cân bằng. Vì vậy, bài toán con nhỏ nhất khả dĩ bắt buộc phải chứa ít nhất hai nhân tử Lagrange. Trong mỗi vòng lặp, SMO thực hiện hai thao tác chính:
- Lựa chọn hai nhân tử Lagrange phù hợp bằng phương pháp tìm kiếm heuristic thông minh (ưu tiên các mẫu vi phạm điều kiện tối ưu KKT nhiều nhất).
- Tối ưu hóa giải tích chính xác cặp nhân tử này trong khi cố định toàn bộ các nhân tử còn lại. Nhờ chỉ có hai biến số, bài toán có nghiệm đóng bằng giải tích mà không cần gọi bất kỳ hàm tối ưu ma trận phức tạp nào.
Nhờ triết lý chia để trị tinh tế, thuật toán SMO giảm độ phức tạp bộ nhớ xuống mức tuyến tính theo số mẫu dữ liệu, cho phép SVM huấn luyện nhanh chóng và ổn định trên các tập dữ liệu thực tế trong công nghiệp.
10. So sánh Chuyên sâu: Support Vector Machine vs Hồi quy Logistic
Khi đứng trước một bài toán phân loại nhị phân thực tế, các kỹ sư học máy thường phân vân giữa việc sử dụng Support Vector Machine hay Hồi quy Logistic. Dưới đây là phân tích chi tiết để đưa ra lựa chọn sáng suốt:
Thứ nhất, về mặt triết lý phân cách hình học, Hồi quy Logistic tìm kiếm một siêu phẳng phân cách dựa trên việc tối đa hóa xác suất đồng thời của tất cả các mẫu dữ liệu. Mọi điểm dữ liệu trong tập huấn luyện, dù nằm rất xa đường biên giới, đều đóng góp một phần lực kéo vào việc định hình vị trí siêu phẳng. Ngược lại, SVM hoàn toàn phớt lờ các điểm nằm xa ngoài lề; vị trí và góc nghiêng của siêu phẳng SVM chỉ phụ thuộc duy nhất vào một nhóm nhỏ các Support Vectors nằm sát đường biên giới. Điều này giúp SVM có độ bền vững phi thường trước các điểm dữ liệu dị biệt nằm sâu trong vùng an toàn của từng lớp.
Thứ hai, về mặt xác suất dự đoán, Hồi quy Logistic cung cấp trực tiếp một giá trị xác suất được hiệu chuẩn mượt mà từ 0 đến 1 thông qua hàm Sigmoid, rất phù hợp cho các bài toán kinh doanh cần định lượng mức độ rủi ro (như chấm điểm tín dụng ngân hàng hoặc dự đoán tỷ lệ khách hàng rời bỏ dịch vụ). Trong khi đó, SVM nguyên bản chỉ đưa ra quyết định hình học nhị phân cứng dựa trên dấu của hàm quyết định.
Thứ ba, về mặt năng lực biểu diễn dữ liệu phi tuyến, SVM kết hợp với Kernel Trick (đặc biệt là RBF Kernel) có thể tự động xây dựng ranh giới phân tách phi tuyến cực kỳ linh hoạt trong không gian nhiều chiều vô hạn mà không đòi hỏi kỹ sư phải tự tay tạo thêm các đặc trưng bậc cao. Do đó, SVM vượt trội hơn hẳn Logistic Regression khi làm việc với tập dữ liệu có số chiều đặc trưng rất lớn nhưng số lượng mẫu vừa phải, chẳng hạn như bài toán phân loại văn bản y khoa, nhận diện cấu trúc chuỗi DNA hoặc phân tích ảnh vi mô tế bào.
11. Kinh nghiệm Thực chiến: Tinh chỉnh Siêu tham số C và Gamma
Trong ứng dụng thực tế với Scikit-Learn hoặc LIBSVM, hiệu năng của mô hình SVM phụ thuộc quyết định vào hai siêu tham số then chốt là C và Gamma:
- Siêu tham số phạt sai số C: Đại diện cho sự đánh đổi giữa việc mở rộng độ rộng lề và việc chấp nhận sai số huấn luyện. Khi giá trị C quá nhỏ, mô hình dễ dãi với các điểm vi phạm, tạo ra lề rất rộng nhưng có nguy cơ bị underfitting. Ngược lại, khi C quá lớn, mô hình cố gắng phân loại đúng từng mẫu đơn lẻ bằng mọi giá, dẫn đến ranh giới uốn lượn phức tạp và rơi vào bẫy overfitting nghiêm trọng.
- Siêu tham số độ cong Gamma trong RBF Kernel: Quyết định bán kính ảnh hưởng của từng Support Vector đơn lẻ. Khi Gamma nhỏ, một điểm dữ liệu có tầm ảnh hưởng lan rộng khắp không gian, khiến ranh giới phân cách mềm mại và gần như tuyến tính. Khi Gamma rất lớn, mỗi điểm dữ liệu chỉ tạo ra một vùng ảnh hưởng cục bộ nhỏ hẹp quanh chính nó, khiến mô hình học thuộc lòng từng điểm dữ liệu huấn luyện và mất hoàn toàn khả năng khái quát hóa.
Phương pháp tốt nhất trong kỹ thuật học máy là luôn kết hợp kỹ thuật tìm kiếm lưới Grid Search cùng với kiểm chứng chéo K-Fold Cross Validation trên không gian logarit của C và Gamma để phát hiện cấu hình tối ưu nhất.
Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.


