🎓 Danh sách khóa học Thầy Lê Chí Tuyền

"""Bài 1 – Lập trình truyền thống vs học máy.
Bài toán: từ chiều dài cánh hoa, đoán loài hoa diên vĩ (Iris versicolor hay virginica)."""
from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data[50:, 2]            # chiều dài cánh hoa (cm) của 100 bông: 50 versicolor, 50 virginica
y = iris.target[50:] - 1         # 0 = versicolor, 1 = virginica
ten = ["versicolor", "virginica"]

# ----- Cách 1: LẬP TRÌNH TRUYỀN THỐNG – con người tự nghĩ ra luật -----
def luat_tu_viet(chieu_dai):
    return 1 if chieu_dai > 5.5 else 0        # "cảm giác" hoa virginica to hơn 5.5 cm


dung = sum(luat_tu_viet(x) == t for x, t in zip(X, y))
print(f"Luật tự viết (ngưỡng 5.5 cm): đúng {dung}/{len(y)}")

# ----- Cách 2: HỌC MÁY – máy tự tìm ngưỡng tốt nhất từ DỮ LIỆU -----
tot_nhat, nguong_tot = 0, None
for nguong in sorted(set(X)):                # thử mọi ngưỡng có thể
    so_dung = sum((1 if x > nguong else 0) == t for x, t in zip(X, y))
    if so_dung > tot_nhat:
        tot_nhat, nguong_tot = so_dung, nguong
print(f"Ngưỡng máy học được: {nguong_tot} cm -> đúng {tot_nhat}/{len(y)}")

# ----- Dùng "mô hình" vừa học để dự đoán hoa MỚI -----
for x_moi in [3.9, 4.8, 5.6]:
    print(f"  Cánh hoa {x_moi} cm -> đoán là {ten[int(x_moi > nguong_tot)]}")

print("\nThống kê dữ liệu (máy 'nhìn thấy' gì):")
for k in (0, 1):
    v = X[y == k]
    print(f"  {ten[k]:<10}: nhỏ nhất {v.min():.1f}, lớn nhất {v.max():.1f}, trung bình {v.mean():.2f} cm")

"""Bài 2 – Dữ liệu và numpy: mảng, thống kê, chuẩn hoá, lọc."""
import numpy as np

# Nhiệt độ (°C) đo bởi trạm thời tiết trong 2 tuần, mỗi hàng 1 tuần, mỗi cột 1 ngày
nhiet = np.array([[29, 31, 30, 33, 34, 32, 28],
                  [27, 26, 30, 35, 36, 33, 31]])
print("Kích thước (shape):", nhiet.shape, "| số phần tử:", nhiet.size)
print("Trung bình cả 2 tuần:", nhiet.mean().round(2))
print("Trung bình mỗi tuần:", nhiet.mean(axis=1).round(2))
print("Nóng nhất mỗi ngày trong tuần:", nhiet.max(axis=0))
print("Độ lệch chuẩn:", nhiet.std().round(2))

# Phép toán trên CẢ mảng (không cần vòng lặp) – nhanh và gọn
do_f = nhiet * 9 / 5 + 32
print("Đổi sang °F (tuần 1):", do_f[0])

# Lọc bằng điều kiện
print("Các ngày trên 32°C:", nhiet[nhiet > 32])
print("Số ngày nóng:", (nhiet > 32).sum())

# Chuẩn hoá dữ liệu về 0..1 (min-max) – bước bắt buộc trước khi cho nhiều mô hình học
lo, hi = nhiet.min(), nhiet.max()
chuan_hoa = (nhiet - lo) / (hi - lo)
print("Chuẩn hoá min-max (tuần 1):", chuan_hoa[0].round(2))

# Chuẩn hoá z-score: trung bình 0, độ lệch chuẩn 1
z = (nhiet - nhiet.mean()) / nhiet.std()
print("z-score (tuần 2):", z[1].round(2))

