Top 10 thuật toán Machine Learning vào năm 2026

Có lẽ chúng ta đang sống trong giai đoạn mang tính bước ngoặt nhất của lịch sử nhân loại - thời kỳ mà công nghệ điện toán chuyển mình từ các hệ thống mainframe lớn sang PC và giờ đây là điện toán đám mây (cloud). Tuy nhiên, điều thực sự tạo nên dấu ấn của thời đại này không chỉ nằm ở những gì đã qua, mà còn ở những điều đang chờ đón chúng ta trong tương lai gần.

Điều khiến giai đoạn này trở nên đầy hứng khởi và lôi cuốn chính là sự phổ cập hóa các công cụ, kỹ thuật và thuật toán Machine Learning – hệ quả trực tiếp từ sự bùng nổ của công nghệ điện toán. Trong bài viết này, chúng ta sẽ cùng tìm hiểu về 10 thuật toán Machine Learning cũng như cách chúng giải quyết các vấn đề dữ liệu thông qua những khía cạnh cụ thể và những ví dụ thực tế.

Ngày nay, các nhà khoa học dữ liệu có thể xây dựng những hệ thống xử lý dữ liệu mạnh mẽ dựa trên nhiều thuật toán phức tạp với chi phí chỉ vài USD mỗi giờ. Thế nhưng, để đạt được thành quả này không hề dễ dàng; họ phải trải qua những khoảng thời gian đầy gian nan và vất vả.

Dưới đây là danh sách các thuật toán Machine Learning thường được sử dụng. Các thuật toán này có thể áp dụng cho hầu hết mọi vấn đề liên quan đến dữ liệu:

1. Hồi quy tuyến tính (Linear Regression)

Thuật toán này được sử dụng để ước tính các giá trị thực (giá nhà, số lượng cuộc gọi, tổng doanh số, v.v...) dựa trên (những) biến liên tục. Tại đây, chúng ta thiết lập mối quan hệ giữa biến độc lập và biến phụ thuộc bằng cách xác định đường thẳng phù hợp nhất.

Đường thẳng phù hợp nhất này được gọi là đường hồi quy và được biểu diễn bằng phương trình tuyến tính Y = a*X + b.

Ví dụ 1

Cách tốt nhất để hiểu về hồi quy tuyến tính là nhớ lại một trải nghiệm thời thơ ấu. Giả sử bạn yêu cầu một học sinh lớp 5 sắp xếp các bạn trong lớp theo thứ tự cân nặng tăng dần mà không được hỏi cân nặng của họ! Bạn nghĩ đứa trẻ sẽ làm gì? Có thể trẻ sẽ quan sát (phân tích bằng mắt) chiều cao và vóc dáng của các bạn, rồi sắp xếp họ dựa trên sự kết hợp của những đặc điểm có thể nhìn thấy này. Đây chính là hồi quy tuyến tính trong đời thực! Đứa trẻ thực ra đã nhận ra rằng chiều cao và vóc dáng có mối tương quan với cân nặng theo một quy luật nào đó, trông giống như phương trình đã nêu ở trên.

Trong phương trình này:

• Y – Biến phụ thuộc
• a – Hệ số góc
• X – Biến độc lập
• b – Hệ số chặn (điểm cắt trục tung)

Các hệ số a và b này được xác định dựa trên việc tối thiểu hóa tổng bình phương khoảng cách giữa những điểm dữ liệu và đường hồi quy.

Ví dụ 2

Hãy xem ví dụ dưới đây. Ở đây, chúng ta đã xác định được đường thẳng phù hợp nhất với phương trình tuyến tính y = 0,2811x + 13,9. Giờ đây, khi đã biết chiều cao của một người, ta có thể sử dụng phương trình này để xác định cân nặng của họ.

Hồi quy tuyến tính chủ yếu bao gồm hai loại: Hồi quy tuyến tính đơn và Hồi quy tuyến tính bội. Hồi quy tuyến tính đơn được đặc trưng bởi một biến độc lập. Trong khi đó, hồi quy tuyến tính bội (đúng như tên gọi của nó) được đặc trưng bởi nhiều biến độc lập (nhiều hơn một biến). Khi xác định đường phù hợp nhất, bạn có thể áp dụng mô hình hồi quy đa thức hoặc hồi quy đường cong; các phương pháp này được gọi tương ứng là hồi quy đa thức hoặc hồi quy đường cong.

Dưới đây là cửa sổ lập trình để bạn thử sức và tự xây dựng mô hình Hồi quy Tuyến tính (Linear Regression) của riêng mình:

Python

# Nhập các thư viện cần thiết
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train.csv')
test_data = pd.read_csv('test.csv')

print(train_data.head())

