Bỏ qua đến nội dung chính
Mục lục

Gradient descent bằng NumPy: tự tìm hệ số hồi quy

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 2/10 · Chương 4

Hồi quy

  • 9 phút
  • Cơ bản
  • Python 3.14
  • Cập nhật

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:

gw=2n∑i=1n(y^i−yi) xig_w = \frac{2}{n}\sum_{i=1}^{n} (\hat{y}_i - y_i)\, x_i

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ó:

wnew=w−lr⋅gww_{\text{new}} = w - \text{lr} \cdot g_w

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:

python
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.886

Mộ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:

python
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.4

Sau 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:

python
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.4

Lầ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ẽ:

python
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()
Biểu đồ đường MSE theo 100 bước gradient descent; MSE rơi từ khoảng 21 ở bước 1 xuống gần 6 chỉ sau ba bước, rồi giảm chậm dần về gần 1 ở bước 100.

Đườ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

  1. Sau w, lr, g_w = 2.0, 0.1, -5.0, print(w - lr * g_w) in ra gì?

    • 1.5
    • 2.5
    • -3.0
  2. 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ổ
  3. 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
  4. Sau import numpy as np và lech = np.array([-3.0, -5.0]), print(2 * lech.mean()) in ra gì?

    • -4.0
    • -8.0
    • 8.0
Đúng hết lần đầu +15 XP

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.

python
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ày

Tó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ủ đề

gradient descent

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

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.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập