Bài 27: Gradient Descent — cách AI "học" bằng cách đi xuống dốc

Sau bài học, bạn sẽ:

• Hiểu gradient descent (GD) là thuật toán đi ngược hướng gradient để giảm loss.
• Viết được update rule \( \theta \leftarrow \theta - \eta \nabla L(\theta) \) và giải thích từng ký hiệu.
• Biết vai trò của learning rate \( \eta \) và 3 chế độ: quá nhỏ / quá lớn / vừa.
• Phân biệt 3 biến thể chính: Batch GD, Stochastic GD (SGD), Mini-batch GD.
• Nhận diện local minima, saddle point và biết vì sao DL thực tế ổn với "cực tiểu đủ tốt".
• Tự viết GD bằng Python thuần để minimize \( f(x) = x^2 \) và cho linear regression đơn giản.
• Hiểu liên hệ giữa GD và backpropagation — chain rule cho phép áp GD cho mọi network sâu.

Đây là bài kết của Module 3 — Toán nền tảng cho AI. Bài 25 cho bạn đạo hàm, bài 26 cho bạn loss function. Bài 27 ghép 2 mảnh đó lại thành thuật toán mà mọi model ML/DL hiện đại đều dùng để "học".

Ba bài cuối Module 3 (25 → 27) là một chuỗi logic chặt:

• Bài 25 (Đạo hàm): với hàm nhiều biến \( f(\theta_1, \ldots, \theta_n) \), gradient \( \nabla f \) là vector các đạo hàm riêng, chỉ về hướng \( f \) tăng nhanh nhất.
• Bài 26 (Loss function): đặt một hàm \( L(\theta) \) đo "model sai bao nhiêu". Bài toán training rút gọn thành: tìm \( \theta \) để \( L(\theta) \) nhỏ nhất.
• Bài 27 (bài này): dùng \( \nabla L \) để cập nhật \( \theta \) lặp lại — đó là gradient descent. Đây chính là "việc học" của model.

Có thể coi training như câu hỏi: nếu tôi đang ở điểm \( \theta \) trên "bản đồ" loss, đi theo hướng nào và bước dài bao nhiêu để loss giảm nhanh? GD trả lời: đi theo \( -\nabla L(\theta) \), bước dài tỉ lệ \( \eta \).

Lưu ý quan trọng: GD không hứa hẹn tìm được global minimum. Nó chỉ giảm loss qua từng bước; điểm dừng phụ thuộc loss surface, \( \eta \), và điểm khởi tạo. Trong DL hiện đại, đây là "đủ tốt" trên phần lớn bài toán.

Hình dung bạn đứng trên một quả đồi trong sương mù dày đặc. Tầm nhìn chỉ vài bước chân. Mục tiêu: xuống thung lũng (chỗ thấp nhất). Bạn không thấy bản đồ toàn cảnh, chỉ cảm nhận được độ dốc dưới chân.

Chiến lược hợp lý nhất:

1. Quan sát hướng dốc nhất đi xuống ngay dưới chân.
2. Bước một bước vừa phải theo hướng đó.
3. Đứng lại, quan sát hướng mới, bước tiếp.
4. Lặp đến khi mặt đất phẳng — gần như chắc chắn bạn đang ở một thung lũng.

Đó chính xác là gradient descent. "Độ dốc dưới chân" = gradient. "Hướng xuống dốc nhất" = \( -\nabla L \). "Bước vừa phải" = learning rate \( \eta \). "Mặt đất phẳng" = gradient gần 0.

Bản đồ tương ứng trong ML:

• Vị trí của bạn ↔ giá trị hiện tại của tham số \( \theta \).
• Độ cao ↔ loss \( L(\theta) \).
• Thung lũng ↔ tham số tối ưu \( \theta^\star \) tại đó loss thấp nhất.
• Sương mù ↔ ta không có công thức tường minh của loss surface; chỉ tính được giá trị và gradient tại điểm hiện tại.

    L(θ)
     ^
     |  *                           *
     |   \                         /
     |    *                       *
     |     \         η ↘        /
     |      *  →  →  →  →  →  *
     |       \               /
     |        *   --(local min)--   *
     |         \               /
     |          *  ---global min--- *
     +-----------------------------------> θ

