Tiếp nối bài số 13 lý thuyết về máy vector hỗ trợ - Support Vector Machine (SVM), trong bài học này chúng ta sẽ thực hành huấn luyện (training) một SVM model cho bài toán phân loại (classication) dữ liệu nhé.

Import tập dữ liệu

Trong bài học này chúng ta sẽ tiếp tục sử dụng tập dữ liệu (dataset) về người trưởng thành đã được sử dụng trong các bài thực hành trước. Dataset này được trải qua tiền xử lý (pre-processing) ở bài 4 và sẵn sàng cho việc huấn luyện (training) các ML model. Việc tái sử dụng tập dữ liệu này nhằm mục đích so sánh hiệu năng của các ML model và nhận xét về những sự khác biệt.

1
import pandas as pd

1
2
3
df = pd.read_csv('/content/new_adult_data.csv')

df

Phân chia tập dữ liệu

Tách biến không phụ thuộc (independent variable) và biến phụ thuộc (dependent variable) từ tập dữ liệu (dataset)

1
2
3
x = df.iloc[:,0:104]

y = df.iloc[:,104]

Tiếp theo chúng ta sẽ phân chia tập dữ liệu (dataset) thành hai tập nhỏ hơn: tập dữ liệu huấn luyện (training set) và tập dữ liệu xác nhận (validation set) với tỷ lệ 80% và 20%.

• random_state nhằm đảm bảo việc phân chia dữ liệu là như nhau trong mọi lần chạy.

1
from sklearn.model_selection import train_test_split

1
X_train, X_valid, Y_train, Y_valid = train_test_split(x, y, test_size = 0.2, random_state = 101)

Hyperparameter tuning

Ở bài thực hành này chúng ta cũng sẽ sử dụng hyperparameter tuning để tìm ra được SVM model có hiệu năng (performance) tốt nhất. Ở bài lý thuyết trước chúng ta đã biết đến 2 hyperpameter có thể tuning khi sử dụng SVM đó là: C biểu thị mức độ phạt trong lề mềm (soft margin) và kernel giúp biến đổi dữ liệu sang chiều (dimension) cao hơn.

Hôm nay chúng ta sẽ tuning một hyperparameter nữa đó là Gamma. Gamma là hyperparameter được sử dụng với các kernel RBF, Poly and Sigmoid. Một cách trực quan, Gamma sẽ biểu thị xem mức độ xa gần của các vector hỗ trợ (support vector). Gamma càng nhỏ các vector hỗ trợ (support vector) sẽ ở càng ở xa so với siêu phẳng (hyperplane). Khi để Gamma quá lớn SVM model sẽ càng cong theo dữ liệu không tuyến tính (non-linear), từ đó dễ dẫn đến việc quá vừa vặn (overfit). Tuy nhiên nếu để Gamma quá nhỏ, SVM model sẽ trở nên rất dễ dãi. Vì vậy để tìm một Gamma thích hợp cho tập dữ liệu (dataset), chúng ta cần phải sử dụng hyperpameter tuning. Hình dưới đây minh họa trực quan hơn về Gamma.

1
2
3
4
5
list_kernel = ['linear', 'poly', 'rbf', 'sigmoid']

list_c = [0.1, 1]

list_gamma = [1, 0.1]

1
2
3
4
5
tuning_dict = dict(kernel = list_kernel,

                   C = list_c,

                   gamma = list_gamma)

Tiếp theo chúng ta sẽ khởi tạo SVM model nhé

1
2
3
from sklearn.svm import SVC

svm_model = SVC()

1
2
3
4
5
6
7
8
9
from sklearn.model_selection import GridSearchCV

# Khởi tạo grid search cross validation, n_jobs để xử lý song song

search = GridSearchCV(svm_model, tuning_dict, verbose=1, n_jobs=-1)

# Fit grid search cross validation với tập huấn luyện

best_hp = search.fit(X_train, Y_train)

1
2
3
4
5
6
Fitting 5 folds for each of 16 candidates, totalling 80 fits


[Parallel(n_jobs=-1)]: Using backend LokyBackend with 2 concurrent workers.
[Parallel(n_jobs=-1)]: Done  46 tasks      | elapsed: 76.0min
[Parallel(n_jobs=-1)]: Done  80 out of  80 | elapsed: 135.9min finished

Sau hơn 135 phút, Grid search with cross validation đã tìm ra cho chúng ta các giá trị tốt nhất ứng với mỗi hyperparameter. Chúng ta cùng xem các giá trị ấy như nào nhé.

1
best_hp.best_params_

1
{'C': 1, 'gamma': 0.1, 'kernel': 'rbf'}