# Dữ liệu có giá trị lỗi (cảm biến hỏng trả về -999) -> làm sạch
tho = np.array([28.5, 29.0, -999, 30.1, 29.8, -999, 31.2])
sach = tho[tho > -100]
print(f"Dữ liệu thô {len(tho)} mẫu, sau khi bỏ lỗi còn {len(sach)}, trung bình {sach.mean():.2f}")

# Ma trận ngẫu nhiên có seed – cho kết quả lặp lại được
rng = np.random.default_rng(42)
print("5 số ngẫu nhiên chuẩn:", rng.normal(0, 1, 5).round(3))

"""Bài 3 – Hồi quy tuyến tính: dự đoán giá nhà theo diện tích.
Tự cài GRADIENT DESCENT bằng numpy, rồi so sánh với scikit-learn."""
import numpy as np
from sklearn.linear_model import LinearRegression

rng = np.random.default_rng(0)
dien_tich = rng.uniform(30, 120, 40)                              # m²
gia = 0.045 * dien_tich + 0.5 + rng.normal(0, 0.35, 40)           # tỉ đồng (có nhiễu)

# Chuẩn hoá đầu vào giúp gradient descent hội tụ nhanh
x = (dien_tich - dien_tich.mean()) / dien_tich.std()
w, b = 0.0, 0.0                                                   # mô hình: gia ≈ w*x + b
toc_do_hoc = 0.1
for vong in range(201):
    du_doan = w * x + b
    sai = du_doan - gia
    mse = (sai ** 2).mean()                                       # hàm mất mát: sai số bình phương trung bình
    dw = 2 * (sai * x).mean()                                     # đạo hàm của MSE theo w
    db = 2 * sai.mean()                                           # đạo hàm theo b
    w -= toc_do_hoc * dw                                          # bước xuống dốc
    b -= toc_do_hoc * db
    if vong in (0, 5, 20, 50, 200):
        print(f"vòng {vong:>3}: MSE = {mse:.4f}  w = {w:.4f}  b = {b:.4f}")

# Quy đổi về đơn vị gốc: gia = a * dien_tich + c
a = w / dien_tich.std()
c = b - a * dien_tich.mean()
print(f"\nMô hình tự học : giá = {a:.4f} x diện tích + {c:.3f}")

mo_hinh = LinearRegression().fit(dien_tich.reshape(-1, 1), gia)
print(f"scikit-learn   : giá = {mo_hinh.coef_[0]:.4f} x diện tích + {mo_hinh.intercept_:.3f}")
print(f"R² (độ khớp, 1 là tuyệt đối): {mo_hinh.score(dien_tich.reshape(-1, 1), gia):.3f}")

for s in (50, 80, 100):
    print(f"  Nhà {s} m² -> dự đoán {a * s + c:.2f} tỉ đồng")

"""Bài 4 – Phân loại với k láng giềng gần nhất (kNN): tự viết bằng numpy và so sánh với scikit-learn.
Dữ liệu: hoa Iris, dùng 2 đặc trưng chiều dài và chiều rộng cánh hoa, 3 loài."""
import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

iris = load_iris()
X = iris.data[:, 2:4]                       # chiều dài, chiều rộng cánh hoa (cm)
y = iris.target
TEN = iris.target_names
X_hoc, X_thu, y_hoc, y_thu = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)
print(f"Dữ liệu học: {len(X_hoc)} bông, dữ liệu kiểm tra: {len(X_thu)} bông")


def knn_du_doan(x_moi, k=5):
    khoang_cach = np.sqrt(((X_hoc - x_moi) ** 2).sum(axis=1))   # khoảng cách Euclid tới MỌI mẫu học
    gan_nhat = np.argsort(khoang_cach)[:k]                        # chỉ số k mẫu gần nhất
    phieu = Counter(y_hoc[gan_nhat])                              # bỏ phiếu theo nhãn
    return phieu.most_common(1)[0][0]


for k in (1, 3, 5, 15):
    du_doan = np.array([knn_du_doan(x, k) for x in X_thu])
    print(f"k = {k:>2}: độ chính xác tự viết = {(du_doan == y_thu).mean():.1%}")

