Gradient descent bằng NumPy: tự tìm hệ số hồi quy
Bài 2/10 · Chương 4
Hồi quy
- 9 phút
- Cơ bản
- Python 3.14
- Cập nhật
Trong bài này · 13
Gradient descent là thuật toán tìm hệ số của model bằng cách sửa dần. Mỗi vòng, nó tính xem loss đổi ra sao khi nhích từng hệ số (gradient), dời hệ số một bước ngược chiều đó, rồi lặp lại tới khi loss gần như không giảm nữa. Hồi quy tuyến tính có công thức tính thẳng. Logistic regression và mạng nơ-ron thì không, nên chúng học hệ số bằng vòng lặp này hay một biến thể của nó; các model như cây quyết định học theo cách khác hẳn.
Cần biết trước: hồi quy tuyến tính và loss MSE, mảng NumPy và vòng lặp for.
Công thức: gradient và bước cập nhật
Với đường ŷ = w·x + b và loss MSE, gradient là hai con số cho biết MSE tăng nhanh tới đâu khi nhích w, nhích b lên một chút. Thành phần theo w:
Trong đó:
n (
len(x)): số điểm dữ liệu.x, y với chỉ số i (
x[i],y[i]): feature và giá trị thật của điểm thứ i.ŷ với chỉ số i (
w * x + b): giá trị đường thẳng đoán cho điểm đó.g_w (
g_w): gradient theo w.
Thành phần theo b giống hệt nhưng không nhân x: g_b = (2/n) · Σ (ŷᵢ − yᵢ). Mỗi bước, hệ số đi ngược dấu gradient một đoạn tỉ lệ với nó:
Trong đó lr (lr) là learning rate (tốc độ học), độ dài của mỗi bước; b cập nhật theo cùng cách với g_b. Gradient dương nghĩa là tăng w làm MSE tăng, nên w phải giảm. Cách các công thức này được rút ra từ đạo hàm, và phương trình chuẩn cho đáp án không cần lặp, nằm ở bài đạo hàm, gradient và phương trình chuẩn.
Tính tay một bước
Một app giao hàng ghi năm đơn: quãng đường 1, 2, 3, 4, 5 km, thời gian giao 12, 15, 21, 23, 29 phút. Bắt đầu từ w = b = 0 với lr = 0,01:
Bước | Việc | Kết quả |
|---|---|---|
1 | Đoán ŷ = 0 · x + 0 | 0 ở cả năm đơn |
2 | Lệch ŷ − y | −12; −15; −21; −23; −29 |
3 | Lệch nhân x, rồi cộng | −12 − 30 − 63 − 92 − 145 = −342 |
4 | g_w = 2/5 · (−342); g_b = 2/5 · (−100) | −136,8; −40 |
5 | w mới = 0 − 0,01 · (−136,8); b mới = 0 − 0,01 · (−40) | 1,368; 0,4 |
Khối dưới làm đúng các bước đó và in MSE trước, sau bước:
km = [1, 2, 3, 4, 5]
phut = [12, 15, 21, 23, 29]
w, b, lr, n = 0.0, 0.0, 0.01, len(km)
tong_w, tong_b, mse_truoc = 0, 0, 0
for x, y in zip(km, phut):
lech = w * x + b - y
tong_w += lech * x
tong_b += lech
mse_truoc += lech ** 2 / n
g_w, g_b = 2 / n * tong_w, 2 / n * tong_b
w, b = w - lr * g_w, b - lr * g_b
mse_sau = sum((w * x + b - y) ** 2 for x, y in zip(km, phut)) / n
print(round(g_w, 3), round(g_b, 3))
print(round(w, 3), round(b, 3))
print(round(mse_truoc, 3), round(mse_sau, 3))KẾT QUẢ
-136.8 -40.0
1.368 0.4
436.0 256.886Một bước đã kéo MSE từ 436 xuống 256,886. Cả hai gradient âm, nên w và b cùng tăng: đường đang đoán thấp hơn thực tế ở mọi đơn.
Mười dòng NumPy chạy cả nghìn bước
Viết lại bằng mảng NumPy thì một bước chỉ còn bốn dòng, và vòng for lặp nó bao nhiêu lần cũng được. Dòng cuối tính đường bình phương nhỏ nhất bằng công thức để so:
import numpy as np
km = np.array([1.0, 2, 3, 4, 5])
phut = np.array([12.0, 15, 21, 23, 29])
w, b, lr = 0.0, 0.0, 0.05
for buoc in range(1, 1001):
lech = w * km + b - phut
g_w, g_b = 2 * (lech * km).mean(), 2 * lech.mean()
w, b = w - lr * g_w, b - lr * g_b
if buoc in (1, 10, 100, 500, 1000):
mse = ((w * km + b - phut) ** 2).mean()
print(buoc, round(w, 3), round(b, 3), round(mse, 3))
dx, dy = km - km.mean(), phut - phut.mean()
w_dung = (dx * dy).sum() / (dx ** 2).sum()
b_dung = phut.mean() - w_dung * km.mean()
print("công thức:", round(w_dung, 3), round(b_dung, 3))KẾT QUẢ
1 6.84 2.0 21.01
10 5.553 2.516 5.062
100 4.492 6.347 0.922
500 4.2 7.399 0.72
1000 4.2 7.4 0.72
công thức: 4.2 7.4Sau 1.000 bước, gradient descent ra đúng w = 4,2 phút mỗi km và b = 7,4 phút, như công thức. Hai hệ số không về đích cùng lúc. Sau 10 bước, w đã ở 5,553, chỉ còn cách 4,2 khoảng 1,35; b mới tới 2,516, còn cách 7,4 gần 4,9. Tới bước 100, w lệch 0,29 còn b vẫn thiếu hơn 1. Đổi w, b, lr = 0.0, 0.0, 0.05 thành w, b, lr = 0.0, 0.0, 0.01 rồi chạy lại: tới bước 1000 vẫn chưa xong, dòng đó in 1000 4.254 7.204 0.727.
Xuất phát chỗ nào cũng về một đáy
Loss MSE của hồi quy tuyến tính chỉ có một chỗ thấp nhất, nên điểm xuất phát không đổi đáp án. Khối dưới lấy năm điểm xuất phát ngẫu nhiên và chạy cùng 1.000 bước:
import numpy as np
km = np.array([1.0, 2, 3, 4, 5])
phut = np.array([12.0, 15, 21, 23, 29])
rng = np.random.default_rng(3)
for _ in range(5):
w, b = rng.uniform(-50, 50, 2).tolist()
bat_dau = (round(w, 1), round(b, 1))
for buoc in range(1000):
lech = w * km + b - phut
g_w, g_b = 2 * (lech * km).mean(), 2 * lech.mean()
w, b = w - 0.05 * g_w, b - 0.05 * g_b
print(bat_dau, "->", round(w, 3), round(b, 3))KẾT QUẢ
(-41.4, -26.3) -> 4.2 7.4
(30.1, 8.2) -> 4.2 7.4
(-40.6, -6.7) -> 4.2 7.4
(-2.1, -34.0) -> 4.2 7.4
(23.5, -38.6) -> 4.2 7.4Lần chạy này, cả năm điểm xuất phát, có điểm cách đáp án hơn 40 đơn vị, đều về sát w = 4,2 và b = 7,4. Model phức tạp hơn có loss nhiều chỗ trũng, và điểm xuất phát khi đó đổi kết quả.
Đường loss theo vòng lặp
Cách thường dùng để theo dõi gradient descent là ghi MSE sau mỗi bước rồi vẽ:
import numpy as np
import matplotlib.pyplot as plt
km = np.array([1.0, 2, 3, 4, 5])
phut = np.array([12.0, 15, 21, 23, 29])
w, b, lich_su = 0.0, 0.0, []
for buoc in range(100):
lech = w * km + b - phut
g_w, g_b = 2 * (lech * km).mean(), 2 * lech.mean()
w, b = w - 0.05 * g_w, b - 0.05 * g_b
lich_su.append(((w * km + b - phut) ** 2).mean())
fig, ax = plt.subplots(figsize=(6.4, 4), layout="constrained")
ax.plot(range(1, 101), lich_su)
ax.set_title("MSE sau từng bước gradient descent, lr = 0,05")
ax.set(xlabel="Bước", ylabel="MSE (phút²)")
plt.show()Đường rơi thẳng đứng ở ba bước đầu rồi thoải dần: từ bước 10 tới bước 100, MSE chỉ giảm từ 5,06 xuống 0,92, và phần giảm đó gần như toàn nhờ b tiến dần về 7,4. Đường đi lên hay răng cưa là dấu hiệu learning rate quá lớn.
Kiểm tra nhanh
Sau
w, lr, g_w = 2.0, 0.1, -5.0,print(w - lr * g_w)in ra gì?1.52.5-3.0
Trong khung bẫy, lr = 0,1 cho MSE lên tới cỡ 10²⁹ sau 100 bước. Nên làm gì?
- Tăng số bước lên 1.000 để loss kịp giảm
- Giảm learning rate, ví dụ còn 0,01 hay 0,05
- Tăng learning rate để vượt qua chỗ nổ
Những câu nào đúng về gradient descent trên MSE của hồi quy tuyến tính?
- Gradient theo w dương thì bước cập nhật làm w giảm
- Learning rate quá nhỏ vẫn hội tụ, chỉ cần nhiều bước hơn
- Learning rate càng lớn thì càng về đáy nhanh
- Đổi điểm xuất phát thì đáp án w, b đổi theo
Sau
import numpy as npvàlech = np.array([-3.0, -5.0]),print(2 * lech.mean())in ra gì?-4.0-8.08.0
Bài tập
Ghi lại MSE sau từng bước gradient descent
x, y là hai list số cùng độ dài. Viết thân hàm lich_su_loss(x, y, lr, so_vong): chạy gradient descent cho đường ŷ = w·x + b, bắt đầu từ w = 0, b = 0, learning rate lr, đúng so_vong vòng cập nhật. Mỗi bước tính g_w, g_b từ w, b hiện tại rồi cập nhật cả hai cùng lúc. Sau mỗi lần cập nhật, tính MSE của đường mới và thêm vào kết quả.
Hàm không sửa x, y của nơi gọi.
Trả về: MSE sau từng bước theo thứ tự, một list.
Ví dụ với năm đơn của bài, lich_su_loss([1, 2, 3, 4, 5], [12, 15, 21, 23, 29], 0.01, 3) có phần tử đầu khoảng 256.886.
import numpy as np
def lich_su_loss(x, y, lr, so_vong):
pass # Viết thân hàm thay cho dòng nàyTóm tắt
Gradient descent dời mỗi hệ số một bước ngược dấu gradient của loss, lặp tới khi loss gần như không giảm.
Với MSE: g_w = (2/n) · Σ (ŷᵢ − yᵢ)·xᵢ, g_b là cùng tổng không nhân x.
Bước cập nhật là w − lr · g_w; w và b cập nhật cùng lúc từ cùng một gradient.
Learning rate quá lớn làm loss tăng vọt; quá nhỏ thì hội tụ chậm.
Trên hồi quy tuyến tính, gradient descent ra đúng hệ số của công thức bình phương nhỏ nhất.
Câu hỏi thường gặp
Learning rate bao nhiêu là tốt?
Không có một số dùng cho mọi bài, vì khoảng chạy được phụ thuộc thang đo của feature. Ghi năm đơn bằng mét thay cho km, x lớn gấp 1.000 lần, và chính lr = 0,01 làm w nổ tới cỡ 10¹⁰⁴ chỉ sau 20 bước. Thử vài giá trị cách nhau 10 lần (0,1; 0,01; 0,001), vẽ đường loss của mỗi giá trị, rồi giữ giá trị lớn nhất mà loss vẫn giảm đều; chuẩn hóa feature trước đó giúp một lr dùng được cho mọi cột.
Đã có công thức tính thẳng thì học gradient descent làm gì?
Chỉ một số ít model, như hồi quy tuyến tính và Ridge, có công thức giải thẳng, và trên bảng cực lớn công thức đó tốn bộ nhớ. Logistic regression hay mạng nơ-ron không có công thức nào, nên đều học bằng gradient descent hay biến thể của nó. Bài đạo hàm, gradient và phương trình chuẩn so hai cách.
scikit-learn có dùng gradient descent cho LinearRegression không?
Không. LinearRegression giải thẳng bài toán bình phương nhỏ nhất, nên không có learning rate hay số bước. Bài linear regression trong sklearn cho thấy nó ra cùng hệ số.
Khi nào dừng vòng lặp?
Dừng khi loss giữa hai bước gần như không đổi, hay sau một số bước tối đa đặt trước. Ở ví dụ năm đơn, từ bước 500 MSE đứng yên ở 0,72: chạy thêm chỉ tốn thời gian.
Chủ đề
Bài này có hữu ích?
Hỏi đáp
Tham vấn chuyên môn
Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE
- Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
- Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
- Xây hệ thống AI cho doanh nghiệp tại VietPlatform.