Như vậy chúng ta sẽ cần phải sử dụng hàm kernel (kernel function) RBF thì SVM model mới đạt hiệu năng (performance) tốt nhất. Điều này cho thấy dữ liệu của chúng ta có tính chất phi tuyến tính (non-linear).

Huấn luyện SVM model

Chúng ta sẽ khởi tạo lại SVM model nhưng với các hyperparameter có giá trị như bên trên nhé.

1
2
3
# Khởi tạo SVM model với các hyperparameter

svm_model = SVC(C = 1, kernel='rbf', gamma=0.1)

1
2
3
# Fit SVM model với tập dữ liệu huấn luyện

svm_model.fit(X_train, Y_train)

1
2
3
4
SVC(C=1, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma=0.1, kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)

Có thể thấy quá trình huấn luyện (training) của SVM model lâu hơn so với các model trước đây chúng ta đã thực hiện, đây là lý do vì sao mà việc hyperparameter tuning diễn ra khá lâu.

Tiếp theo chúng ta sẽ kiểm tra hiệu năng của SVM model trên cả tập huấn luyện (training set) và tập xác nhận (validation set)

1
2
3
4
5
# Độ chính xác (accuracy) trên tập huấn luyện (training set)

svm_model_score = svm_model.score(X_train, Y_train)

svm_model_score

1
0.8594603542459858

1
2
3
4
5
# Độ chính xác (accuracy) trên tập xác nhận (validation set)

svm_model_score_val = svm_model.score(X_valid, Y_valid)

svm_model_score_val

1
0.8533436327521519

Độ chính xác (accuracy) của model trên cả tập huấn luyện (training set) và tập xác nhận (validation set) là gần như tương đồng nhau, cho thấy mức độ tổng quát (generalization) tốt của SVM model đã được huấn luyện.

Kiểm tra SVM model đã huấn luyện

Sau khi xác nhận SVM model vừa huấn luyện không gặp tình trạng quá vừa vặn (overfit) với tập huấn luyện (training set) giờ chúng ta kiểm thử nó trên tập kiểm thử (testing set) nhé.

1
2
3
4
5
# Import dữ liệu từ tập kiểm thử (test set)

df_test = pd.read_csv('/content/new_adult_test.csv')

df_test

1
2
3
4
5
6
7
# Tách biến không phụ thuộc (indepedent variable)

x_test = df_test.iloc[:, 0:104]

# Tách biến phụ thuộc (depedent variable)

y_test = df_test.iloc[:,104]

1
y_pred = svm_model.predict(x_test)

Chúng ta sẽ lần lượt kiểm tra các chỉ số độ chính xác (accuracy), độ bao phủ (recall / sensitivity), độ chuẩn xác (precision), ma trận nhầm lẫn (confusion matrix) dự đoán của SVM model trên tập kiểm thử (testing set).

1
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import seaborn as sns

import matplotlib.pyplot as plt



def draw_cf_matrix(label, pred):

  cf_matrix = confusion_matrix(label, pred)

  ax = plt.subplot()

  sns.heatmap(cf_matrix, annot=True, ax = ax, fmt='g', cmap='Greens')

  ax.set_xlabel('Predicted labels')

  ax.set_ylabel('True labels')

  ax.set_title('Confusion Matrix')

  ax.xaxis.set_ticklabels([0, 1])

  ax.yaxis.set_ticklabels([0, 1])

  cf_matrix

1
2
3
# Vẽ ma trận nhầm lẫn

draw_cf_matrix(y_test, y_pred)

1
2
3
# In báo cáo phân loại

print(classification_report(y_test, y_pred))

1
2
3
4
5
6
7
8
              precision    recall  f1-score   support

         0.0       0.91      0.81      0.86     11360
         1.0       0.56      0.76      0.64      3700

    accuracy                           0.80     15060
   macro avg       0.74      0.78      0.75     15060
weighted avg       0.82      0.80      0.80     15060

Chúng ta so sánh với các kết quả phân loại của Logistic Regression model, Naive Bayes model và Decision tree model đã được huấn luyện (training) ở các bài thực hành số 8, 10 và 12:

Qua bảng so sánh trên có thể thấy, SVM model có hiệu năng (performance) gần như tương đồng với Logistic Regression model và tốt hơn so với 2 model Naive Bayes và Decision tree. Các model chúng ta đã huấn luyện đều có điểm yếu cố hữu ở việc phân loại các cá thể (instance) ở nhóm 1 - nhóm có thu nhập lớn hơn 50K.

• Previous
  [Lý Thuyết] Bài 13 Máy vector hỗ trợ - Support Vector Machine
• Next
  [Lý Thuyết] Bài 15 Mạng thần kinh nhân tạo - Artificial Neural Network