# Hình dạng của tập dữ liệu
print('\nHình dạng của dữ liệu huấn luyện:',train_data.shape)
print('\nHình dạng của dữ liệu kiểm tra:',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu bị thiếu trong dữ liệu kiểm tra
# Biến mục tiêu - Item_Outlet_Sales

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện
train_x = train_data.drop(columns=['Item_Outlet_Sales'],axis=1)
train_y = train_data['Item_Outlet_Sales']

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện

test_x = test_data.drop(columns=['Item_Outlet_Sales'],axis=1)
test_y = test_data['Item_Outlet_Sales']

'''
Tạo đối tượng của mô hình Hồi quy tuyến tính
Bạn cũng có thể thêm các tham số khác và kiểm tra mã của mình tại đây
Một số tham số là: fit_intercept và normalize
Tài liệu về sklearn LinearRegression:

https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html

'''
model = LinearRegression()

# Huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# Hệ số của mô hình đã huấn luyện
print('\nHệ số của mô hình:', model.coef_)

# Hệ số chặn của mô hình
print('\nHệ số chặn của mô hình',model.intercept_)

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra tập dữ liệu
predict_train = model.predict(train_x)
print('\nItem_Outlet_Sales trên tập dữ liệu huấn luyện',predict_train)

# Sai số bình phương trung bình gốc trên tập dữ liệu huấn luyện
rmse_train = mean_squared_error(train_y,predict_train)**(0.5)
print('\nRMSE trên tập dữ liệu huấn luyện: ', rmse_train)

# Dự đoán mục tiêu trên tập dữ liệu kiểm thử
predict_test = model.predict(test_x)
print('\nItem_Outlet_Sales trên tập dữ liệu kiểm thử',predict_test)

# Sai số bình phương trung bình gốc trên tập dữ liệu kiểm thử
rmse_test = mean_squared_error(test_y,predict_test)**(0.5)
print('\nRMSE trên tập dữ liệu kiểm thử: ', rmse_test)

Code R

# Load các tập dữ liệu huấn luyện và kiểm thử
# Xác định các biến đầu vào và biến mục tiêu; các giá trị phải ở dạng số và mảng numpy
x_train <- input_variables_values_training_datasets
y_train <- target_variables_values_training_datasets
x_test <- input_variables_values_test_datasets
x <- cbind(x_train,y_train)
# Huấn luyện mô hình sử dụng các tập dữ liệu huấn luyện và kiểm tra kết quả
linear <- lm(y_train ~ ., data = x)
summary(linear)
# Dự đoán kết quả đầu ra
predicted= predict(linear,x_test)

2. Hồi quy Logistic (Logistic Regression)

Đừng để tên gọi làm bạn nhầm lẫn! Đây là một thuật toán phân loại, không phải thuật toán hồi quy. Nó được sử dụng để ước tính các giá trị rời rạc (các giá trị nhị phân như 0/1, yes/no, true/false) dựa trên một tập hợp những biến độc lập cho trước. Nói một cách đơn giản, nó dự đoán xác suất xảy ra của một sự kiện bằng cách khớp dữ liệu vào một hàm logistic. Do đó, nó còn được gọi là hồi quy logit. Vì nó dự đoán xác suất, các giá trị đầu ra của nó nằm trong khoảng từ 0 đến 1 (như mong đợi).

Một lần nữa, hãy thử tìm hiểu điều này thông qua một ví dụ đơn giản.

Giả sử bạn của bạn đưa cho bạn một câu đố để giải. Chỉ có 2 kịch bản kết quả xảy ra – hoặc là bạn giải được, hoặc là không. Bây giờ, hãy tưởng tượng bạn được giao nhiều loại câu đố/bài kiểm tra khác nhau để xác định xem bạn giỏi ở những môn học nào. Kết quả của nghiên cứu này có thể được diễn giải như sau: Nếu bạn gặp một bài toán lượng giác lớp 10, xác suất bạn giải được là 70%; ngược lại, nếu đó là một câu hỏi lịch sử lớp 5, xác suất tìm ra đáp án chỉ là 30%. Đây chính là thông tin mà mô hình Hồi quy Logistic cung cấp cho bạn.

Xét về mặt toán học, log của tỷ lệ chênh (log-odds) đối với kết quả đầu ra được mô hình hóa dưới dạng một tổ hợp tuyến tính của các biến dự báo.

odds = p / (1-p) = xác suất xảy ra sự kiện / xác suất không xảy ra sự kiện
ln(odds) = ln(p/(1-p))
logit(p) = ln(p/(1-p)) = b0 + b1X1 + b2X2 + b3X3 + ... + bkXk

Trong đó, p là xác suất xuất hiện đặc tính cần nghiên cứu. Mô hình này lựa chọn các tham số sao cho tối đa hóa khả năng quan sát được các giá trị mẫu, thay vì tối thiểu hóa tổng bình phương sai số (như trong hồi quy thông thường).

Có thể bạn sẽ thắc mắc tại sao lại dùng hàm logarit? Đơn giản mà nói, đây là một trong những phương pháp toán học tối ưu nhất để mô phỏng hàm bậc thang. 

Hãy tự xây dựng mô hình hồi quy logistic bằng Python tại đây và kiểm tra độ chính xác:

# nhập các thư viện cần thiết
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# đọc tập dữ liệu huấn luyện và kiểm thử
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')


print(train_data.head())

# kích thước của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu còn thiếu trong dữ liệu kiểm thử
# biến mục tiêu - Survived

# tách biến độc lập và biến mục tiêu trong dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# tách biến độc lập và biến mục tiêu trong dữ liệu kiểm thử
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng mô hình Hồi quy Logistic
Bạn cũng có thể thêm các tham số khác và thử nghiệm code tại đây
Một số tham số bao gồm: fit_intercept và penalty
Tài liệu về sklearn LogisticRegression:

https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html

'''
model = LogisticRegression()

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# các hệ số của mô hình đã huấn luyện
print('Coefficient of model :', model.coef_)

# hệ số chặn (intercept) của mô hình
print('Intercept of model',model.intercept_)

# dự đoán biến mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('Target on train data',predict_train) 

# Điểm độ chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('accuracy_score on train dataset : ', accuracy_train)

# dự đoán biến mục tiêu trên tập dữ liệu kiểm thử
predict_test = model.predict(test_x)
print('Target on test data',predict_test) 

# Điểm độ chính xác trên tập dữ liệu kiểm thử
accuracy_test = accuracy_score(test_y,predict_test)
print('accuracy_score on test dataset : ', accuracy_test)

Code R:

x <- cbind(x_train, y_train)
# Huấn luyện mô hình sử dụng các tập dữ liệu huấn luyện và kiểm tra điểm số
logistic <- glm(y_train ~ ., data = x, family='binomial')
summary(logistic)
# Dự đoán kết quả
predicted = predict(logistic, x_test)

Hơn nữa…

Có nhiều bước khác nhau có thể thử nghiệm để cải thiện mô hình:

• bao gồm các số hạng tương tác 
• loại bỏ các đặc trưng 
• sử dụng các kỹ thuật điều chuẩn 
• sử ​​dụng mô hình phi tuyến tính

3. Cây quyết định (Decision Tree)

Đây là một trong những thuật toán được yêu thích nhất và thường xuyên sử dụng. Nó thuộc loại thuật toán học có giám sát, chủ yếu được dùng cho các bài toán phân loại. Điều thú vị là nó hoạt động hiệu quả với cả biến phụ thuộc dạng phân loại (categorical) lẫn dạng liên tục (continuous). Trong thuật toán này, chúng ta chia tập dữ liệu ban đầu thành hai hoặc nhiều tập con đồng nhất. Quá trình này dựa trên các thuộc tính (hoặc biến độc lập) quan trọng nhất để tạo ra những nhóm khác biệt nhau nhiều nhất có thể. 

Trong hình trên, bạn có thể thấy tập dữ liệu được phân loại thành 4 nhóm khác nhau dựa trên nhiều thuộc tính để xác định xem liệu họ "có chơi hay không". Để chia tập dữ liệu thành các nhóm khác biệt, thuật toán sử dụng nhiều kỹ thuật khác nhau như Gini, Information Gain, Chi-square và Entropy.

Cách tốt nhất để hiểu cơ chế hoạt động của cây quyết định là chơi thử Jezzball – một trò chơi kinh điển của Microsoft (hình bên dưới). Về cơ bản, bạn có một căn phòng với các bức tường di động và nhiệm vụ của bạn là dựng thêm những bức tường sao cho giải phóng được diện tích lớn nhất mà không va chạm với các quả bóng.

Như vậy, mỗi lần dựng một bức tường để chia căn phòng, bạn đang cố gắng tạo ra 2 tập hợp (nhóm) khác nhau trong cùng một không gian. Cây quyết định hoạt động theo cách tương tự: chia một tập dữ liệu thành các nhóm khác biệt nhau nhiều nhất có thể.

Hãy cùng bắt tay vào thực hành và tự viết code cho thuật toán cây quyết định bằng Python!

# nhập các thư viện cần thiết
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# đọc tập dữ liệu huấn luyện và kiểm thử
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# kích thước của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu còn thiếu trong dữ liệu kiểm thử
# biến mục tiêu - Survived

# tách biến độc lập và biến mục tiêu trong dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# tách biến độc lập và biến mục tiêu trong dữ liệu kiểm thử
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng mô hình Cây quyết định (Decision Tree)
Bạn cũng có thể thêm các tham số khác và thử nghiệm code tại đây
Một số tham số bao gồm: max_depth và max_features
Tài liệu về sklearn DecisionTreeClassifier:

https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html

'''
model = DecisionTreeClassifier()

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# độ sâu của cây quyết định
print('Depth of the Decision Tree :', model.get_depth())

# dự đoán biến mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('Target on train data',predict_train) 

# Điểm độ chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('accuracy_score on train dataset : ', accuracy_train)

# dự đoán biến mục tiêu trên tập dữ liệu kiểm thử
predict_test = model.predict(test_x)
print('Target on test data',predict_test) 

# Điểm độ chính xác trên tập dữ liệu kiểm thử
accuracy_test = accuracy_score(test_y,predict_test)
print('accuracy_score on test dataset : ', accuracy_test)

Code R:

library(rpart)
x <- cbind(x_train,y_train)
# xây dựng cây
fit <- rpart(y_train ~ ., data = x,method="class")
summary(fit)
#Dự đoán kết quả
predicted= predict(fit,x_test)

4. SVM (Support Vector Machine)

Đây là một phương pháp phân loại. Trong thuật toán SVM, mỗi phần tử dữ liệu được biểu diễn dưới dạng một điểm trong không gian n chiều (với n là số lượng đặc trưng), trong đó giá trị của mỗi đặc trưng tương ứng với giá trị của một tọa độ cụ thể.

Ví dụ, nếu chỉ có hai đặc trưng là Chiều cao và Độ dài tóc của một cá nhân, trước tiên ta sẽ biểu diễn hai biến này trong không gian hai chiều, nơi mỗi điểm có hai tọa độ (các tọa độ này được gọi là Support Vectors).

Tiếp theo, ta tìm các đường thẳng giúp phân chia dữ liệu thành hai nhóm riêng biệt. Đường thẳng được chọn sẽ đảm bảo khoảng cách đến điểm gần nhất của mỗi nhóm là lớn nhất có thể. Nếu có nhiều biến hơn, một siêu phẳng (hyperplane) sẽ được sử dụng để phân tách các lớp dữ liệu.

Trong ví dụ trên, đường thẳng màu đen là đường phân chia dữ liệu thành hai nhóm, vì nó tối đa hóa khoảng cách đến hai điểm gần nhất của mỗi nhóm. Đường thẳng này đóng vai trò là bộ phân loại. Sau đó, tùy thuộc vào việc dữ liệu kiểm thử nằm ở phía nào của đường thẳng, ta sẽ xác định được lớp tương ứng cho dữ liệu mới đó.

Hãy hình dung thuật toán này giống như trò chơi JezzBall nhưng diễn ra trong không gian n chiều. Các điểm khác biệt so với trò chơi gốc bao gồm:

• Bạn có thể vẽ các đường thẳng hoặc mặt phẳng ở bất kỳ góc độ nào (thay vì chỉ theo chiều ngang hoặc chiều dọc như trong trò chơi kinh điển).
• Mục tiêu của trò chơi là tách biệt các quả bóng có màu sắc khác nhau vào những khu vực (phòng) riêng biệt.
• Và các quả bóng này đứng yên, không di chuyển.

Hãy thử sức thiết kế một mô hình SVM bằng Python thông qua cửa sổ code dưới đây:

# nhập các thư viện cần thiết
import pandas as pd
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# đọc tập dữ liệu huấn luyện và kiểm thử
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# kích thước của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu còn thiếu trong dữ liệu kiểm thử
# biến mục tiêu - Survived

# tách biến độc lập và biến mục tiêu trong dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# tách biến độc lập và biến mục tiêu trong dữ liệu kiểm thử
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng mô hình Support Vector Classifier (SVC)
Bạn cũng có thể thêm các tham số khác và thử nghiệm code của mình tại đây
Một số tham số bao gồm: kernel và degree
Tài liệu về sklearn Support Vector Classifier:

https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html

'''
model = SVC()

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# dự đoán biến mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('Target on train data',predict_train) 

# Điểm độ chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('accuracy_score on train dataset : ', accuracy_train)

# dự đoán biến mục tiêu trên tập dữ liệu kiểm thử
predict_test = model.predict(test_x)
print('Target on test data',predict_test) 

# Điểm độ chính xác trên tập dữ liệu kiểm thử
accuracy_test = accuracy_score(test_y,predict_test)
print('accuracy_score on test dataset : ', accuracy_test)

Code R:

library(e1071)
x <- cbind(x_train,y_train)
# Huấn luyện mô hình
fit <-svm(y_train ~ ., data = x)
summary(fit)
# Dự đoán kết quả
predicted= predict(fit,x_test)

5. Naive Bayes

Naive Bayes là một kỹ thuật phân loại dựa trên định lý Bayes với giả định về tính độc lập giữa các biến dự báo (đặc trưng). Nói một cách đơn giản, bộ phân loại Naive Bayes giả định rằng sự hiện diện của một đặc trưng cụ thể trong một lớp không liên quan đến sự hiện diện của bất kỳ đặc trưng nào khác. Ví dụ, một loại quả có thể được coi là táo nếu nó có màu đỏ, hình tròn và đường kính khoảng 3 inch. Ngay cả khi các đặc trưng này có mối liên hệ với nhau, thuật toán phân loại Naive Bayes vẫn coi mỗi thuộc tính đóng góp một cách độc lập vào xác suất quả đó là táo.

Mô hình Naive Bayes rất dễ xây dựng và đặc biệt hữu ích cho các tập dữ liệu rất lớn. Bên cạnh sự đơn giản, phương pháp phân loại Naive Bayes còn được biết đến với hiệu suất vượt trội so với cả những phương pháp phức tạp hơn trong các tác vụ như phân loại văn bản, phát hiện thư rác và phân tích cảm xúc.

Phương trình Naive Bayes

Định lý Bayes cung cấp cách tính xác suất hậu nghiệm P(c|x) từ P(c), P(x) và P(x|c). Hãy xem phương trình dưới đây:

Trong đó:

• P(c|x) là xác suất hậu nghiệm của lớp (biến mục tiêu) khi biết biến dự báo (thuộc tính).
• P(c) là xác suất tiên nghiệm của lớp.
• P(x|c) là độ khả dĩ (likelihood) – tức xác suất của biến dự báo khi biết lớp đó.
• P(x) là xác suất tiên nghiệm của biến dự báo.

Ví dụ

Hãy cùng tìm hiểu thông qua một ví dụ. Dưới đây là tập dữ liệu huấn luyện về thời tiết và biến mục tiêu tương ứng là 'Play'. Bây giờ, chúng ta cần phân loại xem người chơi có tham gia chơi hay không dựa trên điều kiện thời tiết. Hãy thực hiện theo các bước dưới đây.

Thời gian cần thiết: 3 phút

1. Chuyển đổi tập dữ liệu thành bảng tần suất.

2. Tạo bảng độ khả dĩ (Likelihood table) bằng cách tính các xác suất, ví dụ: xác suất trời nhiều mây (Overcast) = 0,29 và xác suất chơi là 0,64.

3. Bây giờ, sử dụng phương trình Naive Bayes để tính xác suất hậu nghiệm cho mỗi lớp. Lớp có xác suất hậu nghiệm cao nhất chính là kết quả dự đoán.

Vấn đề: Người chơi sẽ tham gia nếu thời tiết có nắng. Nhận định này có đúng không? Chúng ta có thể giải quyết vấn đề này bằng phương pháp đã thảo luận ở trên, theo đó P(Yes | Sunny) = P(Sunny | Yes) * P(Yes) / P(Sunny).

Ở đây, ta có P(Sunny | Yes) = 3/9 = 0,33; P(Sunny) = 5/14 = 0,36; và P(Yes) = 9/14 = 0,64.

Khi đó, P(Yes | Sunny) = 0,33 * 0,64 / 0,36 = 0,60; đây là mức xác suất cao hơn.

Naive Bayes sử dụng phương pháp tương tự để dự đoán xác suất của các lớp khác nhau dựa trên nhiều thuộc tính khác nhau. Thuật toán này chủ yếu được sử dụng trong phân loại văn bản và các bài toán có nhiều lớp.

Code cho mô hình phân loại Naive Bayes bằng Python:

# nhập các thư viện cần thiết
import pandas as pd
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score

# đọc tập dữ liệu huấn luyện và kiểm thử
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# kích thước của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu còn thiếu trong dữ liệu kiểm thử
# biến mục tiêu - Survived 

# tách biến độc lập và biến mục tiêu trong dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# tách biến độc lập và biến mục tiêu trong dữ liệu kiểm thử
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng mô hình Naive Bayes
Bạn cũng có thể thêm các tham số khác và thử nghiệm code tại đây
Một số tham số bao gồm: var_smoothing
Tài liệu về sklearn GaussianNB:

https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html

'''
model = GaussianNB()

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# dự đoán biến mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('Target on train data',predict_train) 

# Độ chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('accuracy_score on train dataset : ', accuracy_train)

# dự đoán biến mục tiêu trên tập dữ liệu kiểm thử
predict_test = model.predict(test_x)
print('Target on test data',predict_test) 

# Độ chính xác trên tập dữ liệu kiểm thử
accuracy_test = accuracy_score(test_y,predict_test)
print('accuracy_score on test dataset : ', accuracy_test)

Code R:

library(e1071)
x <- cbind(x_train,y_train)
# Huấn luyện mô hình
fit <-naiveBayes(y_train ~ ., data = x)
summary(fit)
# Dự đoán kết quả
predicted= predict(fit,x_test)

6. kNN (k-Nearest Neighbors)

KNN có thể được sử dụng cho cả bài toán phân loại và hồi quy. Tuy nhiên, nó được ứng dụng phổ biến hơn như một thuật toán phân loại trong Machine learning. k-Nearest Neighbors là một thuật toán đơn giản, trực quan; nó lưu trữ tất cả các trường hợp dữ liệu hiện có và phân loại những trường hợp mới dựa trên kết quả bỏ phiếu đa số từ k-Nearest Neighbors của chúng. Nhãn lớp được gán cho một trường hợp mới sẽ là nhãn xuất hiện nhiều nhất trong số k láng giềng gần nhất (được xác định thông qua hàm khoảng cách).

Các hàm khoảng cách được sử dụng trong KNN có thể là khoảng cách Euclidean, Manhattan, Minkowski hoặc Hamming. Ba loại đầu thường được dùng cho các biến liên tục, trong khi khoảng cách Hamming được áp dụng cho các biến phân loại. Nếu K = 1, trường hợp đó sẽ được gán vào cùng lớp với láng giềng gần nhất của nó. Tuy nhiên, việc chọn giá trị K phù hợp có thể khá khó khăn và thường phụ thuộc vào tập dữ liệu được sử dụng trong mô hình KNN.

Trong thực tế, KNN có thể được ví như việc tìm hiểu về một người dựa trên bạn bè thân thiết hoặc các mối quan hệ xã hội của họ. Nếu bạn không biết gì về một người, đặc điểm của những người xung quanh (láng giềng) có thể cung cấp những thông tin hữu ích.

Những lưu ý quan trọng đối với KNN

• KNN tiêu tốn nhiều tài nguyên tính toán do phải lưu trữ toàn bộ dữ liệu hiện có.
• Việc chuẩn hóa đặc trưng là rất cần thiết; các biến cần được chuẩn hóa vì những biến có phạm vi giá trị lớn hơn có thể làm sai lệch kết quả.
• Các bước tiền xử lý như loại bỏ dữ liệu ngoại lai và giảm nhiễu có ảnh hưởng đáng kể đến hiệu suất của mô hình KNN.

Code Python:

# Nhập các thư viện cần thiết
import pandas as pd
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# Hình dạng của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu bị thiếu trong dữ liệu kiểm tra
# Biến mục tiêu - Survived

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# Tách biến độc lập và biến mục tiêu trên dữ liệu kiểm tra
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng của mô hình K-Nearest Neighbor
Bạn cũng có thể thêm các tham số khác và kiểm tra code của mình tại đây
Một số tham số là: n_neighbors, leaf_size
Tài liệu về bộ phân loại K-Neighbors của sklearn:

https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html

'''
model = KNeighborsClassifier()

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# Số lượng neighbor được sử dụng để dự đoán mục tiêu
print('\nThe number of neighbors used to predict the target : ',model.n_neighbors)

# dự đoán mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('\nTarget on train data',predict_train) 

# Điểm chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('accuracy_score on train dataset : ', accuracy_train)

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra
predict_test = model.predict(test_x)
print('Target on test data',predict_test) 

# Điểm chính xác trên tập dữ liệu kiểm tra
accuracy_test = accuracy_score(test_y,predict_test)
print('accuracy_score on test dataset : ', accuracy_test)

Code R:

library(knn)
x <- cbind(x_train,y_train)
# Huấn luyện mô hình
fit <-knn(y_train ~ ., data = x,k=5)
summary(fit)
# Dự báo kết quả
predicted= predict(fit,x_test)

7. K-Means

Đây là một loại thuật toán học không giám sát dùng để giải quyết bài toán phân cụm. Quy trình của nó rất đơn giản và dễ hiểu: Phân loại một tập dữ liệu cho trước thành một số lượng cụm nhất định (giả sử là k cụm). Các điểm dữ liệu trong cùng một cụm có tính đồng nhất với nhau nhưng lại khác biệt so với những nhóm khác.

Bạn còn nhớ trò chơi đoán hình từ các vệt mực loang không? Thuật toán K-means cũng có phần tương tự như vậy. Bạn quan sát hình dạng và sự phân bố để xác định xem có bao nhiêu cụm hoặc nhóm dữ liệu khác nhau đang tồn tại!

Cách K-means hình thành các cụm:

1. K-means chọn ra k điểm làm tâm cụm (gọi là các centroid).
2. Mỗi điểm dữ liệu sẽ được xếp vào cụm có tâm gần nó nhất, tạo thành k cụm.
3. Xác định lại tâm của mỗi cụm dựa trên các thành viên hiện có trong cụm đó. Lúc này ta có các tâm cụm mới.
4. Khi đã có tâm cụm mới, lặp lại các bước 2 và 3. Xác định khoảng cách gần nhất từ ​​mỗi điểm dữ liệu đến các tâm cụm mới và gán chúng vào các cụm tương ứng. Quá trình này được lặp lại cho đến khi đạt trạng thái hội tụ, nghĩa là vị trí các tâm cụm không còn thay đổi nữa.

Cách xác định giá trị K:

Trong K-means, chúng ta có các cụm và mỗi cụm đều có tâm riêng. Tổng bình phương các khoảng cách giữa tâm cụm và các điểm dữ liệu trong cụm đó tạo thành giá trị tổng bình phương của cụm đó. Khi cộng tổng bình phương của tất cả các cụm lại, ta thu được tổng bình phương nội tại cho toàn bộ kết quả phân cụm.

Ta biết rằng khi số lượng cụm tăng lên, giá trị này sẽ giảm dần. Tuy nhiên, nếu vẽ biểu đồ kết quả, bạn sẽ thấy tổng bình phương khoảng cách giảm mạnh cho đến một giá trị k nhất định, sau đó tốc độ giảm sẽ chậm lại đáng kể. Tại điểm này, ta có thể xác định được số lượng cụm tối ưu.

Code Python:

# Nhập các thư viện cần thiết
import pandas as pd
from sklearn.cluster import KMeans

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# Hình dạng của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần chia dữ liệu huấn luyện thành các cụm khác nhau
# và dự đoán điểm dữ liệu cụ thể thuộc cụm nào.

'''
Tạo đối tượng của mô hình K-Means
Bạn cũng có thể thêm các tham số khác và kiểm tra mã của mình tại đây
Một số tham số là: n_clusters và max_iter
Tài liệu về sklearn KMeans:

https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html

'''

model = KMeans()

# Huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_data)

# Số lượng cụm
print('\nDefault number of Clusters : ',model.n_clusters)

# Dự đoán các cụm trên tập dữ liệu huấn luyện
predict_train = model.predict(train_data)
print('\nCLusters on train data',predict_train) 

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra
predict_test = model.predict(test_data)
print('Clusters on test data',predict_test) 

# Bây giờ, chúng ta sẽ huấn luyện một mô hình với n_cluster = 3
model_n3 = KMeans(n_clusters=3)

# Huấn luyện mô hình với dữ liệu huấn luyện
model_n3.fit(train_data)

# Số lượng cụm
print('\nNumber of Clusters : ',model_n3.n_clusters)

# Dự đoán các cụm trên tập dữ liệu huấn luyện
predict_train_3 = model_n3.predict(train_data)
print('\nCLusters on train data',predict_train_3) 

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra
predict_test_3 = model_n3.predict(test_data)
print('Clusters on test data',predict_test_3) 

Code R:

library(cluster)
fit <- kmeans(X, 3) # 5 cluster solution

8. Random Forest

Random Forest là thuật ngữ (đã được đăng ký nhãn hiệu) chỉ một phương pháp học kết hợp dựa trên các cây quyết định. Trong Random Forest, chúng ta có một tập hợp các cây quyết định (còn được gọi là Forest). Để phân loại một đối tượng mới dựa trên các thuộc tính, mỗi cây sẽ đưa ra một kết quả phân loại; ta có thể coi như cây đó "bỏ phiếu" cho lớp (class) tương ứng. Kết quả cuối cùng của cả khu rừng sẽ là lớp nhận được nhiều phiếu bầu nhất (tính trên tổng số cây trong rừng).

Quá trình xây dựng (hay "trồng") mỗi cây diễn ra như sau:

1. Nếu tập huấn luyện có N mẫu dữ liệu, một mẫu con gồm N phần tử sẽ được chọn ngẫu nhiên theo phương pháp lấy mẫu có hoàn lại. Mẫu con này sẽ đóng vai trò là tập dữ liệu để xây dựng cây.
2. Nếu có M biến đầu vào, ta xác định một số m sao cho m << M. Tại mỗi nút của cây, m biến sẽ được chọn ngẫu nhiên từ M biến ban đầu, và phương án phân chia tối ưu dựa trên m biến này sẽ được sử dụng để tách nút. Giá trị m được giữ cố định trong suốt quá trình xây dựng rừng.
3. Mỗi cây được phát triển đến mức tối đa có thể. Không thực hiện bước cắt tỉa (pruning) cây.

Code Python:

# Nhập các thư viện cần thiết
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# Xem 3 hàng đầu của tập dữ liệu
print(train_data.head(3))

# Hình dạng của tập dữ liệu
print('\nShape of training data :',train_data.shape)
print('\nShape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu bị thiếu trong dữ liệu kiểm tra
# Biến mục tiêu - Survived

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# Tách biến độc lập và biến mục tiêu trên dữ liệu kiểm thử
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''

Tạo đối tượng của mô hìnhRandom Forest
Bạn cũng có thể thêm các tham số khác và kiểm tra mã của mình tại đây
Một số tham số là: n_estimators và max_depth
Tài liệu về sklearn RandomForestClassifier:

https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html

'''

model = RandomForestClassifier()

# Huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# Số lượng cây được sử dụng
print('Number of Trees used : ', model.n_estimators)

# Dự đoán mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('\nTarget on train data',predict_train) 

# Điểm chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('\naccuracy_score on train dataset : ', accuracy_train)

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra
predict_test = model.predict(test_x)
print('\nTarget on test data',predict_test) 

# Điểm chính xác trên tập dữ liệu kiểm tra
accuracy_test = accuracy_score(test_y,predict_test)
print('\naccuracy_score on test dataset : ', accuracy_test)

Code R:

library(randomForest)
x <- cbind(x_train,y_train)
# Huấn luyện mô hình
fit <- randomForest(Species ~ ., x, ntree=500)
summary(fit)
# Dự đoán kết quả
predicted <- predict(fit, x_test)

9. Các thuật toán giảm chiều dữ liệu

Trong khoảng 4-5 năm trở lại đây, lượng dữ liệu được thu thập đã tăng theo cấp số nhân ở mọi giai đoạn có thể. Các doanh nghiệp, cơ quan chính phủ và tổ chức nghiên cứu không chỉ tìm ra các nguồn dữ liệu mới mà còn thu thập dữ liệu với độ chi tiết rất cao.

Ví dụ, các công ty thương mại điện tử thu thập rất nhiều thông tin chi tiết về khách hàng - như thông tin nhân khẩu học, lịch sử duyệt web, sở thích, lịch sử mua hàng, phản hồi, v.v... - để mang lại sự chăm sóc cá nhân hóa vượt xa cả người chủ cửa hàng tạp hóa gần nhà bạn.

Đối với các nhà khoa học dữ liệu, dữ liệu mà chúng ta tiếp nhận thường bao gồm rất nhiều đặc trưng. Điều này nghe có vẻ thuận lợi cho việc xây dựng một mô hình mạnh mẽ, nhưng lại đi kèm một thách thức: Làm thế nào để xác định được các biến thực sự quan trọng trong số hàng nghìn biến đó? Trong những trường hợp như vậy, các thuật toán giảm chiều dữ liệu sẽ phát huy tác dụng, bên cạnh các thuật toán khác như Decision Tree, Random Forest, PCA (Phân tích thành phần chính), Factor Analysis, cũng như các phương pháp dựa trên ma trận tương quan, tỷ lệ giá trị thiếu, v.v...

Code Python:

# Nhập các thư viện cần thiết
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train.csv')
test_data = pd.read_csv('test.csv')

# Xem 3 hàng đầu của tập dữ liệu
print(train_data.head(3))

# Hình dạng của tập dữ liệu
print('\nShape of training data :',train_data.shape)
print('\nShape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu bị thiếu trong dữ liệu kiểm tra
# Biến mục tiêu - Survived

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện
# Biến mục tiêu - Item_Outlet_Sales
train_x = train_data.drop(columns=['Item_Outlet_Sales'],axis=1)
train_y = train_data['Item_Outlet_Sales']

# Tách biến độc lập và biến mục tiêu trên dữ liệu kiểm thử
test_x = test_data.drop(columns=['Item_Outlet_Sales'],axis=1)
test_y = test_data['Item_Outlet_Sales']

print('\nTraining model with {} dimensions.'.format(train_x.shape[1]))

# Tạo đối tượng của mô hình
model = LinearRegression()

# Huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# Dự đoán mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)

# Điểm chính xác trên tập dữ liệu huấn luyện
rmse_train = mean_squared_error(train_y,predict_train)**(0.5)
print('\nRMSE on train dataset : ', rmse_train)

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra
predict_test = model.predict(test_x)

# Điểm chính xác trên tập dữ liệu kiểm tra
rmse_test = mean_squared_error(test_y,predict_test)**(0.5)
print('\nRMSE on test dataset : ', rmse_test)

# Tạo đối tượng của mô hình PCA (Principal Component Analysis)

# Giảm kích thước dữ liệu xuống 12
'''
Bạn cũng có thể thêm các tham số khác và kiểm tra mã của mình tại đây
Một số tham số là: svd_solver, iterated_power
Tài liệu về PCA của sklearn:

https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html
'''
model_pca = PCA(n_components=12)

new_train = model_pca.fit_transform(train_x)
new_test = model_pca.fit_transform(test_x)

print('\nTraining model with {} dimensions.'.format(new_train.shape[1]))

# Tạo đối tượng của mô hình
model_new = LinearRegression()

# Huấn luyện mô hình với dữ liệu huấn luyện
model_new.fit(new_train,train_y)

# Dự đoán mục tiêu trên tập dữ liệu huấn luyện mới
predict_train_pca = model_new.predict(new_train)

# Điểm chính xác trên tập dữ liệu huấn luyện
rmse_train_pca = mean_squared_error(train_y,predict_train_pca)**(0.5)
print('\nRMSE on new train dataset : ', rmse_train_pca)

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra mới
predict_test_pca = model_new.predict(new_test)

# Điểm chính xác trên tập dữ liệu kiểm tra tập dữ liệu
rmse_test_pca = mean_squared_error(test_y,predict_test_pca)**(0.5)
print('\nRMSE on new test dataset : ', rmse_test_pca)

Code R:

library(stats)
pca <- princomp(train, cor = TRUE)
train_reduced  <- predict(pca,train)
test_reduced  <- predict(pca,test)

10. Các thuật toán Gradient Boosting

Bây giờ, hãy cùng xem xét 4 thuật toán gradient boosting phổ biến nhất.

GBM

GBM là một thuật toán boosting được sử dụng khi xử lý lượng dữ liệu lớn để đưa ra dự đoán với độ chính xác cao. Boosting thực chất là một phương pháp kết hợp các thuật toán Machine Learning, trong đó các dự đoán từ nhiều mô hình cơ sở được gộp lại nhằm cải thiện độ ổn định và hiệu quả so với việc chỉ sử dụng một mô hình duy nhất. Phương pháp này kết hợp nhiều mô hình dự đoán yếu hoặc trung bình để tạo ra một mô hình dự đoán mạnh. Các thuật toán boosting này luôn đạt hiệu quả cao trong các cuộc thi khoa học dữ liệu như Kaggle, AV Hackathon và CrowdAnalytix.

Code Python:

# Nhập các thư viện cần thiết
import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# Hình dạng của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu bị thiếu trong dữ liệu kiểm tra
# Biến mục tiêu - Survived

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# Tách biến độc lập và biến mục tiêu trên dữ liệu kiểm tra
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng của mô hình GradientBoosting Classifier
Bạn cũng có thể thêm các tham số khác và kiểm tra code của mình tại đây
Một số tham số là: learning_rate, n_estimators
Tài liệu về GradientBoosting Classifier của sklearn:

https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html
'''
model = GradientBoostingClassifier(n_estimators=100,max_depth=5)

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# dự đoán mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('\nTarget on train data',predict_train) 

# Điểm chính xác trên tập huấn luyện Tập dữ liệu
accuracy_train = accuracy_score(train_y,predict_train)
print('\naccuracy_score on train dataset : ', accuracy_train)

# Dự đoán mục tiêu trên tập dữ liệu kiểm tra
predict_test = model.predict(test_x)
print('\nTarget on test data',predict_test) 

# Điểm chính xác trên tập dữ liệu kiểm tra
accuracy_test = accuracy_score(test_y,predict_test)
print('\naccuracy_score on test dataset : ', accuracy_test)

Code R:

library(caret)
x <- cbind(x_train,y_train)
# Fitting model
fitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)
fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)
predicted= predict(fit,x_test,type= "prob")[,2]

GradientBoostingClassifier và Random Forest là hai bộ phân loại dựa trên cây (tree-based classifier) ​​sử dụng kỹ thuật boosting khác nhau, và người ta thường thắc mắc về sự khác biệt giữa hai thuật toán này.

XGBoost

Một thuật toán gradient boosting kinh điển khác, vốn được xem là yếu tố quyết định thắng bại trong nhiều cuộc thi trên Kaggle, chính là XGBoost. Thuật toán này sở hữu khả năng dự báo cực kỳ mạnh mẽ, trở thành lựa chọn tối ưu để đạt độ chính xác cao. Nhờ kết hợp cả mô hình tuyến tính và thuật toán học dựa trên cây, XGBoost có tốc độ xử lý nhanh hơn gần 10 lần so với các kỹ thuật gradient boosting hiện có.

Một trong những điểm thú vị nhất của XGBoost là nó còn được gọi là kỹ thuật boosting có áp dụng cơ chế điều chuẩn (regularization). Cơ chế này giúp giảm thiểu tình trạng quá khớp (overfitting) của mô hình; đồng thời, thuật toán hỗ trợ đa dạng các ngôn ngữ lập trình như Scala, Java, R, Python, Julia và C++.

XGBoost hỗ trợ nhiều hàm mục tiêu khác nhau, bao gồm hồi quy (regression), phân loại (classification) và xếp hạng (ranking). Nó hỗ trợ quy trình huấn luyện phân tán trên nhiều máy chủ, bao gồm các nền tảng như GCE, AWS, Azure và cụm Yarn. Ngoài ra, XGBoost có thể tích hợp với Spark, Flink và các hệ thống luồng dữ liệu đám mây khác, đồng thời tích hợp sẵn tính năng kiểm chứng chéo (cross-validation) trong mỗi vòng lặp của quá trình boosting.

Code Python:

# Nhập các thư viện cần thiết
import pandas as pd
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score

# Đọc tập dữ liệu huấn luyện và kiểm tra
train_data = pd.read_csv('train-data.csv')
test_data = pd.read_csv('test-data.csv')

# Hình dạng của tập dữ liệu
print('Shape of training data :',train_data.shape)
print('Shape of testing data :',test_data.shape)

# Bây giờ, chúng ta cần dự đoán biến mục tiêu bị thiếu trong dữ liệu kiểm tra
# Biến mục tiêu - Survived

# Tách biến độc lập và biến mục tiêu trên dữ liệu huấn luyện
train_x = train_data.drop(columns=['Survived'],axis=1)
train_y = train_data['Survived']

# Tách biến độc lập và biến mục tiêu trên dữ liệu kiểm tra
test_x = test_data.drop(columns=['Survived'],axis=1)
test_y = test_data['Survived']

'''
Tạo đối tượng của mô hình XGBoost
Bạn cũng có thể thêm các tham số khác và kiểm tra code của mình tại đây
Một số tham số là: max_depth và n_estimators
Tài liệu về xgboost:

https://xgboost.readthedocs.io/en/latest/
'''
model = XGBClassifier()

# huấn luyện mô hình với dữ liệu huấn luyện
model.fit(train_x,train_y)

# dự đoán mục tiêu trên tập dữ liệu huấn luyện
predict_train = model.predict(train_x)
print('\nTarget on train data',predict_train) 

# Điểm chính xác trên tập dữ liệu huấn luyện
accuracy_train = accuracy_score(train_y,predict_train)
print('\naccuracy_score on train dataset : ', accuracy_train)

# dự đoán Mục tiêu trên tập dữ liệu kiểm thử
predict_test = model.predict(test_x)
print('\nTarget on test data',predict_test) 

# Điểm chính xác trên tập dữ liệu kiểm thử
accuracy_test = accuracy_score(test_y,predict_test)
print('\naccuracy_score on test dataset : ', accuracy_test)

Code R:

require(caret)

x <- cbind(x_train,y_train)

# Fitting model

TrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)

model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)

OR 

model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)

predicted <- predict(model, x_test)

LightGBM

LightGBM là một framework gradient boosting sử dụng các thuật toán học dựa trên dạng cây. Nó được thiết kế để hoạt động theo mô hình phân tán và đạt hiệu suất cao với các ưu điểm sau:

• Tốc độ huấn luyện nhanh hơn và hiệu quả hơn
• Mức tiêu thụ bộ nhớ thấp hơn
• Độ chính xác cao hơn
• Hỗ trợ huấn luyện song song và sử dụng GPU
• Có khả năng xử lý dữ liệu quy mô lớn

Đây là một framework gradient boosting nhanh, hiệu suất cao dựa trên các thuật toán cây quyết định, được sử dụng cho các tác vụ xếp hạng, phân loại và nhiều nhiệm vụ Machine Learning khác. Nó được phát triển trong framework Distributed Machine Learning Toolkit Project của Microsoft.

Do LightGBM dựa trên các thuật toán cây quyết định, nó thực hiện phân tách cây theo leaf-wise để đạt kết quả tối ưu nhất; trong khi đó, các thuật toán boosting khác thường phân tách cây theo chiều sâu hoặc theo từng tầng. Vì vậy, khi mở rộng cùng một nút lá, thuật toán leaf-wise có thể giúp giảm thiểu hàm mất mát nhiều hơn so với thuật toán level-wise, từ đó mang lại độ chính xác vượt trội – điều mà hiếm thuật toán boosting hiện có nào đạt được.

Ngoài ra, nó còn có tốc độ cực kỳ nhanh, đúng như tên gọi "Light" (nhẹ/nhanh) của mình.

Code Python:

data = np.random.rand(500, 10) # 500 mẫu dữ liệu, mỗi mẫu có 10 đặc trưng
label = np.random.randint(2, size=500) # nhãn nhị phân

train_data = lgb.Dataset(data, label=label)
test_data = train_data.create_valid('test.svm')

param = {'num_leaves':31, 'num_trees':100, 'objective':'binary'}
param['metric'] = 'auc'

num_round = 10
bst = lgb.train(param, train_data, num_round, valid_sets=[test_data])

bst.save_model('model.txt')

# 7 mẫu dữ liệu, mỗi mẫu có 10 đặc trưng
data = np.random.rand(7, 10)
ypred = bst.predict(data)

Code R:

library(RLightGBM)
data(example.binary)
# Các tham số

num_iterations <- 100
config <- list(objective = "binary",  metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)

# Tạo đối tượng xử lý dữ liệu (data handle) và mô hình (booster)
handle.data <- lgbm.data.create(x)

lgbm.data.setField(handle.data, "label", y)

handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))

# Huấn luyện trong num_iterations vòng lặp và đánh giá sau mỗi 5 bước

lgbm.booster.train(handle.booster, num_iterations, 5)

# Dự đoán
pred <- lgbm.booster.predict(handle.booster, x.test)

# Kiểm tra độ chính xác
sum(y.test == (y.pred > 0.5)) / length(y.test)

# Lưu mô hình (có thể load lại bằng lgbm.booster.load(filename))
lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")

Nếu bạn đã quen thuộc với gói Caret trong R, thì đây là một cách khác để triển khai LightGBM.

require(caret)
require(RLightGBM)
data(iris)

model <-caretModel.LGBM()

fit <- train(Species ~ ., data = iris, method=model, verbosity = 0)
print(fit)
y.pred <- predict(fit, iris[,1:4])

library(Matrix)
model.sparse <- caretModel.LGBM.sparse()

#Generate a sparse matrix
mat <- Matrix(as.matrix(iris[,1:4]), sparse = T)
fit <- train(data.frame(idx = 1:nrow(iris)), iris$Species, method = model.sparse, matrix = mat, verbosity = 0)
print(fit)

CatBoost

CatBoost là một thuật toán Machine Learning mã nguồn mở do Yandex phát triển. Nó có khả năng tích hợp dễ dàng với các framework Deep Learning như TensorFlow của Google và Core ML của Apple. Điểm ưu việt của CatBoost là nó không đòi hỏi quy trình huấn luyện dữ liệu phức tạp hay tốn kém như các mô hình Machine Learning khác và có thể hoạt động hiệu quả với nhiều định dạng dữ liệu đa dạng mà vẫn duy trì được hiệu năng mạnh mẽ.

CatBoost có thể tự động xử lý các biến phân loại mà không gặp lỗi chuyển đổi kiểu dữ liệu; điều này giúp bạn tập trung vào việc tinh chỉnh mô hình thay vì phải tốn thời gian khắc phục những lỗi vặt. Tuy nhiên, hãy đảm bảo bạn đã xử lý tốt dữ liệu bị thiếu trước khi tiến hành triển khai.

Code Python:

import pandas as pd
import numpy as np

from catboost import CatBoostRegressor

#Đọc các tập dữ liệu huấn luyện và kiểm thử
train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")

#Điền các giá trị thiếu cho cả tập huấn luyện và kiểm thử
train.fillna(-999, inplace=True)
test.fillna(-999,inplace=True)

#Tạo tập huấn luyện để xây dựng mô hình và tập kiểm định để kiểm tra hiệu suất mô hình
X = train.drop(['Item_Outlet_Sales'], axis=1)
y = train.Item_Outlet_Sales

from sklearn.model_selection import train_test_split

X_train, X_validation, y_train, y_validation = train_test_split(X, y, train_size=0.7, random_state=1234)

categorical_features_indices = np.where(X.dtypes != np.float)[0]

#Nhập thư viện và xây dựng mô hình
from catboost import CatBoostRegressormodel=CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')

model.fit(X_train, y_train,cat_features=categorical_features_indices,eval_set=(X_validation, y_validation),plot=True)

submission = pd.DataFrame()

submission['Item_Identifier'] = test['Item_Identifier']
submission['Outlet_Identifier'] = test['Outlet_Identifier']
submission['Item_Outlet_Sales'] = model.predict(test)

Code R:

set.seed(1)

require(titanic)

require(caret)

require(catboost)

tt <- titanic::titanic_train[complete.cases(titanic::titanic_train),]

data <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)

drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")

x <- data[,!(names(data) %in% drop_columns)]y <- data[,c("Survived")]

fit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)

grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3,            rsm = 0.95, border_count = 64)

report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)

print(report)

importance <- varImp(report, scale = FALSE)

print(importance)