Trong bài học này chúng ta sẽ thực hành triển khai huấn luyện (training) một Naïve Bayes model cho bài toán phân loại (classication) dữ liệu nhé.

* Các bài thực hành đều sử dụng Python 3.

Import tập dữ liệu

Trong bài thực hành này và những bài thực hành sau về các ML model thực hiện bài toán phân loại (classification) chúng ta cũng sẽ 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 4 và 8. 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)

Huấn luyện Naive Bayes model

Trong thư viện Scikit-Learn có hỗ trợ 4 dạng Naive Bayes (NB):

1. Gaussian NB: Sử dụng hàm mật độ xác suất (probability density function) của phân phối chuẩn để tính khả năng (likelihood). Thích hợp với các tập dữ liệu (dataset) có dữ liệu dạng số (numerical value).

2. Multinomial NB: Sử dụng phương pháp đếm tần suất (frequency counting) như trong bài toán trường học ở bài lý thuyết để tính khả năng (likelihood). Thích hợp với các tập dữ liệu (dataset) có dữ liệu dạng phân loại (categorical value).

3. Complement NB: Phương pháp này tương tự như Multinomal NB, tuy nhiên sẽ bù trừ từ mỗi nhóm (class) để tính trọng số (weight) của model. Thích hợp với các tập dữ liệu (dataset) không cân bằng (imbalance).

4. Bernoulli NB: Khả năng (likelihood) được tính phân phối Bernoulli. Thích hợp với các tập dữ liệu dạng phân phối nhị phân (binary).

Tập dữ liệu (dataset) của chúng ta bao gồm cả dữ liệu dạng số (numerical value) cả dữ liệu dạng phân loại (categorical value), và cả dữ liệu phân phối dưới dạng nhị phân (Các cột được thực hiện One-hot encoding). Khác với ví dụ trong lý thuyết ở Bài 9, khi đó chúng ta sử dụng xen lẫn cả phương pháp Gaussian NB và Multinomial NB để tính toán, thư viện Scikit-Learn chỉ cho phép sử dụng một cách riêng biệt. Do đó chúng ta sẽ thử lần lượt từng loại NB model và xem model nào cho kết quả tốt nhất nhé.

Huấn luyện (training) Gaussian NB model

1
from sklearn.naive_bayes import GaussianNB

1
2
3
# Khởi tạo Gaussian NB model

gaussian_nb = GaussianNB()

1
2
3
# Fit tập dữ tập liệu huấn luyện (training set) với Gaussian NB model vừa tạo

gaussian_nb.fit(X_train, Y_train)

1
GaussianNB(priors=None, var_smoothing=1e-09)

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

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

gaussian_nb_score = gaussian_nb.score(X_train, Y_train)

gaussian_nb_score

1
0.7323014953374165

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

gaussian_nb_score_val = gaussian_nb.score(X_valid, Y_valid)

gaussian_nb_score_val

1
0.7350474508938424

Như vậy trong sau quá trình huấn luyện (training) Gaussian NB model có mức độ tổng quát (generalize) tốt, không bị hiện tượng quá vừa vặn (overfit). Bằng chứng là việc độ chính xác (accuracy) là tương đồng trên cả tập huấn luyện (training set) và tập xác nhận (validation set).

Huấn luyện (training) Multinomial NB model

1
from sklearn.naive_bayes import MultinomialNB

1
2
3
# Khởi tạo Multinomial NB model

multinomial_nb = MultinomialNB()

1
2
3
4
5
# Fit tập dữ tập liệu huấn luyện (training set) với Multinomial NB model vừa tạo 

# Ở đây chúng ta có một hyperparameter đó là alpha chỉ mức độ (degree) Laplace smoothing

multinomial_nb.fit(X_train, Y_train)

1
MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)

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

1
2
3
multinomial_nb_score = multinomial_nb.score(X_train, Y_train)

multinomial_nb_score

1
0.8375820780224025

1
2
3
multinomial_nb_score_val = multinomial_nb.score(X_valid, Y_valid)

multinomial_nb_score_val

1
0.8401015228426396

Tương tự như trên Multinomial NB model cũng không xuất hiện hiện tượng quá vừa vặn (overfit).

Huấn luyện (training) Bernoulli NB model

1
from sklearn.naive_bayes import BernoulliNB

1
2
3
# Khởi tạo Bernoulli NB model

bernoulli_nb = BernoulliNB()