mo_hinh = KNeighborsClassifier(n_neighbors=5).fit(X_hoc, y_hoc)
print(f"scikit-learn (k = 5): {mo_hinh.score(X_thu, y_thu):.1%}")

for hoa in ([1.5, 0.3], [4.5, 1.4], [5.8, 2.2], [4.9, 1.7]):
    print(f"  Cánh {hoa[0]} x {hoa[1]} cm -> {TEN[knn_du_doan(np.array(hoa))]}")

"""Bài 5 – Đánh giá mô hình: chia dữ liệu, độ chính xác, ma trận nhầm lẫn, precision / recall,
và hiện tượng QUÁ KHỚP (overfitting)."""
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, precision_score, recall_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

# Bài toán y tế: dự đoán khối u lành (1) hay ác tính (0) từ 30 chỉ số ảnh siêu âm
du_lieu = load_breast_cancer()
X, y = du_lieu.data, du_lieu.target
X_hoc, X_thu, y_hoc, y_thu = train_test_split(X, y, test_size=0.25, random_state=0, stratify=y)
mo_hinh = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)).fit(X_hoc, y_hoc)
du_doan = mo_hinh.predict(X_thu)

print(f"Số mẫu học {len(X_hoc)}, kiểm tra {len(X_thu)}")
print(f"Độ chính xác (accuracy): {(du_doan == y_thu).mean():.1%}")
tn, fp, fn, tp = confusion_matrix(y_thu, du_doan, labels=[0, 1]).ravel()
print("Ma trận nhầm lẫn (hàng = thật, cột = dự đoán):")
print(f"               đoán ác tính  đoán lành")
print(f"  thật ác tính      {tn:>4}        {fp:>4}   <- {fp} ca ác tính bị bỏ sót (nguy hiểm!)")
print(f"  thật lành         {fn:>4}        {tp:>4}")
print(f"Precision (đoán 'lành' thì đúng bao nhiêu): {precision_score(y_thu, du_doan):.1%}")
print(f"Recall    (tìm ra được bao nhiêu ca lành) : {recall_score(y_thu, du_doan):.1%}")
print(f"Recall cho lớp ác tính (quan trọng nhất)  : {recall_score(y_thu, du_doan, pos_label=0):.1%}")

# ----- Quá khớp: mô hình đa thức bậc cao "học thuộc" dữ liệu -----
rng = np.random.default_rng(3)
x = np.sort(rng.uniform(0, 1, 15))
y_that = np.sin(2 * np.pi * x) + rng.normal(0, 0.2, 15)
x_moi = np.linspace(x.min(), x.max(), 50)            # điểm MỚI nằm giữa các điểm đã học
y_moi = np.sin(2 * np.pi * x_moi)
print("\nĐa thức bậc d khớp 15 điểm (sai số trên dữ liệu học / dữ liệu mới):")
for d in (1, 3, 9):
    he_so = np.polyfit(x, y_that, d)
    sai_hoc = np.mean((np.polyval(he_so, x) - y_that) ** 2)
    sai_moi = np.mean((np.polyval(he_so, x_moi) - y_moi) ** 2)
    nhan_xet = "chưa khớp (underfit)" if d == 1 else ("vừa đẹp" if d == 3 else "QUÁ KHỚP (overfit)")
    print(f"  bậc {d:>2}: học {sai_hoc:.3f} | mới {sai_moi:.3f}  -> {nhan_xet}")

"""Bài 6 – Cây quyết định: mô hình "dễ hiểu" – in được ra các câu hỏi Có/Không như con người."""
import numpy as np
from sklearn.tree import DecisionTreeClassifier, export_text

