Python - Bài 30

🎓 Bài 30: Đồ án Tốt nghiệp — Tự xây mô hình AI đầu tiên từ con số 0

Chặng 7 · Toán & Tư duy ML (Bài 26 → 30) · đây là bài 5/5 của chặng.

🎯 Mục tiêu: Tổng hợp kiến thức toàn chặng để xây dựng hoàn chỉnh mô hình Hồi quy tuyến tính đa biến (Multivariate Linear Regression) chỉ bằng NumPy, không dùng thư viện AI có sẵn.

👥 Đối tượng: học sinh cấp 2–3, sinh viên, người mới học Python. Cần biết trước: Ma trận (Bài 26) và Gradient Descent (Bài 29).

📖 Cách đọc 3 lớp: mỗi phần có ba khối màu song song — 🟢 Lớp A trực giác, 🔵 Lớp B cơ chế, 🟣 Lớp C nghiên cứu.

Sau bài này bạn sẽ:

• Viết được phương trình dự đoán có nhiều biến số dưới dạng Ma trận.
• Biết cách dùng công thức tính đạo hàm trực tiếp (Analytical Gradient) thay vì phải nhích từng chút một.
• Xây dựng trọn vẹn "Tứ đại quy trình" của mọi mô hình học sâu: Forward → Loss → Backward → Update.
• Cảm nhận được sự kỳ diệu khi hàng chục con số tự động biến đổi để tìm ra quy luật của dữ liệu.

Chúc mừng bạn đã đến với bài học cuối cùng của Chặng 7! Chúng ta đã có dữ liệu dạng Ma trận (Bài 26), có đạo hàm đo dốc (Bài 27), có chiếc bát sai số MSE (Bài 28), và có thuật toán tự bước đi Gradient Descent (Bài 29). Hôm nay, ta sẽ ráp tất cả "linh kiện" này lại để chế tạo cỗ máy Machine Learning đầu tiên: Dự đoán giá nhà dựa vào Diện tích và Số phòng ngủ.

Hình 1 — Toàn cảnh một vòng lặp huấn luyện (Training Loop). Hàng tỷ tham số của ChatGPT cũng được cập nhật qua đúng 4 bước xoay vòng như thế này.

1. Forward: Toán học của sự dự đoán

🟢 Lớp A · Trực giác

Giả sử bạn có thông tin: Nhà rộng 60m2 ($x_1$), có 2 phòng ngủ ($x_2$). Làm sao để đoán giá ($y$)?

Máy sẽ tự động cấp cho diện tích một cái trọng số $w_1$ (ví dụ: mỗi m2 giá bao nhiêu), cấp cho số phòng ngủ một trọng số $w_2$ (mỗi phòng tăng thêm bao nhiêu tiền), và một mức giá nền cơ bản $b$ (nhà nát cũng có giá gốc). Phương trình là:
Giá = ($w_1 \times$ Diện tích) + ($w_2 \times$ Số phòng) + Giá nền

🔵 Lớp B · Cơ chế

Nếu có hàng ngàn ngôi nhà, vòng lặp for sẽ chạy cực chậm. Đây là lúc phép Nhân Ma Trận (Dot Product) của Bài 26 tỏa sáng. Ta gom tất cả $x_1, x_2$ vào ma trận $X$, gom $w_1, w_2$ vào vector $W$. Phép tính rút gọn thành đúng 1 dòng code NumPy:

y_pred = np.dot(X, W) + b

Toàn bộ hàng ngàn dự đoán được tính vèo trong 1 mili-giây!

🟣 Lớp C · Nghiên cứu

Phương trình $\hat{Y} = XW + b$ vẽ ra một "mặt phẳng" trong không gian nhiều chiều. Việc "huấn luyện" chính là xoay và nâng/hạ mặt phẳng này sao cho nó luồn lách qua các điểm dữ liệu thực tế một cách vừa vặn nhất (sai số nhỏ nhất).

2. Backward: Nâng cấp Đạo hàm

🟢 Lớp A · Trực giác

Ở Bài 29, ta đo độ dốc bằng cách thử nhích $w$ lên một chút (+0.0001) rồi xem Loss thay đổi ra sao. Cách đó dễ hiểu, nhưng nếu mô hình có 1 triệu tham số, ta phải "nhích" 1 triệu lần cho mỗi bước đi → máy tính sẽ nổ tung vì kiệt sức.