1
2
3
4
5
# Fit tập dữ tập liệu huấn luyện (training set) với Multinomial NB model vừa tạo 

# Tương tự như Multinomial NB model, Bernoulli NB model cũng có hyperparameter alpha chỉ mức độ (degree) Laplace smoothing

bernoulli_nb.fit(X_train, Y_train)

1
BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)

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

1
2
3
bernoulli_nb_score = bernoulli_nb.score(X_train, Y_train)

bernoulli_nb_score

1
0.8195111184682448

1
2
3
bernoulli_nb_score_val = bernoulli_nb.score(X_valid, Y_valid)

bernoulli_nb_score_val

1
0.8225557272125359

Tương tự như 2 model trên Bernoulli NB model cũng không xuất hiện hiện tượng quá vừa vặn (overfit). Giờ chúng ta sẽ tổng hợp và vẽ biểu đồ cột (bar plot) hiệu năng (performance) của cả 3 model để đánh giá nhé.

1
2
3
import matplotlib.pyplot as plt

import numpy as np

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Chuẩn bị dữ liệu

performances = [[gaussian_nb_score, multinomial_nb_score, bernoulli_nb_score], [gaussian_nb_score_val, multinomial_nb_score_val, bernoulli_nb_score_val]]

names = ['Gaussian NB', 'Multinomial NB', 'Bernoulli NB']

# Vẽ dữ liệu

idx = np.arange(len(names))

plt.bar(idx, performances[0], label='Training accuracy', width = 0.25)

plt.bar(idx+0.25, performances[1], label='Validation accuracy', width = 0.25)

# Sửa các thanh đơn vị

tick_pos = [0.1, 1.1, 2.1]

plt.xticks(tick_pos, names)

plt.ylabel('Accuracy')

plt.legend()

Có thể thấy Multinomial NB là model có độ chính xác (accuracy) trên cả tập huấn luyện (training set) và tập xác nhận (validation set) vượt trội hơn cả so với 2 model còn lại. Có thể lý giải nguyên nhân Gaussian NB có độ chính xác thấp nhất vì phần lớn các biến không phụ thuộc (dataset) này có dữ liệu dạng phân loại (categorical value). Việc sử dụng mật độ xác suất (probability density) theo phân phối chuẩn (normal distribution) trên các dữ liệu dạng này gây sai sót cho model.

Kiểm thử Naive Bayes model đã huấn luyện

Chúng ta sẽ kiểm thử Naive Bayes model tốt nhất đó là Multinomial NB trên tập dữ liệu kiểm thử (test set) và so sánh với Logistic Regression model chúng ta đã huấn luyện (training) ở bài 8 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 = multinomial_nb.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), độ chuẩn xác (precision), ma trận nhầm lẫn (confusion matrix) để kiểm tra hiệu năng (performance) của Multinomial NB model 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.7715139442231076

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.77      0.84     11360
         1.0       0.52      0.77      0.62      3700

    accuracy                           0.77     15060
   macro avg       0.72      0.77      0.73     15060
weighted avg       0.82      0.77      0.78     15060

Dù độ chính xác là 77% nhưng vẫn có rất nhiều dữ liệu bị phân loại nhầm từ nhóm (class) 1 sang nhóm (class) 0. Điều này thể hiện ở độ chuẩn xác (precision) ở nhóm (class) 1 chỉ đạt 52%. Cùng xem lại kết quả dự đoán của Logistic Regression ở bài thực hành 8 nhé:

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.57      0.76      0.65      3700

    accuracy                           0.80     15060
   macro avg       0.74      0.79      0.76     15060
weighted avg       0.83      0.80      0.81     15060

Có thể thấy hiệu năng (performance) của Naive Bayes model kém hơn hẳn so với Logistic Regression model. Độ chuẩn xác (precision) ở nhóm (class) 1 của Naive Bayes model thậm chí còn thấp hơn khá nhiều so với Logitic Regression model (52% và 57%). Do precision ở nhóm (class) 1 giảm, độ bao phủ (recall) của nhóm (class) 0 ở Naive Bayes model cũng giảm hơn hẳn (77% và 81%). Tuy nhiên một điểm sáng của Naive Bayes model là độ bao phủ (recall) của nhóm (class) 1 lại nhỉnh hơn một chút so với Logistic Regression model (77% và 76%).

• Previous
  [Lý Thuyết] Bài 9 Phân loại Naïve Bayes - Naïve Bayes classifier
• Next
  [Lý Thuyết] Bài 11 Cây quyết định - Decision Tree