Khoảng cách Euclid, chuẩn hóa Min-Max và KNN tính tay: gợi ý phòng trọ

AI

Trong bài này
  1. Chuẩn bị
  2. Mỗi phòng trọ là một vector
  3. Khoảng cách Euclid (Ơ-clít): đường chim bay
  4. Khoảng cách Manhattan (Man-hát-tân): đi theo ô bàn cờ
  5. Code NumPy
  6. Đổi đơn vị, máy chọn sai: vì sao phải chuẩn hóa
  7. Một ví dụ "đau ví"
  8. Chuẩn hóa Min-Max: đưa mọi cột về cùng thang 0 đến 1
  9. KNN tính tay: "ngưu tầm ngưu"
  10. Ý tưởng
  11. Tính tay với 6 máy
  12. Code NumPy: không cần vòng for
  13. Thực hành: gợi ý phòng trọ, có và không chuẩn hóa
  14. Đề bài
  15. Khung code: điền vào chỗ ____
  16. Vì sao phòng H bị loại sau khi chuẩn hóa?
  17. Lỗi thường gặp
  18. Tự luyện thêm
  19. Tóm tắt
Series · Bài 4/12 Toán AI thực chiến: học Toán cho AI bằng code Python
  1. Ký hiệu Toán → NumPy & công thức 1 nơ-ron
  2. Ảnh là ma trận & Web App chấm điểm CV
  3. Hàm số & Sigmoid
  4. Khoảng cách, chuẩn hóa & KNN
  5. Mini-App định giá laptop cũ
  6. Vector, tích vô hướng & cosine
  7. Chữ thành vector bằng đếm từ
  8. Embedding, tìm kiếm ngữ nghĩa & RAG
  9. Nhân ma trận, vector riêng & trị riêng
  10. PCA: bản đồ sinh viên 2D & nén ảnh
  11. Đạo hàm, đạo hàm riêng & chain rule
  12. Lan truyền ngược: nơ-ron tự sửa sai
Xem cả series →

Lướt nhóm cho thuê phòng, bạn thấy hàng chục phòng trọ. Phòng nào "giống" yêu cầu của mình nhất? Bạn nhìn là biết, nhưng máy tính thì không hiểu chữ "giống". Nó chỉ biết làm một việc: đo khoảng cách giữa hai dãy số.

Trong bài này, mình sẽ cùng bạn đo khoảng cách Euclid và Manhattan bằng NumPy, tận mắt thấy chuyện chỉ đổi đơn vị mà máy chọn sai phòng, sửa nó bằng chuẩn hóa Min-Max, rồi tự cài thuật toán KNN (ca-en-en) bằng tay và bằng code để gợi ý phòng trọ.

Bảng khoảng cách của 8 phòng trọ trước và sau chuẩn hóa Min-Max trên Google Colab
Cùng 8 phòng trọ, cùng một yêu cầu: chưa chuẩn hóa thì top 3 là E, H, A; đã chuẩn hóa thì top 3 là E, A, B. Cuối bài bạn sẽ hiểu vì sao.

Chuẩn bị

Code của bài nằm trong notebook Colab (cô-láp): mở notebook trên Google Colab. Bài này dùng các ô A3, A4, A5 và Bài tập 2.

  1. Bấm link, đăng nhập Google, chọn File › Save a copy in Drive để có bản sao của riêng bạn.
  2. Bấm Connect ở góc phải trên, thấy dấu ✓ xanh là sẵn sàng.
  3. Chạy ô A1 trước (ô này có import numpy as np), rồi mới chạy A3, A4, A5. Nếu bạn dùng notebook mới, chỉ cần thêm import numpy as np vào đầu.

💡 Notebook có sẵn ô đáp án (tên bắt đầu bằng 🔑). Hãy tự gõ khung code và điền chỗ trống trước rồi mới mở ra đối chiếu.

Mỗi phòng trọ là một vector

Lấy hai phòng trọ: phòng A giá 3 triệu, cách trường 2 km; phòng B giá 3,5 triệu, cách trường 5 km. Viết mỗi phòng thành một dãy số [giá (triệu), km đến trường]:

𝐚 = [3.0, 2.0], 𝐛 = [3.5, 5.0]
(đọc: "vector a", "vector b"; chữ in đậm để nhắc đây là vector (véc-tơ), không phải một số)

