Tiếp nối bài số 11 lý thuyết về cây quyết định - Decision tree, trong bài học này chúng ta sẽ thực hành huấn luyện (training) một Decision tree 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 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

Trong bài 3 chúng ta có nhắc đến phương pháp Hyperparameter tuning nhằm giúp cải tiến model. Trong bài thực hành ngày hôm nay chúng ta sẽ áp dụng phương pháp này để tìm ra các thông số vận hành (hyperparameter) của Decision tree model sao cho model của chúng ta đạt hiệu quả (performance) tốt nhất với tập dữ liệu (dataset) đã cho.

Đầu tiên chúng ta sẽ liệt kê các danh sách các hyperparameter và các giá trị để điểu chỉnh. Trong bài thực hành này chúng ta sẽ thực hiện tuning các thông số vận hành (hyperparameter) sau:

1. criterion: Chỉ sổ để tính độ vấy bẩn (impurity).

2. max_depth: Độ sâu lớn nhất mà cây có thể phát triển.

3. min_samples_split: Số cá thể (instance) tối thiểu để phân nhánh một nút (node).

4. min_samples_leaf: số cá thể (instance) tối thiểu ở lá (leaf).

1
2
3
4
5
6
7
list_criterion = ['gini', 'entropy']

list_max_depth = [5, 10, 15, 20, 25, 30]

list_min_samples_split = [2, 4, 6, 8, 10, 12, 14, 16 ,18, 20]

list_min_samples_leaf = [1, 2, 4, 6, 8, 10]

1
2
3
4
5
6
7
tuning_dict = dict(criterion  = list_criterion, 

                    max_depth = list_max_depth, 

                    min_samples_split = list_min_samples_split,

                    min_samples_leaf = list_min_samples_leaf)

Bước tiếp theo chúng ta sẽ sử dụng Grid search cross validation để tìm ra giá trị tốt nhất cho từng thông số vận hành (hyperparameter). K-Fold Cross validation là một phương pháp kiểm tra chéo trong đó tập huấn luyện (training set) sẽ được gấp làm k phần, k-1 phần sẽ được sử dụng để huấn luyện và 1 phần sẽ được sử dụng để xác nhận (validation). Model sẽ lần lượt trải qua k lần huấn luyện (training) với tập xác nhận (validation set) thay đổi khác nhau như mô tả ở hình bên dưới với k = 10. Hiệu suất (performance) tổng thể của model trong quá trính huấn luyện (training) ứng với trung bình của k lần huấn luyện (training). Grid search cross validation của thư viện sklearn sẽ thử từng cặp giá trị đã được nêu ở trên và kiểm tra xem các giá trị nào sẽ cho ra model tối ưu nhất.

1
2
3
4
5
# Khởi tạo Decision tree model

from sklearn.tree import DecisionTreeClassifier

dt_model = DecisionTreeClassifier()

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

# Khởi tạo grid search cross validation

search = GridSearchCV(dt_model, tuning_dict, verbose=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
Fitting 5 folds for each of 720 candidates, totalling 3600 fits


[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done 3600 out of 3600 | elapsed: 22.2min finished

Với số lượng khá lớn các giá trị để kiểm tra, phải mất đến hơn 20 phút Grid search cross validation mới thực hiện xong việc tìm kiếm. Giờ chúng ta sẽ xem các giá trị tốt nhất ứng với từng thông số vận hành (hyperparameter) như nào nhé.

1
best_hp.best_params_

1
2
3
4
{'criterion': 'gini',
 'max_depth': 25,
 'min_samples_leaf': 10,
 'min_samples_split': 12}

Huấn luyện Decision tree model

Decision tree model với hyperparameter tuning

Chúng ta sẽ khởi tạo lại Decision tree model, nhưng với các thông số vận hành (hyperparameter) tương ứng như trên nhé.

1
2
3
4
5
6
7
8
9
# Khởi tạo Decision Tree model với các hyperparameter

dt_model_tuning = DecisionTreeClassifier(criterion='gini', 

                                         max_depth=25, 

                                         min_samples_leaf=10, 

                                         min_samples_split=12)

1
2
3
# Fit model với tập huấn luyện

dt_model_tuning.fit(X_train, Y_train)

1
2
3
4
5
6
DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='gini',
                       max_depth=25, max_features=None, max_leaf_nodes=None,
                       min_impurity_decrease=0.0, min_impurity_split=None,
                       min_samples_leaf=10, min_samples_split=12,
                       min_weight_fraction_leaf=0.0, presort='deprecated',
                       random_state=None, splitter='best')

Chúng ta có thể vẽ Decision tree model vừa huấn luyện (training) xong sử dụng đoạn code sau:

1
2
from sklearn import tree
tree.plot_tree(dt_model_tuning) 

Tuy nhiên có thể thấy do độ phức tạp của dữ liệu cao khiến cho Decision tree model của chúng ta có độ sâu lớn nên hình vẽ không được rõ ràng và cụ thể.

Tiếp theo chúng ta sẽ kiểm tra hiệu năng của Decision tree 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)