# Dữ liệu tự tạo: có nên tưới cây không? [độ ẩm đất %, nhiệt độ °C, khả năng mưa %]
rng = np.random.default_rng(7)
do_am = rng.uniform(10, 90, 200)
nhiet = rng.uniform(18, 40, 200)
mua = rng.uniform(0, 100, 200)
X = np.column_stack([do_am, nhiet, mua])
# "Luật thật" (máy không biết): đất khô dưới 35% và sắp không mưa -> tưới; hoặc rất nóng và đất dưới 50%
y = (((do_am < 35) & (mua < 60)) | ((nhiet > 35) & (do_am < 50))).astype(int)

cay = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print(f"Độ chính xác trên dữ liệu học: {cay.score(X, y):.1%}")
print("Cây quyết định máy học được:\n")
print(export_text(cay, feature_names=["do_am", "nhiet_do", "kha_nang_mua"], class_names=["khong_tuoi", "TUOI"]))

print("Mức độ quan trọng của từng đặc trưng:")
for ten, qt in zip(["độ ẩm đất", "nhiệt độ", "khả năng mưa"], cay.feature_importances_):
    print(f"  {ten:<14}{'█' * int(qt * 40)} {qt:.2f}")

for mau in ([25, 30, 20], [25, 30, 80], [45, 38, 10], [70, 25, 0]):
    kq = cay.predict([mau])[0]
    print(f"  Đất {mau[0]}%, {mau[1]}°C, mưa {mau[2]}% -> {'TƯỚI' if kq else 'không tưới'}")

"""Bài 7 – Học KHÔNG giám sát: phân cụm k-means tự viết bằng numpy.
Dữ liệu: vị trí (km) của 90 nhà học sinh – tìm 3 điểm đặt trạm xe buýt đưa đón."""
import numpy as np

rng = np.random.default_rng(5)
tam_that = np.array([[2, 3], [8, 8], [9, 2]])
X = np.vstack([rng.normal(t, 1.0, (30, 2)) for t in tam_that])     # 3 khu dân cư (máy không biết)

k = 3
tam = X[rng.choice(len(X), k, replace=False)]                          # bước 0: chọn ngẫu nhiên 3 tâm
for vong in range(1, 20):
    kc = np.linalg.norm(X[:, None, :] - tam[None, :, :], axis=2)        # khoảng cách mọi điểm tới mọi tâm
    nhom = kc.argmin(axis=1)                                            # bước 1: gán điểm vào tâm gần nhất
    tam_moi = np.array([X[nhom == j].mean(axis=0) for j in range(k)])   # bước 2: dời tâm về trung bình nhóm
    dich = np.linalg.norm(tam_moi - tam)
    tam = tam_moi
    print(f"vòng {vong}: tâm dịch chuyển {dich:.3f} km")
    if dich < 1e-3:
        print("-> hội tụ!")
        break

print("\nVị trí 3 trạm xe buýt đề xuất:")
for j in np.argsort(tam[:, 0]):
    print(f"  Trạm tại ({tam[j, 0]:.2f}, {tam[j, 1]:.2f}) km – phục vụ {np.sum(nhom == j)} học sinh, "
          f"xa nhất {np.max(np.linalg.norm(X[nhom == j] - tam[j], axis=1)):.2f} km")

"""Bài 8 – Nơ-ron nhân tạo (perceptron): học hàm AND, OR – và thất bại với XOR."""
import numpy as np

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
BANG = {"AND": [0, 0, 0, 1], "OR": [0, 1, 1, 1], "XOR": [0, 1, 1, 0]}


def huan_luyen(y, so_vong=20, toc_do=0.2):
    w = np.zeros(2)
    b = 0.0
    for _ in range(so_vong):
        for xi, yi in zip(X, y):
            ra = 1 if xi @ w + b > 0 else 0       # nơ-ron: tổng có trọng số -> hàm bước
            loi = yi - ra
            w += toc_do * loi * xi                 # luật học perceptron: chỉnh trọng số theo lỗi
            b += toc_do * loi
    return w, b