Thật may, môn Giải tích (Calculus) cho ta một "đường tắt". Các nhà Toán học đã giải sẵn phương trình và tìm ra một công thức trực tiếp. Chỉ cần cắm số vào là ra ngay độ dốc mà không cần thử-sai-nhích gì cả!

🔵 Lớp B · Cơ chế

Sự chênh lệch giữa thực tế và dự đoán gọi là error = y_pred - y_true. Công thức toán học trực tiếp để tính đạo hàm (độ dốc) cho $W$ và $b$ trên toàn bộ tập dữ liệu (với $N$ là số lượng ngôi nhà) là:

error = y_pred - y_true
N = len(y_true)

# dw là ma trận độ dốc của các w (w1, w2)
dw = (2 / N) * np.dot(X.T, error) 

# db là độ dốc của giá nền b
db = (2 / N) * np.sum(error)

🟣 Lớp C · Nghiên cứu

Khái niệm X.T là ma trận chuyển vị (Transpose). Về mặt toán học, đây là quy tắc chuỗi (Chain Rule) khi lấy đạo hàm của hàm tổng $MSE = \frac{1}{N} \sum (XW + b - Y)^2$. Các thư viện như PyTorch/TensorFlow dùng công nghệ AutoGrad để tự động suy ra các công thức kiểu này cho những mạng nơ-ron phức tạp nhất, nhưng cốt lõi toán học thì giống hệt những gì bạn đang thấy.

3. Update: Lắp ráp cỗ máy hoàn chỉnh

🟢 Lớp A · Trực giác

Mọi thứ đã sẵn sàng. Ta chỉ việc ném dữ liệu vào, bật vòng lặp cho chạy qua chạy lại các bước trên. Bạn sẽ thấy Loss (sai số) giảm dần. Ban đầu máy đoán sai bét, nhưng sau mỗi Epoch (1 vòng lặp), $w_1, w_2$ và $b$ sẽ tự động vặn đến những con số tối ưu nhất.

🔵 Lớp B · Cơ chế

Hãy xem toàn bộ mã nguồn ở phần Thực hành bên dưới. Bạn sẽ thấy 4 bước quy trình (Hình 1) được code cực kỳ rành mạch bằng Python.

📝 Bảng tóm tắt Toàn chặng 7

Bước	Toán học	Python (NumPy)
Dữ liệu (Bài 26)	$X$ (Đầu vào), $Y$ (Thực tế)	X = np.array(...); Y = np.array(...)
Forward (Bài 30)	$\hat{Y} = X \cdot W + b$	y_pred = np.dot(X, W) + b
Loss (Bài 28)	$MSE = \frac{1}{N} \sum (\hat{Y} - Y)^2$	loss = np.mean((y_pred - Y)**2)
Backward (Bài 27, 30)	$\frac{\partial L}{\partial W}$, $\frac{\partial L}{\partial b}$ (Đạo hàm)	dw = 2/N * np.dot(X.T, error)
Update (Bài 29)	$W = W - \alpha \cdot dW$ $b = b - \alpha \cdot db$	W = W - lr * dw b = b - lr * db

✎ Kiểm tra nhanh

Câu 1. Trong quy trình 4 bước, bước nào đóng vai trò đo xem "phải chỉnh tham số theo hướng nào và mạnh cỡ nào"?

• Forward (Dự đoán)
• Loss (Đo sai)
• Backward (Đo dốc / Tính đạo hàm)
• Update (Vặn núm)

Chính xác. Backward (Lan truyền ngược) là quá trình tính đạo hàm, cung cấp chiếc "la bàn" chỉ hướng đi xuống đáy. Càng dốc thì đạo hàm càng lớn.

Câu 2. Lợi ích lớn nhất của việc dùng "công thức toán trực tiếp" để tính đạo hàm thay cho cách "nhích thử bằng số" là gì?

• Tính toán siêu nhanh, phù hợp cho mô hình có hàng triệu tham số.
• Nó làm cho sai số tự động bằng 0.
• Giúp Python chạy mượt hơn mà không cần NumPy.
• Không cần dùng vòng lặp (Epoch) nữa.

