Nội dung bài viết
© 2025 AI VIET NAM. All rights reserved.
Tác giả: Nhóm ra đề (AIO2024)
Keywords: kiểm tra năng lực machine learning, học machine learning online, khóa học ai
Trong phần này, chúng ta sẽ xử lý một tập hợp các câu đánh giá phim và chuyển đổi nó thành định dạng vector bằng CountVectorizer. Sự chuyển đổi này rất cần thiết để chuẩn bị dữ liệu văn bản cho các mô hình Machine Learning. Sau đây là quy trình từng bước chuyển đổi:
Bộ dữ liệu text-corpus
Chúng ta bắt đầu với một bộ data nhỏ các câu đánh giá phim, mà chúng ta gọi là corpus. Corpus chứa 6 câu đánh giá khác nhau:
import sklearn from sklearn.neighbors import KNeighborsClassifier from sklearn.feature_extraction.text import CountVectorizer import numpy as np import pandas as pd corpus = ["ai is powerful and useful", "smart and adaptive system", "very smart and useful", "learning AI is very hard", "ai can be biased", "biased and flawed"]
| Các văn bản | Nhãn |
|---|---|
| ai is powerful and useful | 1 |
| smart and adaptive system | 1 |
| very smart and useful | 1 |
| learning AI is very hard | 0 |
| ai can be biased | 0 |
| biased and flawed | 0 |
Tạo đặc trưng
corpus = ["ai is powerful and useful", "smart and adaptive system", "very smart and useful", "learning AI is very hard", "ai can be biased", "biased and flawed"]
Vectorization
Chúng ta sử dụng CountVectorizer để chuyển đổi dữ liệu văn bản thành một ma trận, trong đó mỗi cột tương ứng với một từ trong bộ từ vựng và mỗi hàng đại diện cho một văn bản. Mỗi giá trị trong ma trận thể hiện số lần từ đó xuất hiện trong văn bản tương ứng.
Ví dụ: Câu đầu tiên là: "ai is powerful and useful" được thể hiện bằng vector [0 1 1 0 0 0 0 0 1 0 1 0 0 1 0] tức là đối với câu thứ nhất, có 1 từ ở index 1, 2, 8, 10, 13 trong bộ từ vựng vocab.
vectorizer = CountVectorizer() X = vectorizer.fit_transform(corpus) y_data = np.array([1, 1, 1, 0, 0, 0])
Biết bộ từ điển được sắp xếp theo thứ tự như sau:
| adaptive | ai | and | be | biased | can | flawed | hard | is | learning | powerful | smart | system | useful | very |
|---|
Vector đặc trưng khi nhận đầu vào là "ai is a smart system" là?
new_sentence = ["ai is a smart system"] new_sentence_vector = vectorizer.transform(new_sentence).toarray() print(new_sentence_vector)
Hãy tính khoảng cách Euclid giữa câu "ai is a smart system" (bạn vừa thực hiện ở câu trước) và câu "learning AI is very hard" trong tập văn bản đã được biến đổi thành ma trận đặc trưng. Khoảng cách Euclid giữa hai câu này bằng ? (kết quả làm tròn đến 2 chữ số sau dấu phẩy).
def euclid_distance(x1, x2): return np.sqrt(np.sum((x1 - x2) ** 2)) distance = euclid_distance(X[3].toarray(), new_sentence_vector) print(distance)
Top 3 câu có khoảng cách gần nhất với câu "ai is a smart system" là ?
distances = [] for i in range(X.shape[0]): distance = euclid_distance(new_sentence_vector, X[i].toarray()) distances.append((distance, i)) distances.sort() top_3 = distances[:3] for dist, idx in top_3: print(f"Index: {idx} - {corpus[idx]}; Distance: {dist}")
Tập dữ liệu này chứa thông tin về các đặc trưng liên quan đến khối u ung thư vú, cùng với chẩn đoán của chúng. (Đây là dữ liệu đã được cắt vớt và chuẩn hóa)
Mô Tả Dữ Liệu
| Chỉ số | perimeter_mean | area_mean | compactness_mean | diagnosis |
|---|---|---|---|---|
| 0 | 0.29 | 0.18 | 0.12 | B |
| 1 | 0.11 | 0.06 | 0.17 | B |
| 2 | 0.34 | 0.21 | 0.20 | B |
| 3 | 0.26 | 0.15 | 0.09 | B |
| 4 | 0.22 | 0.09 | 0.20 | B |
| 5 | 0.58 | 0.42 | 0.47 | M |
| 6 | 0.56 | 0.37 | 0.77 | M |
| 7 | 0.48 | 0.38 | 0.28 | M |
| 8 | 0.63 | 0.49 | 0.39 | M |
| 9 | 0.54 | 0.42 | 0.43 | M |
Các Đặc Trưng
!gdown 1dLF8lffQLgBO5Thu__Lk5Pbw57fTkncc df = pd.read_csv('/content/final_dataset.csv') X_train = df[["perimeter_mean", "area_mean", "compactness_mean"]].values.tolist() labels = df['diagnosis'].values.tolist()
Đoạn mã bên dưới chuyển đổi lớp 'B' và lớp 'M' lần lượt thành?
y_train = [] for label in labels: if label == 'B': y_train.append(0) else: y_train.append(1) print(type(y_train)) y_train
Kết quả của mã nguồn bên dưới được hiểu như thế nào?
train_data = zip(X_train, y_train) train_data = list(train_data) train_data
================ Output ================ [ ([0.29, 0.18, 0.12], 0), ([0.11, 0.06, 0.17], 0), ([0.34, 0.21, 0.2], 0), ([0.26, 0.15, 0.09], 0), ([0.22, 0.09, 0.2], 0), ([0.58, 0.42, 0.47], 1), ([0.56, 0.37, 0.77], 1), ([0.48, 0.38, 0.28], 1), ([0.63, 0.49, 0.39], 1), ([0.54, 0.42, 0.43], 1) ] ====================================
Cho input x = [0.25, 0.25, 0.25]. Tính khoảng cách Manhattan từ x tới 3 điểm dữ liệu đầu tiên (3 dòng đầu trong bộ dữ liệu train) là?
def manhattan_distance(x1, x2): return np.sum(np.abs(x1 - x2)) x = np.array([0.25, 0.25, 0.25]) manhattan_distances = [] for i in range(3): manhattan_distances.append(manhattan_distance(x, np.array(train_data[i][0]))) for d in manhattan_distances: print(np.round(d, 2), end=' ')
Sắp xếp theo thứ tự tăng dần khoảng cách, nếu K=7, có tổng cộng bao nhiêu Class 0 và 1?
x = np.array([0.25, 0.25, 0.25]) manhattan_distances = [] for i in range(len(train_data)): manhattan_distances.append((manhattan_distance(x, np.array(train_data[i][0])), i)) manhattan_distances.sort() top_7 = manhattan_distances[:7] for dist, idx in sorted(top_7): print(f"Index: {idx} - {train_data[idx][0]}; Distance: {np.round(dist, 2)}; label: {train_data[idx][1]}")
Trong phần này, chúng ta sẽ xử lý một tập hợp các câu đánh giá phim và chuyển đổi nó thành định dạng vector bằng CountVectorizer. Sự chuyển đổi này rất cần thiết để chuẩn bị dữ liệu văn bản cho các mô hình Machine Learning. Sau đây là quy trình từng bước chuyển đổi:
Chúng ta bắt đầu với một bộ data nhỏ các câu đánh giá phim, mà chúng ta gọi là corpus. Corpus chứa 6 câu đánh giá khác nhau:
from sklearn.feature_extraction.text import CountVectorizer import numpy as np corpus = ["ai is powerful and useful", "smart and adaptive system", "very smart and useful", "learning AI is very hard", "ai can be biased", "biased and flawed"] vectorizer = CountVectorizer()
Chúng ta sử dụng CountVectorizer để chuyển đổi dữ liệu văn bản thành một ma trận, trong đó mỗi cột tương ứng với một từ trong bộ từ vựng và mỗi hàng đại diện cho một văn bản. Mỗi giá trị trong ma trận thể hiện số lần từ đó xuất hiện trong văn bản tương ứng. Ví dụ: Câu đầu tiên là: "ai is powerful and useful" được thể hiện bằng vector [0 1 1 0 0 0 0 0 1 0 1 0 0 1 0], tức là đối với câu thứ nhất, có 1 từ ở index 1, 2, 8, 10, 13 trong bộ từ vựng (vocab).
X = vectorizer.fit_transform(corpus) print("================== Output =================") display(f"Bộ từ vựng xây dựng từ corpus: {dict(sorted(vectorizer.vocabulary_.items()))}") print("===========================================")
| Word | Index |
|---|---|
| adaptive | 0 |
| ai | 1 |
| and | 2 |
| be | 3 |
| biased | 4 |
| can | 5 |
| flawed | 6 |
| hard | 7 |
| is | 8 |
| learning | 9 |
| powerful | 10 |
| smart | 11 |
| system | 12 |
| useful | 13 |
| very | 14 |
X = X.toarray() print("================== Output =================") print("Vector đại diện cho bộ corpus sau khi vectorization:") print(X) print("===========================================")
[ [0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1], [0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1], [0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0] ]
Cho tâm cụm là 2 tâm cụm ngẫu nhiên:
Khoảng cách Euclidean của C1 tới các sample 1, 2, 3, 5 (làm tròn tới 3 chữ số thập phân) lần lượt là?
def euclidean_distance(x1, x2): return np.sqrt(np.sum(np.power(x1 - x2, 2))) indices = [1, 2, 3, 5] distances_C1 = [(euclidean_distance(C1, X[i]), i) for i in indices] for dist, idx in distances_C1: print(f'Distance: {np.round(dist, 3)}; index: {idx}')
Khoảng cách Euclidean của C2 tới các sample 1, 2, 3, 5 (làm tròn tới 3 chữ số thập phân) lần lượt là?
distances_C2 = [(euclidean_distance(C2, X[i]), i) for i in indices] for dist, idx in distances_C2: print(f'Distance: {np.round(dist, 3)}; index: {idx}')
Xác định các điểm dữ liệu thuộc cụm 1 và cụm 2: Vector biểu diễn phân cụm của bộ data X là?
C1 = X[0] C2 = X[4] indices = [1, 2, 3, 5] distances_C1 = [euclidean_distance(C1, X[i]) for i in indices] distances_C2 = [euclidean_distance(C2, X[i]) for i in indices] labels = [] for d1, d2 in zip(distances_C1, distances_C2): labels.append('C1' if d1 < d2 else 'C2') labels.insert(0, 'C1') labels.insert(4, 'C2') print(labels)
Cập nhật tâm cụm: Cập nhật tọa độ của tâm cụm thứ 1 và thứ 2 dựa trên các câu được gán cho mỗi tâm cụm (Chọn đáp án gần bằng, làm tròn 1 chữ số thập phân):
A.
B.
C.
D.
new_centroids_C1 = np.mean(X[0:4], axis=0) new_centroids_C2 = np.mean(X[4:7], axis=0) print(new_centroids_C1) print(new_centroids_C2)
Xác định các điểm dữ liệu thuộc cụm 1 và cụm 2 sau khi cập nhật tâm cụm (Theo vector biểu diễn)
labels = [] for d1, d2 in zip(distances_C1, distances_C2): labels.append('C1' if d1 < d2 else 'C2') labels.insert(0, 'C1') labels.insert(4, 'C2') print(labels)
Tập dữ liệu này chứa thông tin về các đặc trưng liên quan đến khối u ung thư vú, cùng với chẩn đoán của chúng. (Đây là dữ liệu đã được cắt vớt và chuẩn hóa)
| Chỉ số | perimeter_mean | area_mean | compactness_mean | diagnosis |
|---|---|---|---|---|
| 0 | 0.29 | 0.18 | 0.12 | B |
| 1 | 0.11 | 0.06 | 0.17 | B |
| 2 | 0.34 | 0.21 | 0.20 | B |
| 3 | 0.26 | 0.15 | 0.09 | B |
| 4 | 0.22 | 0.09 | 0.20 | B |
| 5 | 0.58 | 0.42 | 0.47 | M |
| 6 | 0.56 | 0.37 | 0.77 | M |
| 7 | 0.48 | 0.38 | 0.28 | M |
| 8 | 0.63 | 0.49 | 0.39 | M |
| 9 | 0.54 | 0.42 | 0.43 | M |
C1: [0.34, 0.21, 0.2] (Index 2)
C2: [0.63, 0.49, 0.39] (Index 8)
Tính tổng khoảng cách của các điểm dữ liệu tới tâm cụm thứ nhất C1: [0.34, 0.21, 0.2]
(Đáp án làm tròn tới 2 chữ số thập phân)
sum_dist = 0 for x in train_data: sum_dist += euclidean_distance(np.array(x), centroid_values[0]) print(np.round(sum_dist, 2))
Tính tổng khoảng cách của các điểm dữ liệu tới tâm cụm thứ hai C2: [0.63, 0.49, 0.39]
(Đáp án làm tròn tới 2 chữ số thập phân)
sum_dist = 0 for x in train_data: sum_dist += euclidean_distance(np.array(x), centroid_values[1]) print(np.round(sum_dist, 2))
Xác định các điểm dữ liệu thuộc cụm 1 và cụm 2: Vector biểu diễn phân cụm của bộ data_train là?
labels = [] distances_C1 = [] distances_C2 = [] for x in train_data: distances_C1.append(euclidean_distance(np.array(x), centroid_values[0])) distances_C2.append(euclidean_distance(np.array(x), centroid_values[1])) for i in range(len(distances_C1)): labels.append('0' if distances_C1[i] < distances_C2[i] else '1') print(labels)
Cập nhật tọa độ của tâm cụm thứ 1 và thứ 2 dựa trên các điểm dữ liệu được gán cho mỗi tâm cụm trước đó
(Chọn đáp án gần bằng, làm tròn 2 chữ số thập phân)
A. C1: [0.56, 0.42, 0.47], C2: [0.24, 0.14, 0.16]
B. C1: [0.24, 0.18, 0.17], C2: [0.56, 0.44, 0.37]
C. C1: [0.56, 0.42, 0.27], C2: [0.28, 0.19, 0.16]
D. C1: [0.24, 0.14, 0.16] C2: [0.56, 0.42, 0.47]
new_centroids_C1 = np.mean(train_data[0:5], axis=0) new_centroids_C2 = np.mean(train_data[5:10], axis=0) print(np.round(new_centroids_C1, 2)) print(np.round(new_centroids_C2, 2))
Xác định các điểm dữ liệu thuộc cụm 1 và cụm 2 sau khi cập nhật tâm cụm (Theo vector biểu diễn)
labels = [] distances_C1 = [] distances_C2 = [] for x in train_data: distances_C1.append(euclidean_distance(np.array(x), new_centroids_C1)) distances_C2.append(euclidean_distance(np.array(x), new_centroids_C2)) for i in range(len(distances_C1)): labels.append('0' if distances_C1[i] < distances_C2[i] else '1') print(labels)
Tập dữ liệu này chứa thông tin về các đặc trưng thời tiết liên quan đến quyết định chơi tennis (PlayTennis).
Bộ dữ liệu gồm 4 thuộc tính:
| Outlook | Temperature | Humidity | Wind | PlayTennis |
|---|---|---|---|---|
| Sunny | Cool | High | Weak | Yes |
| Sunny | Cool | High | Strong | No |
| Overcast | Mild | High | Weak | Yes |
| Rain | Hot | Normal | Weak | Yes |
| Rain | Hot | Normal | Strong | No |
| Overcast | Hot | Normal | Strong | Yes |
| Sunny | Mild | High | Weak | No |
| Sunny | Cool | Normal | Weak | Yes |
| Sunny | Hot | High | Weak | No |
| Rain | Cool | Normal | Weak | Yes |
| Outlook | Temperature | Humidity | Wind | PlayTennis |
|---|---|---|---|---|
| Sunny | Cool | Normal | Strong | Yes |
| Overcast | Hot | High | Strong | Yes |
| Overcast | Mild | Normal | Weak | Yes |
| Rain | Cool | High | Strong | No |
Entropy của tập dữ liệu ban đầu là bao nhiêu (làm tròn đến 4 chữ số thập phân)?
Tập dữ liệu có 6 nhãn Yes, 4 nhãn No → Cross Entropy:
Với tập huấn luyện ban đầu, Information Gain của thuộc tính Temperature là bao nhiêu (làm tròn đến 4 chữ số thập phân)?
Các nhóm:
Thuộc tính nào được chọn chia nhánh đầu tiên?
Tính IG:
→ Outlook là root.
Cây quyết định hoàn chỉnh sẽ có bao nhiêu lá?
Outlook là nhánh root.
Tìm các nhánh tiếp theo của cây:
Kết luận: Temp có IG lớn nhất → Temp là nhánh tiếp theo với thuộc tính Sunny.
Kết luận: Wind có IG lớn nhất → Wind là nhánh tiếp theo với thuộc tính Rain.
Humidity | Cool:
Wind | Cool
Kết luận: Wind có IG lớn nhất → Wind là nhánh tiếp theo với thuộc tính Cool của Temperature.
Chi tiết các nhánh lá:
Dùng cây quyết định đã xây dựng, dự đoán kết quả của dòng cuối cùng trong tập kiểm tra.
Dùng cây quyết định đã xây dựng, dự đoán kết quả cho mẫu dữ liệu sau: Outlook = Overcast, Wind = Weak.
A. Yes
B. No
C. Thiếu giá trị của thuộc tính Temperature nên không dự đoán được
D. Thiếu giá trị của thuộc tính Humidity nên không dự đoán được
Dùng cây quyết định đã xây dựng, dự đoán kết quả cho mẫu dữ liệu sau: Temperature = Hot, Outlook = Rain.
A. Yes
B. No
C. Thiếu giá trị của thuộc tính Wind nên không dự đoán được
D. Thiếu giá trị của thuộc tính Humidity nên không dự đoán được
Độ chính xác của mô hình cây trên tập kiểm tra là bao nhiêu?**
A. 50%
B. 75%
C. 100%
D. 25%
Dựa vào cây đã được xây dựng, ta thấy 3 mẫu được dự đoán đúng nhãn và 1 mẫu sai nhãn → Độ chính xác của cây là 75%.
Nếu một thuộc tính liên tục được chọn làm thuộc tính phân chia, bước tiếp theo sẽ là gì?
A. Chuyển đổi thuộc tính liên tục thành thuộc tính phân loại
B. Chọn điểm cắt để chia thuộc tính thành hai miền
C. Bỏ qua thuộc tính liên tục đó
D. Chia thuộc tính thành nhiều phân khúc dựa trên các giá trị trung bình
Thuộc tính liên tục là các thuộc tính có thể nhận giá trị trong một khoảng số thực, ví dụ như chiều cao, cân nặng, nhiệt độ,...
Khi xây dựng cây quyết định, để phân chia dữ liệu dựa trên thuộc tính liên tục, ta cần chuyển thuộc tính này thành dạng phân đoạn để tạo nhánh cây. Cách làm phổ biến là chọn một điểm cắt (threshold) để chia thuộc tính thành hai miền.
Ví dụ: Nếu thuộc tính là "tuổi", điểm cắt có thể là 30. Dữ liệu sẽ được chia thành hai nhóm: tuổi ≤ 30 và tuổi > 30. Việc chọn điểm cắt dựa trên tiêu chí tối ưu tùy theo thuật toán.
Một thuộc tính có giá trị Information Gain bằng 0 cho thấy điều gì?
A. Thuộc tính không mang lại thông tin để phân biệt các lớp
B. Thuộc tính là quan trọng nhất
C. Thuộc tính này có thể loại bỏ trong quá trình huấn luyện
D. Thuộc tính gây overfitting
Information Gain đo lượng thông tin mà một thuộc tính cung cấp để phân biệt các lớp trong dữ liệu. Nếu IG = 0 nghĩa là phân chia theo thuộc tính đó không làm giảm entropy (độ hỗn loạn) của tập dữ liệu. Nói cách khác, thuộc tính đó không giúp phân biệt các lớp và không hữu ích cho mô hình phân loại.
Trong bài toán này, chúng ta được cho dataset về các batch rượu đỏ ở Bồ Đào Nha, gồm 11 features (acidity, sugar, pH,…) và 1 label là quality (0–10).
Nhiệm vụ:
Code mẫu: Random Forest Hands-on
Khi so sánh với các kỹ thuật ensemble như Gradient Boosting, một lợi thế nổi bật của Random Forest, đặc biệt khi làm việc với tập dữ liệu lớn, là gì?
A. Thời gian huấn luyện của Random Forest luôn ngắn hơn đáng kể so với Gradient Boosting.
B. Việc huấn luyện các cây trong Random Forest có thể được thực hiện song song một cách hiệu quả do tính độc lập của chúng.
C. Random Forest có độ chính xác cao hơn so với Gradient Boosting.
D. Random Forest thường ít nhạy cảm với hiện tượng overfitting hơn Gradient Boosting trong mọi trường hợp.
Với n_estimators=50, random_state=42, MSE & R² trên tập test (làm tròn 4 chữ số) là?
# Đánh giá mô hình với MSE và R2 predictions = forest.predict(X_test) print("MSE:", round(mean_squared_error(y_test, predictions), 4)) print("R2: ", round(r2_score(y_test, predictions), 4))
Thử các n_estimators [10,20,50,100], cây nào cho MSE nhỏ nhất?
best_mse, best_trees = float('inf'), None for n in [10,20,50,100]: model = RandomForestRegressor(n_estimators=n, random_state=42) model.fit(X_train, y_train) mse = mean_squared_error(y_test, model.predict(X_test)) print(f"{n} trees → MSE: {mse:.4f}") if mse < best_mse: best_mse, best_trees = mse, n print(f"Optimal: {best_trees} trees with MSE {best_mse:.4f}")
Thử max_depth từ 1 đến 10 (random_state=100), độ sâu nào cho MSE nhỏ nhất?
best_mse, best_depth = float('inf'), None for depth in range(1,11): model = RandomForestRegressor(n_estimators=100, max_depth=depth, random_state=100) model.fit(X_train, y_train) mse = mean_squared_error(y_test, model.predict(X_test)) print(f"Depth {depth} → MSE: {mse:.4f}") if mse < best_mse: best_mse, best_depth = mse, depth print(f"Optimal depth: {best_depth} with MSE {best_mse:.4f}")
Trong bài toán này, chúng ta sẽ được cho một bộ dataset mô tả thông tin về các batch của một loại rượu đỏ ở Bồ Đào Nha, bao gồm các features liên quan đến tính chất của rượu như: nồng độ acid, độ đường, độ pH,... Nhiệm vụ của chúng ta là phân tích, xử lý bộ data và trả lời các câu hỏi yêu cầu thực hiện coding. Đây là bài toán phân loại với 11 features đầu vào và 1 feature đầu ra là chất lượng của rượu (từ 0 đến 10).
Dataset: winequality-red.csv
Đọc dữ liệu
Tách bộ feature (X) và label (y)
Tách train/test
Lưu ý: Sử dụng các mô hình regressor trong sklearn.
Code mẫu: XG Ada Gra Boost Hands-on
Yếu tố nào mô tả sự khác biệt cốt lõi trong cơ chế cải thiện mô hình giữa AdaBoost và Gradient Boosting?
A) Cả AdaBoost và Gradient Boosting đều áp dụng một phương pháp tương tự nhau để tinh chỉnh mô hình qua từng vòng lặp.
B) AdaBoost ưu tiên sử dụng các mô hình con mạnh, trong khi Gradient Boosting lại tập trung vào các mô hình con yếu.
C) AdaBoost tập trung vào việc sửa lỗi của các mẫu dữ liệu có lỗi cao nhất, còn Gradient Boosting tập trung vào giảm thiểu giá trị lỗi toàn bộ bằng cách sử dụng đạo hàm.
D) AdaBoost có khả năng chống overfitting tốt, còn Gradient Boosting thì ngược lại, rất dễ gặp phải tình trạng overfitting.
Việc gia tăng số lượng mô hình con (estimators) trong AdaBoost hoặc Gradient Boosting sẽ dẫn đến hiện tượng gì? (Gợi ý: hãy thử nghiệm bằng cách thay đổi tham số n_estimators trong code.)
A) Chất lượng của mô hình luôn được cải thiện một cách tuyến tính khi tăng số lượng mô hình con.
B) Chất lượng mô hình thường giảm khi số lượng mô hình con tăng lên.
C) Chất lượng mô hình không có sự thay đổi đáng kể nào khi điều chỉnh số lượng mô hình con.
D) Chất lượng mô hình có thể được cải thiện, tuy nhiên, việc tăng quá nhiều mô hình con có nguy cơ dẫn đến overfitting.
Trong những tình huống nào, hiện tượng overfitting có khả năng xuất hiện đối với các thuật toán AdaBoost và Gradient Boosting? (Gợi ý: hãy thử nghiệm với các kịch bản được mô tả dưới đây bằng code và đưa ra nhận định.)
A) Khi mô hình không được cung cấp đủ lượng dữ liệu cần thiết cho quá trình huấn luyện.
B) Khi số lượng mô hình con (estimators) được sử dụng là quá ít.
C) Hiện tượng overfitting không phải là một vấn đề đối với Gradient Boosting.
D) Khi sử dụng một tỷ lệ học (learning rate) quá lớn kết hợp với một số lượng mô hình con (estimators) quá nhiều.
Trong dự đoán chất lượng rượu, đặc trưng nào có importance cao nhất?
importances = ada_regressor.feature_importances_ feature_names = X.columns feature_importance_df = pd.DataFrame({ 'Feature': feature_names, 'Importance': importances }).sort_values(by='Importance', ascending=False) print(feature_importance_df)
importances = gb_regressor.feature_importances_ feature_names = X.columns feature_importance_df = pd.DataFrame({ 'Feature': feature_names, 'Importance': importances }).sort_values(by='Importance', ascending=False) print(feature_importance_df)
Với n_estimators=50, random_state=42, giá trị MSE & R² của AdaBoost và GB là?
print("AdaBoost → MSE:", mean_squared_error(y_test, y_pred_ada)) print("AdaBoost → R2: ", r2_score(y_test, y_pred_ada)) print("GradientBoost → MSE:", mean_squared_error(y_test, y_pred_gb)) print("GradientBoost → R2: ", r2_score(y_test, y_pred_gb))
So sánh hiệu suất bốn model (n_estimators=50, random_state=42). Model nào tốt nhất?
import pandas as pd from sklearn.ensemble import AdaBoostRegressor, GradientBoostingRegressor, RandomForestRegressor from xgboost import XGBRegressor from sklearn.metrics import mean_squared_error, r2_score models = { 'Random Forest': RandomForestRegressor(n_estimators=50, random_state=42), 'XGBoost': XGBRegressor(n_estimators=50, random_state=42), 'AdaBoost': AdaBoostRegressor(n_estimators=50, random_state=42), 'Gradient Boosting': GradientBoostingRegressor(n_estimators=50, random_state=42) } results = {} for name, model in models.items(): model.fit(X_train, y_train) y_pred = model.predict(X_test) results[name] = { 'R^2': r2_score(y_test, y_pred), 'MSE': mean_squared_error(y_test, y_pred) } print(pd.DataFrame(results).T)
Dùng RandomizedSearchCV tìm hyperparameters tốt nhất cho XGBoost. Kết quả nào đúng?
from sklearn.model_selection import RandomizedSearchCV from xgboost import XGBRegressor param_grid = { 'n_estimators': [50, 100, 200], 'max_depth': [3, 5, 7], 'learning_rate': [0.01, 0.1, 0.2], 'subsample': [0.6, 0.8, 1.0] } rs = RandomizedSearchCV( XGBRegressor(objective='reg:squarederror', random_state=42), param_distributions=param_grid, n_iter=10, cv=3, scoring='neg_mean_squared_error', random_state=42 ) rs.fit(X_train, y_train) best_xgb = rs.best_estimator_ print('Best params:', rs.best_params_) print('MSE:', mean_squared_error(y_test, best_xgb.predict(X_test))) print('R2: ', r2_score(y_test, best_xgb.predict(X_test)))
Xét biến mục tiêu 'quality' (nhận các giá trị nguyên như 3, 4, 5, 6, 7, 8). Yếu tố nào sau đây giải thích chính xác nhất lý do tại sao các mô hình hồi quy (regression) cho kết quả tốt hơn so với việc sử dụng mô hình phân loại (classification) đa lớp cho đặc trưng 'quality'?
A) Các mô hình hồi quy có khả năng xử lý các đặc trưng đầu vào dạng số tốt hơn, trong khi mô hình phân loại phù hợp hơn với các đặc trưng dạng categorical đã được mã hóa.
B) Mô hình phân loại yêu cầu biến mục tiêu phải được chuẩn hóa bằng LabelEncoder về dạng 0, 1, 2,... trong khi mô hình hồi quy có thể làm việc trực tiếp với các giá trị gốc của 'quality', giúp giữ nguyên thông tin.
C) Biến 'quality' về bản chất thể hiện một thang đo có thứ tự, nơi độ lớn và khoảng cách giữa các giá trị (ví dụ, sự khác biệt giữa chất lượng 6 và 7) là thông tin quan trọng. Mô hình hồi quy có khả năng học và tận dụng mối quan hệ thứ tự này để dự đoán một giá trị liên tục (hoặc gần liên tục), trong khi mô hình phân loại thường coi mỗi mức chất lượng là một lớp riêng biệt, không có mối liên hệ về thứ tự, dẫn đến mất mát thông tin.
D) Các thuật toán hồi quy thường có ít siêu tham số cần tinh chỉnh hơn so với các thuật toán phân loại, giúp việc tìm kiếm mô hình tối ưu trở nên dễ dàng hơn.
from sklearn.preprocessing import LabelEncoder from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier, RandomForestClassifier from xgboost import XGBClassifier from sklearn.metrics import mean_squared_error, r2_score le = LabelEncoder() y_enc = le.fit_transform(y) X_tr, X_te, y_tr, y_te = train_test_split(X, y_enc, test_size=0.2, random_state=42) models = { 'Random Forest': RandomForestClassifier(n_estimators=50, random_state=42), 'XGBoost': XGBClassifier(n_estimators=50, random_state=42), 'AdaBoost': AdaBoostClassifier(n_estimators=50, random_state=42), 'Gradient Boosting': GradientBoostingClassifier(n_estimators=50, random_state=42) } results = {} for name, model in models.items(): model.fit(X_tr, y_tr) y_p = model.predict(X_te) results[name] = {'R^2': r2_score(y_te, y_p), 'MSE': mean_squared_error(y_te, y_p)} print(pd.DataFrame(results).T)