for ten, y in BANG.items():
    w, b = huan_luyen(np.array(y))
    ra = [1 if xi @ w + b > 0 else 0 for xi in X]
    dung = sum(r == t for r, t in zip(ra, y))
    print(f"{ten:<4}: w = {w.round(2)}, b = {b:.2f} -> đầu ra {ra} (mong muốn {y}) – đúng {dung}/4"
          + ("" if dung == 4 else "  ✗ một nơ-ron KHÔNG làm được"))
print("\nXOR không chia được bằng MỘT đường thẳng -> cần nhiều nơ-ron xếp thành nhiều lớp (bài tiếp theo).")

"""Bài 8 – Mạng nơ-ron 2 lớp tự viết bằng numpy, huấn luyện bằng LAN TRUYỀN NGƯỢC (backpropagation) để học XOR."""
import numpy as np

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([[0], [1], [1], [0]], dtype=float)


def sigmoid(z):
    return 1 / (1 + np.exp(-z))


rng = np.random.default_rng(1)
W1 = rng.normal(0, 1, (2, 4))        # lớp ẩn: 2 đầu vào -> 4 nơ-ron
b1 = np.zeros(4)
W2 = rng.normal(0, 1, (4, 1))        # lớp ra: 4 -> 1
b2 = np.zeros(1)
toc_do = 1.0

for vong in range(5001):
    # ----- lan truyền xuôi -----
    h = sigmoid(X @ W1 + b1)
    ra = sigmoid(h @ W2 + b2)
    mat_mat = np.mean((ra - y) ** 2)
    # ----- lan truyền ngược: đạo hàm theo quy tắc chuỗi -----
    d_ra = 2 * (ra - y) / len(X) * ra * (1 - ra)
    d_W2 = h.T @ d_ra
    d_b2 = d_ra.sum(axis=0)
    d_h = d_ra @ W2.T * h * (1 - h)
    d_W1 = X.T @ d_h
    d_b1 = d_h.sum(axis=0)
    # ----- cập nhật trọng số -----
    W2 -= toc_do * d_W2; b2 -= toc_do * d_b2
    W1 -= toc_do * d_W1; b1 -= toc_do * d_b1
    if vong in (0, 500, 1000, 2000, 5000):
        print(f"vòng {vong:>4}: mất mát = {mat_mat:.4f}")

print("\nKết quả sau huấn luyện:")
for xi, ri in zip(X, sigmoid(sigmoid(X @ W1 + b1) @ W2 + b2)):
    print(f"  {int(xi[0])} XOR {int(xi[1])} -> {ri[0]:.3f} -> {int(ri[0] > 0.5)}")
print(f"Số tham số của mạng: {W1.size + b1.size + W2.size + b2.size}")

"""Bài 9 – Nhận dạng chữ số viết tay (ảnh 8x8 điểm) bằng mạng nơ-ron MLP của scikit-learn."""
import numpy as np
from sklearn.datasets import load_digits
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier

so = load_digits()                      # 1797 ảnh, mỗi ảnh 8x8 = 64 điểm ảnh, độ sáng 0..16
print(f"Số ảnh: {len(so.images)}, kích thước mỗi ảnh: {so.images[0].shape}")

KY_TU = " .:-=+*#%@"
def ve(anh):                            # in ảnh ra chữ để "nhìn" dữ liệu
    return ["".join(KY_TU[int(v / 16 * 9)] * 2 for v in hang) for hang in anh]

print("\nẢnh đầu tiên (nhãn = %d):" % so.target[0])
for dong in ve(so.images[0]):
    print("  " + dong)

X = so.data / 16.0                      # chuẩn hoá về 0..1
X_hoc, X_thu, y_hoc, y_thu = train_test_split(X, so.target, test_size=0.25, random_state=0, stratify=so.target)
mlp = MLPClassifier(hidden_layer_sizes=(64,), max_iter=400, random_state=0).fit(X_hoc, y_hoc)
print(f"\nMạng 64 -> 64 -> 10 nơ-ron, huấn luyện {mlp.n_iter_} vòng")
print(f"Độ chính xác trên {len(X_thu)} ảnh chưa từng thấy: {mlp.score(X_thu, y_thu):.1%}")