Ta gọi ai (đọc: "a i") là phần tử thứ i của 𝐚: a1 = 3.0 là giá, a2 = 2.0 là số km. Hai phòng "giống nhau" đến đâu? Ta đo khoảng cách giữa hai vector: càng nhỏ càng giống.

Khoảng cách Euclid (Ơ-clít): đường chim bay

d(𝐚, 𝐛) = √∑(ai − bi)²
(đọc: "d của a, b bằng căn của tổng bình phương a i trừ b i")

Đọc từ trong ra ngoài: trừ từng cặp phần tử, bình phương từng hiệu, cộng tất cả lại (∑ đọc là "xích-ma hoa", nghĩa là "tổng"), cuối cùng lấy căn √. Với 2 phần tử, đây chính là định lý Py-ta-go quen thuộc: cạnh huyền của tam giác vuông.

Tính tay: d(𝐚, 𝐛) = √((3.0 − 3.5)² + (2 − 5)²) = √(0.25 + 9) = √9.25 ≈ 3.041.

Khoảng cách Manhattan (Man-hát-tân): đi theo ô bàn cờ

d1(𝐚, 𝐛) = ∑|ai − bi|
(đọc: "d một của a, b bằng tổng trị tuyệt đối a i trừ b i")

Dấu |…| là trị tuyệt đối: bỏ dấu trừ đi. Tên Manhattan đến từ khu phố ở New York có đường kẻ ô vuông như bàn cờ: bạn không thể đi chéo xuyên tòa nhà, phải đi dọc rồi đi ngang.

Tính tay: d1(𝐚, 𝐛) = |−0.5| + |−3| = 0.5 + 3 = 3.5. Lớn hơn Euclid một chút, hợp lý vì đường chim bay luôn ngắn nhất.

Code NumPy

# [A3]: Khoảng cách giữa 2 phòng trọ  — mỗi phòng là 1 vector [giá (triệu), km đến trường]
A = np.array([3.0, 2.0])
B = np.array([3.5, 5.0])

d_euclid    = np.sqrt(np.sum((A - B) ** 2))   # √∑(aᵢ − bᵢ)²
d_manhattan = np.sum(np.abs(A - B))           # ∑|aᵢ − bᵢ|

print("Khoảng cách Euclid    :", round(d_euclid, 3))
print("Kiểm tra np.linalg.norm:", round(np.linalg.norm(A - B), 3))
print("Khoảng cách Manhattan :", d_manhattan)

Kết quả:

Khoảng cách Euclid    : 3.041
Kiểm tra np.linalg.norm: 3.041
Khoảng cách Manhattan : 3.5

Hai con số khớp với phần tính tay. Dòng giữa dùng np.linalg.norm, hàm tính độ dài của một vector, ký hiệu ‖𝐯‖ (đọc: "chuẩn của v"). Khoảng cách Euclid giữa 𝐚 và 𝐛 chính là độ dài của vector hiệu 𝐚 − 𝐛, nên np.linalg.norm(A - B) là cách viết tắt rất hay dùng.

Đổi đơn vị, máy chọn sai: vì sao phải chuẩn hóa

Một ví dụ "đau ví"

Bạn muốn phòng 3 triệu, cách trường 1 km. Có hai lựa chọn:

  • Phòng A: 3,1 triệu (rẻ hơn chút) nhưng xa tận 9 km.
  • Phòng B: 3,3 triệu, cách trường 1,2 km.

Ai cũng thấy B hợp hơn: đắt hơn 200 nghìn nhưng đỡ 8 km đi lại mỗi ngày. Giờ thử để máy chọn, một lần ghi giá bằng đồng, một lần bằng triệu:

# [A4]: Vì sao phải CHUẨN HÓA? — đổi đơn vị là đổi luôn kết quả!
# Bạn muốn: phòng 3 triệu, cách trường 1 km
# Phòng A: 3,1 triệu nhưng cách 9 km   |   Phòng B: 3,3 triệu, cách 1,2 km
q_dong  = np.array([3_000_000, 1.0]);  A_dong  = np.array([3_100_000, 9.0]);  B_dong  = np.array([3_300_000, 1.2])
q_trieu = np.array([3.0, 1.0]);        A_trieu = np.array([3.1, 9.0]);        B_trieu = np.array([3.3, 1.2])