Mỗi mũi tên là một iteration (bước cập nhật). Bước to hay nhỏ phụ thuộc \( \eta \). Bước nhanh hơn về phía đáy khi dốc lớn (gradient lớn), chậm lại khi gần đáy (gradient nhỏ).

Gọn lại từ Bài 25. Với hàm loss \( L(\theta) \) phụ thuộc vector tham số \( \theta = (\theta_1, \theta_2, \ldots, \theta_n) \), gradient của \( L \) là:

\[ \nabla L(\theta) = \left( \frac{\partial L}{\partial \theta_1}, \; \frac{\partial L}{\partial \theta_2}, \; \ldots, \; \frac{\partial L}{\partial \theta_n} \right) \]

Ký hiệu \( \nabla \) đọc là "nabla". Tính chất cốt lõi của gradient mà GD khai thác:

• Tại \( \theta \), \( \nabla L(\theta) \) là vector chỉ về hướng \( L \) tăng nhanh nhất.
• Vector \( -\nabla L(\theta) \) chỉ về hướng \( L \) giảm nhanh nhất.
• Độ lớn \( \|\nabla L(\theta)\| \) là tốc độ thay đổi tối đa của \( L \) khi rời điểm \( \theta \).
• Tại điểm cực trị (min / max / yên ngựa), \( \nabla L = \mathbf{0} \).

Đây là vector cùng số chiều với \( \theta \). Một model DL có thể có hàng trăm triệu tham số — gradient cũng có ngần ấy thành phần. Việc tính \( \nabla L \) cho cả mạng được làm bằng backpropagation (xem mục 12).

Công thức trung tâm của bài:

\[ \theta \leftarrow \theta - \eta \, \nabla L(\theta) \]

Trong đó:

• \( \theta \) — vector tham số hiện tại (weight, bias).
• \( \nabla L(\theta) \) — gradient của loss tại điểm hiện tại. Tính bằng giải tích, autograd, hoặc finite difference.
• \( \eta \) (eta) — learning rate, số thực dương, quyết định độ dài bước.
• \( \leftarrow \) — phép gán: thay \( \theta \) cũ bằng kết quả vế phải.

Mỗi lần áp dụng công thức này gọi là một iteration (bước lặp) hoặc step. Một epoch là một lượt đi qua toàn bộ dataset training — sẽ có bao nhiêu step trong 1 epoch tuỳ vào batch size (xem mục 10).

Pseudo-code chung:

khởi tạo θ (ngẫu nhiên hoặc theo scheme)
lặp lại:
    tính L(θ) và ∇L(θ) trên dữ liệu
    θ ← θ - η · ∇L(θ)
cho đến khi đạt điều kiện dừng (mục 8)

Trực giác: dấu trừ trước \( \eta \nabla L \) phản ánh "đi ngược hướng tăng" = "đi xuống". Nếu gradient lớn, bước cập nhật lớn. Nếu gradient nhỏ (gần đáy), bước nhỏ — GD tự động "giảm tốc khi gần đích".