du_doan = mlp.predict(X_thu)
cm = confusion_matrix(y_thu, du_doan)
print("\nMa trận nhầm lẫn (hàng: số thật 0-9, cột: số dự đoán 0-9):")
for i, hang in enumerate(cm):
    print(f"  {i} | " + " ".join(f"{v:>2}" if v else " ." for v in hang))

sai = np.where(du_doan != y_thu)[0][:2]
for i in sai:
    print(f"\nẢnh bị nhận sai: thật là {y_thu[i]}, máy đoán {du_doan[i]}")
    for dong in ve(X_thu[i].reshape(8, 8) * 16):
        print("  " + dong)

"""Bài 10 – DỰ ÁN AI trên vi điều khiển (TinyML): nhận biết hoạt động (đứng yên / đi bộ / chạy / ngã)
từ cảm biến gia tốc MPU6050 gắn trên người. Huấn luyện trên máy tính -> xuất thành CODE C cho ESP32."""
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

rng = np.random.default_rng(11)
NHAN = ["dung_yen", "di_bo", "chay", "nga"]


def tao_cua_so(loai):
    """Giả lập 1 giây dữ liệu (50 mẫu) độ lớn gia tốc |a| (đơn vị g)."""
    t = np.arange(50) / 50
    if loai == 0: a = 1 + rng.normal(0, 0.02, 50)
    elif loai == 1: a = 1 + 0.25 * np.sin(2 * np.pi * 2 * t + rng.uniform(0, 6)) + rng.normal(0, 0.05, 50)
    elif loai == 2: a = 1 + 0.8 * np.abs(np.sin(2 * np.pi * 3 * t + rng.uniform(0, 6))) + rng.normal(0, 0.1, 50)
    else:
        a = 1 + rng.normal(0, 0.05, 50)
        k = rng.integers(10, 35)
        a[k:k + 3] += rng.uniform(2.0, 3.0)          # cú va đập mạnh
        a[k + 3:] = rng.normal(0.95, 0.03, 50 - k - 3)
    return a


def dac_trung(a):                                    # rút gọn 50 mẫu thành 3 con số – tính được trên ESP32
    return [a.std(), a.max(), np.abs(np.diff(a)).mean()]


X, y = [], []
for loai in range(4):
    for _ in range(150):
        X.append(dac_trung(tao_cua_so(loai)))
        y.append(loai)
X, y = np.array(X), np.array(y)
X_hoc, X_thu, y_hoc, y_thu = train_test_split(X, y, test_size=0.3, random_state=0, stratify=y)
cay = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X_hoc, y_hoc)
print(f"Độ chính xác trên dữ liệu kiểm tra: {cay.score(X_thu, y_thu):.1%}")

# ----- Xuất cây quyết định thành hàm C (chạy được trên Arduino / ESP32, không cần thư viện AI) -----
TEN_DT = ["do_lech", "gia_tri_max", "bien_thien"]
t = cay.tree_


def sinh_c(nut, thut):
    pad = "    " * thut
    if t.children_left[nut] == -1:
        return f"{pad}return {int(np.argmax(t.value[nut]))};  // {NHAN[int(np.argmax(t.value[nut]))]}\n"
    s = f"{pad}if ({TEN_DT[t.feature[nut]]} <= {t.threshold[nut]:.4f}f) {{\n"
    s += sinh_c(t.children_left[nut], thut + 1)
    s += f"{pad}}} else {{\n" + sinh_c(t.children_right[nut], thut + 1) + f"{pad}}}\n"
    return s


print("\n// ===== Dán vào sketch ESP32 =====")
print("// 0 = đứng yên, 1 = đi bộ, 2 = chạy, 3 = NGÃ")
print("int nhanDangHoatDong(float do_lech, float gia_tri_max, float bien_thien) {")
print(sinh_c(0, 1), end="")
print("}")
print(f"// Kích thước mô hình: {t.node_count} nút – chỉ vài trăm byte Flash")