dt_model_tuning_score = dt_model_tuning.score(X_train, Y_train)

dt_model_tuning_score

1
0.891353528665232

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

dt_model_tuning_score_val = dt_model_tuning.score(X_valid, Y_valid)

dt_model_tuning_score_val

1
0.8562127565658795

Có thể thấy độ chênh lệch giữa độ chính xác (accuracy) trên tập huấn luyện (training set) và tập xác nhận (validation set) là không quá lớn, cho thấy Decision model với hyperparameter tuning vừa được huấn luyện (training) có tính tổng quát (generalization) tốt, không có dấu hiệu quá vừa vặn (overfit).

Decision tree model mặc định

Để làm rõ hơn về tính hiệu quả mà hyperparameter tuning đem lại, chúng ta sẽ khởi tạo và huấn luyện (training) một Decision tree model nữa, nhưng model này sử dụng các thông số vận hành (hyperparameter) mặc định để xem sự khác biệt nhé.

1
2
3
# Khởi tạo Decision Tree model mặc định

dt_model = DecisionTreeClassifier()

1
2
3
# Fit model với tập huấn luyện

dt_model.fit(X_train, Y_train)

1
2
3
4
5
6
DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='gini',
                       max_depth=None, max_features=None, max_leaf_nodes=None,
                       min_impurity_decrease=0.0, min_impurity_split=None,
                       min_samples_leaf=1, min_samples_split=2,
                       min_weight_fraction_leaf=0.0, presort='deprecated',
                       random_state=None, splitter='best')

Giống như bên trên chúng ta sẽ kiểm tra độ chính xác (accuracy) trên tập huấn luyện (training set) và tập xác nhận (validation set) của Decision tree model mặc định.

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

dt_model_score = dt_model.score(X_train, Y_train)

dt_model_score

1
0.9999448214975446

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

dt_model_score_val = dt_model.score(X_valid, Y_valid)

dt_model_score_val

1
0.8307216949900684

Qua phần kiểm tra trên, chúng ta thấy độ chính xác (accuracy) của Decision tree model mặc định ở tập huấn luyện (training set) là rất cao 99%, tuy nhiên khi thực hiện dự đoán ở trên tập xác nhận (validation set) độ chính xác tụt xuống thấp hơn hẳn 83.1%, cho thấy model có dấu hiệu quá vừa vặn (overfit). Độ chính xác (accuracy) của Decision tree model mặc định trên tập xác nhận (validation set) cũng thấp hơn so với Decision tree model với hyperparameter tuning (83.1% và 85.6% tương ứng) dù Decision tree model với hyperparameter tuning có độ chính xác trên tập huấn luyện (training set) thấp hơn. Điều này chứng tỏ mức độ tổng quát (generalization) của model với hyperparameter tuning tốt hơn so với model mặc định.

Việc sử dụng hyperparameter tuning rõ ràng đã giúp model của chúng ta hiệu quả hơn so với việc sử dụng model mặc định, việc thay đổi các thông số vận hành (hyperparameter) đã giúp cho model có thể dừng việc quy nap (induction) sớm ngăn tình trạng quá vừa vặn (overfit) xảy ra, cải thiện độ tổng quát (generalization) vừa giúp tối ưu hiệu năng (performance) của model.

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

Chúng ta sẽ kiểm thử Decision tree model với hyperparameter tuning trên tập kiểm thử (test set) để đánh giá kỹ hơn hiệu năng (performance) của model 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
2
# Thực hiện phân loại dữ liệu trên tập kiểm thử (test set)
y_pred = dt_model_tuning.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 Decision tree model với hyperparameter tuning trên tập kiểm thử (test set).

1
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report

1
2
3
# Kiểm tra độ chính xác (accuracy)

accuracy_score(y_test, y_pred)

1
0.799800796812749

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.89      0.84      0.86     11360
         1.0       0.58      0.69      0.63      3700

    accuracy                           0.80     15060
   macro avg       0.73      0.76      0.75     15060
weighted avg       0.81      0.80      0.81     15060

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

|———————|———-|——–|———–|———-|

Decision model với hyperparameter tuning có độ chính xác (accuracy) tương đương với Logistic Regression model, nhưng độ bao phủ (recall) lại thấp hơn hẳn so với các model khác. Nhìn vào ma trận nhầm lẫn (confusion matrix) thì có thể thấy model đã dự đoán sai khá nhiều các cá thể (instance) thuộc nhóm (class) 1. Điểm sáng của model đó là có độ chuẩn xác (precision) tốt nhất 58%, do có ít các cá thể (instance) thuộc nhóm (class) 0 bị dự đoán sai hơn so với các model trước đó.

• Previous
  [Lý Thuyết] Bài 11 Cây quyết định - Decision Tree
• Next
  [Lý Thuyết] Bài 13 Máy vector hỗ trợ - Support Vector Machine