Đúng! Thay vì phải đoán mò và thử-sai, công thức giải tích cho kết quả lập tức, tiết kiệm tài nguyên khổng lồ cho máy tính.

Câu 3. Nếu bạn muốn xây dựng mô hình dự đoán Giá xe cũ dựa trên Số KM đã chạy, Tuổi xe, Số chỗ ngồi, và Dung tích động cơ. Ma trận $W$ của bạn sẽ có bao nhiêu tham số (chưa tính $b$)?

• 1 tham số
• 4 tham số
• 5 tham số
• Vô số tham số

Đúng! Có 4 đặc trưng (KM, Tuổi, Chỗ ngồi, Dung tích), mỗi đặc trưng cần 1 trọng số $w$ đi kèm. Do đó ma trận $W$ sẽ chứa $w_1, w_2, w_3, w_4$.

💻 Thực hành: Khởi động cỗ máy AI của bạn

▶ Cách dùng: Đây là giây phút tốt nghiệp. Bấm Chạy code và quan sát Loss giảm dần, đồng thời xem mô hình tìm ra được mức giá $W$ (trọng số) vô cùng chính xác.

import numpy as np # 1. DỮ LIỆU HUẤN LUYỆN # X có 2 cột: [Diện tích (m2), Số phòng ngủ] X = np.array([ [50, 1], [60, 2], [80, 2], [100, 3] ]) # Y: Giá nhà thực tế (Tỷ đồng) # Giả lập quy luật ngầm: Giá = 0.03*Diện_tích + 0.2*Phòng_ngủ + 0.5(Giá_nền) Y = np.array([2.2, 2.7, 3.3, 4.1]) N = len(Y) # Khởi tạo tham số ngẫu nhiên bừa bãi ban đầu W = np.array([0.0, 0.0]) b = 0.0 lr = 0.0001 # Tốc độ học nhỏ để không nổ Loss epochs = 500 print("BẮT ĐẦU HUẤN LUYỆN...\n") # VÒNG LẶP HUẤN LUYỆN CHÍNH for epoch in range(epochs): # Bước 1: Forward (Dự đoán) Y_pred = np.dot(X, W) + b # Bước 2: Compute Loss (Tính sai số MSE) error = Y_pred - Y loss = np.mean(error ** 2) # Bước 3: Backward (Tính đạo hàm dW, db) dW = (2 / N) * np.dot(X.T, error) db = (2 / N) * np.sum(error) # Bước 4: Update (Cập nhật tham số Gradient Descent) W = W - lr * dW b = b - lr * db # In kết quả sau mỗi 100 vòng if (epoch + 1) % 100 == 0: print(f"Epoch {epoch+1:3d}: Loss = {loss:.4f} | W = [{W[0]:.4f}, {W[1]:.4f}], b = {b:.4f}") print("\nHOÀN THÀNH HUẤN LUYỆN!") # ----------------- # ỨNG DỤNG THỰC TẾ (INFERENCE) # ----------------- print("\n--- TEST DỰ ĐOÁN NHÀ MỚI ---") nha_moi = np.array([75, 2]) # Nhà 75m2, 2 phòng ngủ gia_du_doan = np.dot(nha_moi, W) + b print(f"Ngôi nhà 75m2, 2 phòng ngủ được AI định giá: {gia_du_doan:.2f} Tỷ đồng")

💡 Thử thách: Bạn hãy tạo ra 1 ngôi nhà mới ở cuối đoạn code trên (ví dụ nhà rộng 120m2, 4 phòng ngủ) và dùng mô hình đã huấn luyện để xem AI đoán giá là bao nhiêu nhé.

TỔNG KẾT CHẶNG 7: Chúc mừng bạn đã hoàn thành xuất sắc! Từ một mảng số đơn giản, bạn đã thấu hiểu cơ chế học sâu nhất của AI. Những gì bạn vừa code bằng Numpy ở bài này chính là LinearRegression nổi tiếng trong thư viện scikit-learn, và cũng là tầng (Layer) cơ bản nhất của mạng Neural Network. Hẹn gặp lại bạn ở Chặng 8, nơi ta sẽ vượt ra khỏi "đường thẳng" để tiến vào thế giới của Học Sâu (Deep Learning) thực thụ!