Bài toán mẫu đơn giản nhất, làm trên giấy: minimize \( f(x) = x^2 \). Đạo hàm \( f'(x) = 2x \). Update rule:

\[ x \leftarrow x - \eta \cdot 2x = (1 - 2\eta) \, x \]

Chọn \( x_0 = 5 \), \( \eta = 0.1 \). Mỗi bước, \( x \) bị nhân với \( 1 - 2 \cdot 0.1 = 0.8 \):

step  x
0     5.0000
1     4.0000   (= 5 × 0.8)
2     3.2000
3     2.5600
4     2.0480
5     1.6384
...
20    0.0577
30    0.0066
50    0.0001

\( x \) hội tụ về 0 (chỗ \( f \) thấp nhất). Quan sát đáng nhớ:

• Bước đầu giảm rất nhanh: \( |x| \) lớn ⇒ gradient \( 2x \) lớn ⇒ bước cập nhật lớn.
• Càng về sau bước càng nhỏ — đường tiệm cận về 0, không chạm đúng 0 trong thời gian hữu hạn.
• Hệ số co \( (1 - 2\eta) = 0.8 \) chính là "tốc độ hội tụ" của bài toán này.

Thử với \( \eta = 0.5 \): hệ số co thành \( 1 - 1 = 0 \). \( x \) nhảy về 0 trong đúng 1 bước. \( \eta = 0.5 \) là "tốt nhất" cho bài này — nhưng thực tế ta không biết hằng số đó cho mọi bài.

Thử với \( \eta = 1.0 \): hệ số co \( = -1 \). \( x \) đổi dấu mỗi bước, độ lớn không đổi — không hội tụ. Thử \( \eta = 1.5 \): hệ số co \( = -2 \). \( x \) phóng ra vô cực, oscillating, divergence. Mục 7 sẽ tổng quát hoá.

\( \eta \) là hyperparameter — không học được từ data, phải tự chọn. Đây là tham số mà bạn sẽ điều chỉnh nhiều nhất khi training.

Ba chế độ tiêu biểu:

• \( \eta \) quá nhỏ: bước cập nhật bé, loss giảm rất chậm. Mất hàng chục nghìn iteration mới đến gần đáy. Lãng phí GPU.
• \( \eta \) vừa: loss giảm nhanh, ổn định, hội tụ. Đây là vùng "vàng".
• \( \eta \) quá lớn: mỗi bước nhảy vọt qua đáy, có thể oscillation (dao động hai bên đáy) hoặc divergence (loss tăng dần, model "phát nổ" — loss trở thành NaN).

loss
  ^
  |  * η quá nhỏ: bò chậm
  |    \_
  |      \____________________
  |
  |  * η vừa: giảm mượt
  |    \
  |     \__
  |        \___________
  |
  |  * η quá lớn: oscillation hoặc bay
  |     /\  /\  /\
  |    /  \/  \/  \________
  +-------------------------> iteration

Giá trị khởi đầu hay thử:

• \( 10^{-3} \) — mặc định an toàn cho nhiều bài DL (Adam dùng \( 10^{-3} \) làm default).
• \( 10^{-4} \) — khi model lớn / fine-tune.
• \( 10^{-2} \) — khi bài toán nhỏ, gradient được normalize tốt.

Quy trình thực dụng để chọn \( \eta \):

1. Bắt đầu \( \eta = 10^{-3} \). Train vài trăm step, xem loss.
2. Nếu loss tăng / NaN: giảm \( \eta \) đi 10 lần.
3. Nếu loss giảm quá chậm: tăng \( \eta \) lên 3–10 lần.
4. Plot loss theo step trên log scale. Đường loss nên đi xuống "mượt", không dao động mạnh.

Learning rate schedule: trong thực tế ta thường giảm dần \( \eta \) khi training tiến triển — đầu để loss giảm nhanh, cuối để tinh chỉnh. Các scheme phổ biến: step decay, cosine annealing, warmup + decay. Sẽ gặp lại ở Series 3 (Deep Learning).

GD là vòng lặp — phải có điều kiện dừng. Một số chuẩn hay dùng, áp dụng riêng lẻ hoặc kết hợp:

• Số iteration cố định: chạy đúng \( N \) bước (ví dụ 10.000 step) rồi dừng. Đơn giản, hay dùng trong DL.
• Norm của gradient nhỏ: dừng khi \( \|\nabla L(\theta)\| < \varepsilon \) (ví dụ \( \varepsilon = 10^{-6} \)). Lý thuyết đẹp — \( \nabla L = 0 \) là điều kiện cần của cực trị. Hay dùng trong tối ưu cổ điển.
• Loss thay đổi rất ít: dừng khi \( |L_{t} - L_{t-1}| < \varepsilon \) trong vài bước liên tiếp. "Loss không giảm thêm được nữa".
• Early stopping: theo dõi loss trên validation set. Dừng khi val-loss không cải thiện sau \( k \) epoch (gọi là patience). Đây là chuẩn DL thực tế — vừa tiết kiệm thời gian vừa chống overfitting.

Hội tụ về đâu? Phụ thuộc hình dạng \( L \):

• Loss là hàm lồi (convex), ví dụ MSE cho linear regression: với \( \eta \) đủ nhỏ, GD hội tụ về global minimum.
• Loss không lồi (DL gần như luôn vậy): GD chỉ đảm bảo về một điểm dừng (\( \nabla L \approx 0 \)) — có thể là local min, saddle point, hoặc thậm chí một "plateau" rất rộng.

Tại bất kỳ điểm dừng nào \( \nabla L(\theta) = 0 \). Có 3 loại điểm dừng:

• Global minimum: điểm thấp nhất trên toàn bộ loss surface. Đích lý tưởng.
• Local minimum: điểm thấp cục bộ: loss thấp hơn mọi điểm xung quanh, nhưng vẫn cao hơn global min ở nơi khác.
• Saddle point (điểm yên ngựa): đi theo một hướng thì giảm, hướng khác thì tăng. Gradient = 0 nhưng không phải min cũng không phải max.

    L(θ)
     ^
     |     local min            global min
     |        v                     v
     |    *_______*           *_______*
     |   /         \         /         \
     |  /           \_______/           \____
     +-----------------------------------> θ

  Saddle point (chiều dọc giảm, chiều ngang tăng):

     L(θ₁, θ₂)
     ^
     |   ngang: tăng    ngang: tăng
     |        \              /
     |     ____*___saddle___*____
     |        /              \
     |   dọc: giảm       dọc: giảm

Trong tối ưu hoá cổ điển 1–2 chiều, local minima là vấn đề lớn. Trong DL với hàng triệu chiều, có 2 điều thú vị mà nghiên cứu (Choromanska et al. 2015, Dauphin et al. 2014) chỉ ra:

• Local minima trong loss surface của neural network đa số xấp xỉ nhau về loss — chênh lệch không lớn so với global min. Hội tụ vào local min "đủ tốt" thường chấp nhận được.
• Vấn đề lớn hơn là saddle point: ở chiều cao thì số lượng saddle nhiều gấp bội local minima, và gradient gần saddle rất nhỏ — GD bị "chậm lại".

Đây là một trong những lý do các optimizer dùng momentum (mục 11) — chúng "có quán tính" để vượt qua saddle. Tổng kết: DL thực tế thường ổn với local min đủ tốt; nỗi sợ "kẹt local min" trong nhập môn bị thổi phồng so với thực nghiệm.

Câu hỏi: dùng bao nhiêu dữ liệu để ước lượng \( \nabla L(\theta) \) trước mỗi update? Loss thật là trung bình trên toàn bộ \( N \) mẫu của dataset:

\[ L(\theta) = \frac{1}{N} \sum_{i=1}^{N} \ell(\theta; \, x_i, y_i) \]

Tương ứng, \( \nabla L = \frac{1}{N} \sum_i \nabla \ell_i \). Ba cách lấy mẫu:

Batch Gradient Descent

• Mỗi update dùng toàn bộ dataset để tính gradient.
• Ưu: gradient chính xác, hội tụ ổn định, ít noise.
• Nhược: rất chậm với dataset lớn; bộ nhớ cần để chứa toàn bộ dataset có thể không khả thi.
• Thực tế: hầu như không dùng cho DL hiện đại.

Stochastic Gradient Descent (SGD)

• Mỗi update dùng 1 mẫu duy nhất, chọn ngẫu nhiên.
• Update rule: \( \theta \leftarrow \theta - \eta \, \nabla \ell(\theta; x_i, y_i) \).
• Ưu: cập nhật nhanh, ít bộ nhớ. Noise trong gradient ước lượng giúp model thoát saddle / local min nông.
• Nhược: gradient noisy, đường loss dao động mạnh; khó tận dụng vectorization trên GPU.

Mini-batch Gradient Descent

• Mỗi update dùng một batch nhỏ gồm \( B \) mẫu (ví dụ \( B = 32, 64, 128, 256 \)).
• Update rule: \( \theta \leftarrow \theta - \eta \cdot \frac{1}{B} \sum_{i \in \text{batch}} \nabla \ell_i \).
• Cân bằng tốt: gradient đủ chính xác, đủ noise để thoát local min nông, tận dụng được GPU.
• Đây là chuẩn thực tế. Khi tài liệu DL nói "SGD" thì thường họ ngầm hiểu là mini-batch.

Quy tắc kinh nghiệm về batch size:

• 32 / 64 / 128 cho training thông thường.
• 256 / 512 / 1024 cho training trên GPU lớn — tăng throughput.
• Batch quá lớn có thể giảm chất lượng generalization (Keskar et al. 2017): mất noise có ích.

GD trần (vanilla GD) là điểm khởi đầu lý thuyết. Trong thực tế, optimizer hay dùng là các biến thể tinh chỉnh hơn. Hai cái cần biết tên ngay:

Momentum

Ý tưởng: giữ "đà" của các bước trước, không phụ thuộc 100% vào gradient hiện tại. Giúp đi nhanh hơn theo hướng "đồng thuận" và bỏ qua dao động ngắn hạn. Update rule (đơn giản):

\[ v \leftarrow \beta v + \nabla L(\theta), \qquad \theta \leftarrow \theta - \eta v \]

\( v \) là vector vận tốc, \( \beta \) (thường 0.9) là hệ số "ma sát". Giống bóng lăn xuống dốc: có quán tính, vượt được các đoạn dốc nhẹ và saddle.

Adam (Adaptive Moment Estimation)

Kingma & Ba 2014 (arXiv:1412.6980). Kết hợp:

• Momentum: lưu trung bình trượt của gradient (moment bậc 1).
• Adaptive learning rate: lưu trung bình trượt của bình phương gradient (moment bậc 2). Tham số nào có gradient liên tục lớn thì bị giảm \( \eta \) hiệu dụng — tự cân bằng.

Hyperparameter mặc định trong PyTorch / TensorFlow: \( \eta = 10^{-3} \), \( \beta_1 = 0.9 \), \( \beta_2 = 0.999 \), \( \epsilon = 10^{-8} \). Adam là default lựa chọn đầu tiên cho phần lớn bài DL hiện đại.

Các họ hàng đáng nhớ: RMSProp (chỉ moment bậc 2), AdamW (Adam + weight decay đúng cách — chuẩn trong huấn luyện LLM hiện đại, Loshchilov & Hutter 2017), SGD with Nesterov momentum. Chi tiết để dành cho Series 3.

GD cần \( \nabla L(\theta) \). Với một mạng neural sâu, \( \theta \) gồm hàng triệu (đến hàng trăm tỉ với LLM) tham số. Tính từng đạo hàm riêng bằng tay là bất khả thi. Lời giải là backpropagation (Rumelhart, Hinton, Williams 1986) — về bản chất chính là chain rule (Bài 25, mục 8) áp dụng đệ quy.

Một mạng \( L \) lớp có dạng hàm hợp:

\[ \hat{y} = f_L(f_{L-1}(\cdots f_1(\mathbf{x}; \theta_1) \cdots ; \theta_{L-1}); \theta_L) \]

Loss là một hàm của \( \hat{y} \) và label \( y \). Để tính \( \frac{\partial L}{\partial \theta_k} \) cho mọi \( k \), backprop làm 2 pass:

• Forward pass: tính tuần tự \( f_1, f_2, \ldots, f_L, L \). Lưu lại các giá trị trung gian.
• Backward pass: dùng chain rule, đi ngược từ \( L \) về đầu, lan truyền "tín hiệu" \( \frac{\partial L}{\partial \hat{y}} \to \frac{\partial L}{\partial f_{L-1}} \to \ldots \to \frac{\partial L}{\partial \theta_k} \).

Chi phí tính toàn bộ gradient bằng backprop chỉ tốn khoảng 2 lần chi phí một forward pass — không phụ thuộc số tham số. Đó là điểm mấu chốt khiến training network có hàng tỉ tham số trở nên khả thi.

Trong PyTorch / TensorFlow, bạn không tự viết backprop. Framework xây computation graph khi bạn viết forward pass; gọi loss.backward() (PyTorch) hoặc dùng tf.GradientTape (TensorFlow) sẽ tự tính \( \nabla L \). Sau đó optimizer (SGD, Adam, …) áp update rule. Toàn bộ "phép màu" training thu gọn lại trong 3 dòng:

loss = loss_fn(model(x_batch), y_batch)   # forward
loss.backward()                            # backward (chain rule tự động)
optimizer.step()                           # GD update: θ ← θ - η · ∇L

Hiểu phương trình \( \theta \leftarrow \theta - \eta \nabla L(\theta) \) là hiểu đáy của 3 dòng code đó. Mọi thứ phía trên (transformer, diffusion, RLHF...) chỉ là cách tạo ra \( L \) và \( \theta \) phong phú hơn.

Implementation gradient descent đơn giản nhất, dùng float thuần — chưa cần NumPy (Bài 28 trở đi).

# Bài toán: minimize f(x) = x^2
# Đạo hàm: f'(x) = 2x
# Update rule: x ← x - eta * 2x


def f(x):
    return x ** 2


def grad_f(x):
    return 2.0 * x


def gradient_descent(x0, eta, n_steps):
    """Trả về list giá trị x qua các step."""
    x = x0
    history = [x]
    for _ in range(n_steps):
        x = x - eta * grad_f(x)
        history.append(x)
    return history


# Thử 3 learning rate khác nhau
for eta in [0.01, 0.1, 0.5, 1.1]:
    hist = gradient_descent(x0=5.0, eta=eta, n_steps=30)
    print(f"eta = {eta:>4}:  x_0 = {hist[0]:.4f},  "
          f"x_10 = {hist[10]:.4f},  x_30 = {hist[30]:.4f}")

Output (rút gọn):

eta = 0.01:  x_0 = 5.0000,  x_10 = 4.0954,  x_30 = 2.7448     # hội tụ chậm
eta =  0.1:  x_0 = 5.0000,  x_10 = 0.5369,  x_30 = 0.0062     # hội tụ nhanh, mượt
eta =  0.5:  x_0 = 5.0000,  x_10 = 0.0000,  x_30 = 0.0000     # hội tụ trong 1 step (đặc biệt)
eta =  1.1:  x_0 = 5.0000,  x_10 = 38.6798, x_30 = 2304.69    # divergence — bay khỏi đáy

Quan sát:

• \( \eta = 0.01 \): bước quá nhỏ, 30 step mới giảm từ 5 về 2.7.
• \( \eta = 0.1 \): điển hình cho \( \eta \) tốt — giảm nhanh, mượt.
• \( \eta = 0.5 \): trùng "best step size" cho bài toán này.
• \( \eta = 1.1 \): vượt ngưỡng, \( |x| \) tăng theo cấp số nhân — divergence.

Bài toán: dữ liệu \( (x_i, y_i) \), tìm \( w, b \) sao cho \( \hat{y}_i = w x_i + b \) gần \( y_i \). Loss MSE (Bài 26):

\[ L(w, b) = \frac{1}{N} \sum_{i=1}^{N} (w x_i + b - y_i)^2 \]

Đạo hàm riêng:

\[ \frac{\partial L}{\partial w} = \frac{2}{N} \sum_i x_i (w x_i + b - y_i), \qquad \frac{\partial L}{\partial b} = \frac{2}{N} \sum_i (w x_i + b - y_i) \]

Áp dụng GD đồng thời cho cả 2 tham số:

# Linear regression GD với 1 feature
# Dataset: y ~ 2x + 1 + noise nhẹ
xs = [1.0, 2.0, 3.0, 4.0, 5.0]
ys = [3.1, 4.9, 7.2, 8.8, 11.1]


def predict(w, b, x):
    return w * x + b


def mse_loss(w, b, xs, ys):
    n = len(xs)
    return sum((predict(w, b, x) - y) ** 2 for x, y in zip(xs, ys)) / n


def gradients(w, b, xs, ys):
    """Trả về (dL/dw, dL/db)."""
    n = len(xs)
    dw = 0.0
    db = 0.0
    for x, y in zip(xs, ys):
        err = predict(w, b, x) - y
        dw += 2.0 * x * err
        db += 2.0 * err
    return dw / n, db / n


def train(eta=0.01, n_steps=2000):
    w, b = 0.0, 0.0   # khởi tạo
    for step in range(n_steps):
        dw, db = gradients(w, b, xs, ys)
        w = w - eta * dw
        b = b - eta * db
        if step % 200 == 0:
            loss = mse_loss(w, b, xs, ys)
            print(f"step {step:>4}: w={w:.4f}, b={b:.4f}, loss={loss:.6f}")
    return w, b


w_final, b_final = train()
print(f"\nKết quả: w ≈ {w_final:.4f}, b ≈ {b_final:.4f}")
print(f"Kỳ vọng: w ≈ 2.0, b ≈ 1.0")

Output điển hình:

step    0: w=0.1408, b=0.0420, loss=55.382000
step  200: w=2.0531, b=0.7902, loss=0.041183
step  400: w=2.0184, b=0.9159, loss=0.019920
step  600: w=2.0070, b=0.9573, loss=0.017022
step  800: w=2.0033, b=0.9710, loss=0.016702
step 1000: w=2.0021, b=0.9755, loss=0.016668
step 1200: w=2.0017, b=0.9770, loss=0.016664
step 1400: w=2.0015, b=0.9775, loss=0.016664
step 1600: w=2.0015, b=0.9776, loss=0.016664
step 1800: w=2.0014, b=0.9776, loss=0.016664

Kết quả: w ≈ 2.0014, b ≈ 0.9777
Kỳ vọng: w ≈ 2.0, b ≈ 1.0

\( w \) hội tụ về ~2, \( b \) về ~0.98 — khớp với "luật" sinh dữ liệu \( y \approx 2x + 1 \). Loss giảm từ ~55 xuống ~0.017 và đứng — đây là phần "noise" không giảm thêm được. Đây chính là chuẩn của linear regression by gradient descent, viết tay 100%.

1. Với code ở mục 13, thử các giá trị \( \eta \in \{0.001, \; 0.05, \; 0.3, \; 0.99\} \). Với mỗi giá trị, ghi lại số step để \( |x| < 10^{-4} \) (hoặc ghi "không hội tụ"). Vẽ kết luận.
2. Viết GD cho hàm \( f(x) = (x - 3)^2 + 1 \). Đạo hàm là gì? Khởi đầu \( x_0 = 0 \), \( \eta = 0.1 \), chạy 30 step. \( x \) hội tụ về đâu? Giá trị nhỏ nhất của \( f \) là bao nhiêu?
3. Linear regression cho dataset 5 điểm tự đặt (ví dụ "y phụ thuộc x kiểu giá nhà theo diện tích"). Viết GD như mục 14. Quan sát \( w, b \) hội tụ.
4. Thử dùng SGD cho mục 14: mỗi step chỉ chọn ngẫu nhiên 1 mẫu trong 5 mẫu để tính gradient. So sánh đường loss với batch GD: noisy hơn nhưng vẫn hội tụ về cùng vùng.
5. Cho hàm \( f(x) = x^4 - 3x^2 + 2 \). Tính \( f'(x) \) và tìm các điểm dừng. GD từ \( x_0 = 0.1 \), \( x_0 = 2.0 \), \( x_0 = -2.0 \) hội tụ về đâu? Hiện tượng gì xảy ra?

• Gradient descent: tối thiểu hoá \( L(\theta) \) bằng vòng lặp \( \theta \leftarrow \theta - \eta \nabla L(\theta) \).
• \( \nabla L \) chỉ hướng tăng nhanh nhất; \( -\nabla L \) chỉ hướng giảm nhanh nhất.
• Learning rate \( \eta \) quyết định độ dài bước. Quá nhỏ ⇒ chậm. Quá lớn ⇒ oscillation / divergence. Khởi đầu thử \( 10^{-3} \), điều chỉnh theo loss curve.
• Stopping criteria: số iteration cố định, \( \|\nabla L\| < \varepsilon \), \( |\Delta L| < \varepsilon \), hoặc early stopping theo validation loss.
• Điểm dừng có thể là global min, local min, hoặc saddle point. DL trong thực tế thường ổn với local min "đủ tốt".
• 3 biến thể theo lượng dữ liệu mỗi update: Batch (toàn bộ), SGD (1 mẫu), Mini-batch (batch nhỏ — chuẩn thực tế, B = 32/64/128/256).
• Optimizer thực tế: Momentum (giữ đà), Adam (momentum + adaptive \( \eta \), default DL hiện đại).
• Backpropagation = chain rule áp dụng đệ quy để tính \( \nabla L \) cho mọi tham số. Chi phí chỉ ~2× forward pass.
• 3 dòng code DL chuẩn: loss.backward() tính \( \nabla L \), optimizer.step() áp update GD, optimizer.zero_grad() reset cho iteration sau.

Module 3 (Toán) kết thúc tại đây. Bài 28 mở Module 4 — NumPy, công cụ tính toán vector / ma trận / tensor thực tế thay cho list thuần đã dùng trong các bài Module 3.