print("Giá tính bằng ĐỒNG : d(q,A) =", round(np.linalg.norm(q_dong - A_dong), 1),
      "  d(q,B) =", round(np.linalg.norm(q_dong - B_dong), 1))
print("Giá tính bằng TRIỆU: d(q,A) =", round(np.linalg.norm(q_trieu - A_trieu), 2),
      "  d(q,B) =", round(np.linalg.norm(q_trieu - B_trieu), 2))

# Chuẩn hóa Min-Max: x' = (x − min) / (max − min)  →  mọi cột về đoạn [0, 1]
def chuan_hoa(X):
    return (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_dong  = np.array([q_dong, A_dong, B_dong])
X_trieu = np.array([q_trieu, A_trieu, B_trieu])
print("\nSau chuẩn hóa (đơn vị đồng):\n",  chuan_hoa(X_dong).round(3))
print("Sau chuẩn hóa (đơn vị triệu):\n", chuan_hoa(X_trieu).round(3))

Kết quả:

Giá tính bằng ĐỒNG : d(q,A) = 100000.0   d(q,B) = 300000.0
Giá tính bằng TRIỆU: d(q,A) = 8.0   d(q,B) = 0.36

Sau chuẩn hóa (đơn vị đồng):
 [[0.    0.   ]
 [0.333 1.   ]
 [1.    0.025]]
Sau chuẩn hóa (đơn vị triệu):
 [[0.    0.   ]
 [0.333 1.   ]
 [1.    0.025]]

Hai dòng đầu là vấn đề. Ghi giá bằng đồng, chênh lệch giá là cả trăm nghìn, còn chênh lệch km chỉ vài đơn vị. Khoảng cách gần như chỉ phản ánh giá, nên d(q, A) nhỏ hơn và máy chọn nhầm phòng A, xa 9 km. Đổi sang triệu thì máy chọn đúng B. Cùng ba căn phòng, chỉ đổi đơn vị mà đổi luôn kết quả.

Chuẩn hóa Min-Max: đưa mọi cột về cùng thang 0 đến 1

x' = (x − min) / (max − min)
(đọc: "x phẩy bằng x trừ min, chia cho max trừ min")

Với mỗi cột, giá trị nhỏ nhất thành 0, lớn nhất thành 1, còn lại nằm ở giữa theo đúng tỉ lệ. Tính tay cột giá (đơn vị triệu): ba số 3.0, 3.1, 3.3 có min = 3.0, max = 3.3.

  • q: (3.0 − 3.0) / (3.3 − 3.0) = 0
  • A: (3.1 − 3.0) / 0.3 = 0.1 / 0.3 ≈ 0.333
  • B: (3.3 − 3.0) / 0.3 = 1

Cột km: 1.0, 9.0, 1.2 có min = 1, max = 9, nên B thành (1.2 − 1) / 8 = 0.025. Tất cả khớp với bảng in ra. Và điều quan trọng nhất: hai bảng sau chuẩn hóa giống hệt nhau, dù một bảng ghi giá bằng đồng, một bảng bằng triệu. Đổi đơn vị không còn ảnh hưởng gì nữa.

Trong code, X.min(axis=0) nghĩa là lấy min theo từng cột (đi dọc xuống), nên mỗi cột được chuẩn hóa riêng bằng min, max của chính nó.

Kết quả ô A4 trên Colab: khoảng cách khi ghi giá bằng đồng và bằng triệu, cùng hai bảng sau chuẩn hóa Min-Max
Kết quả ô A4. (1) Đơn vị đồng: d(q, A) nhỏ hơn nên máy chọn nhầm phòng A (xa 9 km); đơn vị triệu: chọn đúng B. (2) Sau chuẩn hóa Min-Max, hai bảng giống hệt nhau: đổi đơn vị không còn ảnh hưởng.

KNN tính tay: "ngưu tầm ngưu"

Ý tưởng

Muốn bán laptop (láp-tóp) cũ mà không biết hét giá bao nhiêu? Bạn lên nhóm mua bán, tìm 3 máy giống máy mình nhất, rồi lấy trung bình giá của chúng. Đó chính là thuật toán KNN, viết tắt của k-Nearest Neighbors: k láng giềng gần nhất. "Giống nhất" ở đây nghĩa là "khoảng cách nhỏ nhất", đúng thứ bạn vừa học.

ŷ = (1/k) ∑ yi, với i chạy trên k máy gần nhất
(đọc: "y mũ bằng một phần k nhân tổng y i")

Ở đây yi là giá của máy thứ i, còn ŷ ("y mũ") là giá dự đoán. Cộng k giá lại rồi chia k, tức là lấy trung bình.

Tính tay với 6 máy

Máy cần định giá: 8 GB RAM, 3 năm tuổi. Mỗi máy là vector [RAM (GB), tuổi máy (năm)]:

Máy RAM (GB) Tuổi (năm) Giá (triệu) Khoảng cách tới (8 GB, 3 năm)
1 8 2 9.5 √(0² + 1²) = 1
2 8 5 6.0 √(0² + 2²) = 2
3 16 3 13.0 √(8² + 0²) = 8
4 4 4 4.5 √(4² + 1²) ≈ 4.12
5 12 3 10.5 √(4² + 0²) = 4
6 16 1 16.5 √(8² + 2²) ≈ 8.25

Ba khoảng cách nhỏ nhất là 1, 2, 4, tức máy 1, 2 và 5. Giá gợi ý = (9.5 + 6.0 + 10.5) / 3 = 26 / 3 ≈ 8.67 triệu.

Code NumPy: không cần vòng for

# [A5]: KNN tính tay — định giá 1 laptop cũ bằng 3 máy "giống nhất"
# Mỗi máy: [RAM (GB), tuổi máy (năm)]
X = np.array([[8, 2], [8, 5], [16, 3], [4, 4], [12, 3], [16, 1]])
gia = np.array([9.5, 6.0, 13.0, 4.5, 10.5, 16.5])   # triệu đồng
q = np.array([8, 3])                                # máy cần định giá: 8 GB, 3 năm tuổi

d = np.sqrt(np.sum((X - q) ** 2, axis=1))           # khoảng cách tới TỪNG máy
print("Khoảng cách tới 6 máy:", d.round(2))

k = 3
idx = np.argsort(d)[:k]                             # vị trí k máy gần nhất
print("3 máy gần nhất là máy số:", idx + 1)
print("Giá 3 máy đó:", gia[idx])
print(f"👉 Giá gợi ý = trung bình = {gia[idx].mean():.2f} triệu")

Kết quả:

Khoảng cách tới 6 máy: [1.   2.   8.   4.12 4.   8.25]
3 máy gần nhất là máy số: [1 2 5]
Giá 3 máy đó: [ 9.5  6.  10.5]
👉 Giá gợi ý = trung bình = 8.67 triệu

Ba điểm đáng chú ý trong đoạn code ngắn này:

  • X - q: X có 6 hàng, q chỉ có 2 số. NumPy tự trừ q vào từng hàng của X, nên tính được khoảng cách tới cả 6 máy một lúc.
  • axis=1: cộng theo từng hàng (đi ngang), mỗi máy ra một khoảng cách. Ngược với axis=0 (theo cột) ở phần chuẩn hóa.
  • np.argsort(d) không trả về khoảng cách đã sắp xếp mà trả về vị trí của chúng theo thứ tự từ nhỏ đến lớn; [:k] lấy k vị trí đầu. Python đếm từ 0 nên mình in idx + 1 cho khớp số thứ tự máy.
Ô code A5 trên Colab: thuật toán KNN định giá laptop cũ từ 6 máy, kết quả 8.67 triệu
Kết quả ô A5. (1) Tính khoảng cách tới cả 6 máy cùng lúc, không cần vòng for. (2) np.argsort(d)[:k] sắp khoảng cách từ nhỏ đến lớn rồi lấy k vị trí đầu. (3) Kết quả trùng với bảng tính tay: máy 1, 2, 5, giá gợi ý 8.67 triệu.

Tự kiểm tra: đổi k = 1 thì giá gợi ý là bao nhiêu? (Đáp án: 9.5 triệu, vì chỉ lấy đúng máy 1.)

💡 Ở ví dụ 6 máy này, mình chưa chuẩn hóa để bạn dễ tính tay. Với dữ liệu thật có nhiều cột đơn vị khác nhau, luôn chuẩn hóa trước khi đo khoảng cách. Bài tập dưới đây cho bạn thấy rõ vì sao.

Thực hành: gợi ý phòng trọ, có và không chuẩn hóa

Đề bài

Bạn cần phòng khoảng 2,7 triệu/tháng, cách trường 1,5 km, rộng 20 m². Có 8 phòng trên nhóm cho thuê. Hãy tìm 3 phòng giống yêu cầu nhất, trước và sau khi chuẩn hóa, rồi so sánh.

Phòng Giá (triệu) Km đến trường Diện tích (m²)
A 2.7 1.0 17
B 2.9 1.2 24
C 2.2 3.5 15
D 4.5 1.2 30
E 2.6 2.0 20
F 3.0 4.0 28
G 1.8 6.0 14
H 3.6 1.5 21

Khung code: điền vào chỗ ____

  1. Tính khoảng cách chưa chuẩn hóa d_tho từ từng phòng tới q.
  2. Chuẩn hóa Min-Max cả bảng X và cả q bằng cùng x_min, x_max của bảng.
  3. Dùng np.argsort(...)[:3] lấy 3 phòng gần nhất cho cả hai cách.
  4. So sánh hai danh sách và thử giải thích vì sao chúng khác nhau.
# BÀI TẬP 2 — KHUNG CODE: điền vào chỗ ____
import numpy as np
import pandas as pd

ten_phong = ["A", "B", "C", "D", "E", "F", "G", "H"]
X = np.array([
    [2.7, 1.0, 17], [2.9, 1.2, 24], [2.2, 3.5, 15], [4.5, 1.2, 30],
    [2.6, 2.0, 20], [3.0, 4.0, 28], [1.8, 6.0, 14], [3.6, 1.5, 21],
])
q = np.array([2.7, 1.5, 20])          # phòng mong muốn

# 1. Khoảng cách CHƯA chuẩn hóa
d_tho = np.sqrt(np.sum((X - ____) ** 2, axis=1))

# 2. Chuẩn hóa Min-Max — dùng CÙNG min, max của bảng cho cả q
x_min, x_max = X.min(axis=0), X.max(axis=0)
X_cc = (X - ____) / (____ - ____)
q_cc = (q - x_min) / (x_max - x_min)
d_cc = np.sqrt(np.sum((X_cc - q_cc) ** 2, axis=1))

# 3. Lấy 3 phòng gần nhất
top_tho = np.argsort(d_tho)[:3]
top_cc  = np.argsort(____)[:3]

bang = pd.DataFrame(X, columns=["Giá (tr)", "Km", "m²"], index=ten_phong)
bang["d chưa chuẩn hóa"] = d_tho.round(2)
bang["d đã chuẩn hóa"] = d_cc.round(2)
print(bang)
print("\nTop 3 CHƯA chuẩn hóa:", [ten_phong[i] for i in top_tho])
print("Top 3 ĐÃ chuẩn hóa  :", [ten_phong[i] for i in top_cc])
Xem đáp án

Ba dòng có chỗ trống, điền xong như sau:

d_tho = np.sqrt(np.sum((X - q) ** 2, axis=1))
X_cc = (X - x_min) / (x_max - x_min)
top_cc  = np.argsort(d_cc)[:3]

Kết quả:

   Giá (tr)   Km    m²  d chưa chuẩn hóa  d đã chuẩn hóa
A       2.7  1.0  17.0              3.04            0.21
B       2.9  1.2  24.0              4.02            0.27
C       2.2  3.5  15.0              5.41            0.54
D       4.5  1.2  30.0             10.17            0.92
E       2.6  2.0  20.0              0.51            0.11
F       3.0  4.0  28.0              8.39            0.72
G       1.8  6.0  14.0              7.55            1.03
H       3.6  1.5  21.0              1.35            0.34

Top 3 CHƯA chuẩn hóa: ['E', 'H', 'A']
Top 3 ĐÃ chuẩn hóa  : ['E', 'A', 'B']

Vì sao phòng H bị loại sau khi chuẩn hóa?

Chưa chuẩn hóa, cột diện tích có số lớn (14 đến 30) nên lấn át hai cột còn lại. Phòng H chỉ chênh 1 m² so với yêu cầu nên trông rất "giống", dù đắt hơn tận 900 nghìn mỗi tháng.

Sau chuẩn hóa, mọi chênh lệch được đo bằng "phần của cả khoảng". Giá trong bảng chạy từ 1,8 đến 4,5 triệu, tức khoảng giá rộng 2,7 triệu. Chênh 0,9 triệu = 0,9 / 2,7 = 1/3 cả khoảng giá, một chênh lệch lớn. Trong khi đó chênh 1 m² chỉ là 1/16 khoảng diện tích (14 đến 30). Tính tay khoảng cách đã chuẩn hóa của H: √((1/3)² + 0² + (1/16)²) ≈ √(0.111 + 0.004) ≈ 0.34, khớp bảng. Vì vậy H tụt xuống thứ 4, còn B (giá sát, gần trường) lên top 3.

💡 Nhớ chuẩn hóa q bằng min, max của bảng, đừng chuẩn hóa q riêng. q chỉ là một dòng, nếu tự lấy min, max của chính nó theo cột thì max = min, phép chia thành 0/0 và cho ra nan. Kể cả khi không lỗi, dùng min, max khác nhau cho q và cho bảng cũng giống như đo hai thứ bằng hai cây thước khác nhau.

Lỗi thường gặp

Thông báo lỗi Nguyên nhân Cách xử lý
NameError: name '____' is not defined Còn chỗ trống chưa điền Tìm ____ trong ô và điền đủ
NameError: name 'np' is not defined Chưa chạy ô import Chạy ô có import numpy as np trước (ô A1)
ValueError: operands could not be broadcast Vector q khác số phần tử với số cột của X Kiểm tra .shape: q phải có đúng số cột của X

Tự luyện thêm

  1. Coi trọng giá hơn: nếu bạn rất để ý tiền phòng, hãy nhân cột giá đã chuẩn hóa với 2 trước khi tính khoảng cách. Top 3 thay đổi thế nào? Gợi ý: tạo trong_so = np.array([2, 1, 1]) rồi tính khoảng cách trên (X_cc - q_cc) * trong_so.
  2. Đổi sang Manhattan: thay khoảng cách Euclid bằng np.sum(np.abs(X_cc - q_cc), axis=1). Top 3 có giống Euclid không?

Tóm tắt

  • Máy đo "độ giống" bằng khoảng cách giữa hai vector: Euclid (đường chim bay) hoặc Manhattan (đi theo ô bàn cờ). Càng nhỏ càng giống.
  • Các cột có đơn vị khác nhau thì cột số to sẽ lấn át. Chuẩn hóa Min-Max đưa mọi cột về đoạn [0, 1] để công bằng.
  • KNN: tìm k điểm gần nhất rồi lấy trung bình giá trị của chúng. Trong NumPy chỉ cần np.argsort(d)[:k] và .mean().
Ký hiệu Toán Cách đọc Lệnh NumPy
𝐚 = [3.0, 2.0] "vector a" a = np.array([3.0, 2.0])
ai "a i" (phần tử thứ i) a[i] (Python đếm từ 0)
d(𝐚, 𝐛) = √∑(ai − bi)² "d của a, b bằng căn của tổng bình phương a i trừ b i" np.sqrt(np.sum((a - b) ** 2))
d1(𝐚, 𝐛) = ∑|ai − bi| "d một của a, b bằng tổng trị tuyệt đối a i trừ b i" np.sum(np.abs(a - b))
‖𝐯‖ "chuẩn của v" (độ dài của v) np.linalg.norm(v)
x' = (x − min) / (max − min) "x phẩy bằng x trừ min, chia cho max trừ min" (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
ŷ = (1/k) ∑ yi "y mũ bằng một phần k nhân tổng y i" y[np.argsort(d)[:k]].mean()

Bài tiếp theo trong series: Mini-App định giá laptop cũ bằng KNN. Từ 6 máy tính tay, mình sẽ chuyển sang 40 laptop thật với 4 thông số, tự viết hàm định giá và đóng gói thành Web App có link gửi bạn bè dùng thử.

Ảnh Nguyễn Hữu Huy

Tác giả

Giảng viên Khoa Công nghệ Thông tin, Cao đẳng FPT Polytechnic

Thầy Huy dạy lập trình tại Cao đẳng FPT Polytechnic, chia sẻ kiến thức về Android, Unity/C#, AI và lập trình backend qua blog dotplays và kênh YouTube Thầy Huy One Champ. Tác giả các ứng dụng dotsave, getvidfb và taptik.