Chương D · dụng cụ tối ưu thực dụng — cùng họ với gradient trong RL

Khung 6 câu hỏi

🖼️ Hình nhanh: Mini-batch = nghe vài giây rồi vặn nút; lr quá lớn nổ, quá nhỏ bò.
```
Loss θ
│ full-batch ──► hướng mượt │ lr lớn: θ ↗︎↘︎↗︎↘︎ nổ
│ mini-batch ──► hướng ồn │ lr vừa: θ ──►★ hội tụ
│ │ lr nhỏ: θ ····· bò mãi
└──────────► θ

★ SGD: θ ← θ − α ∇L_batch(θ) RL: ascent trên E[R] nhưng ∇ rất ồn
```

🇻🇳 Chuyện thật (train policy phủ nhiều thửa): SGD giống đi xuống dốc trong sương — mỗi bước chỉ nhìn một mảng địa hình (mini-batch), không phải cả bản đồ loss.
Train policy phủ nhiều thửa chè: batch hôm nay là vài map/gió; \(\alpha\) quá lớn thì nhảy khỏi thung lũng hội tụ, quá nhỏ thì bò hết budget mẫu.
Chốt: trước khi đổ lỗi kiến trúc, hãy hỏi learning rate và scale reward — cùng một nút thắt với deep RL. ../00C.

Hình minh họa (seminar-ready)

Hình gốc hoặc minh họa cho ebook — không cắt từ slide Princeton. Dùng Present: bật Slide · F toàn màn.

0. Mục tiêu học

1. Giải thích vì sao dùng mini-batch thay full-batch.
2. Nhận biết hậu quả learning rate quá lớn / quá nhỏ trên đường đi của \(\theta\).
3. Phân biệt nhiễu gradient supervised với nhiễu gradient RL.
4. Có checklist debug “học không ra” trước khi đổ lỗi kiến trúc mạng / thuật toán RL.
5. Biết momentum / Adam ở mức dùng (không cần chứng minh hội tụ).

1. Trực giác

Chỉnh radio: không cần nghe cả album mới vặn nút. Nghe vài giây → vặn nhẹ → nghe tiếp.
SGD: mỗi bước chỉ dùng một mini-batch, cập nhật

\[ \theta \leftarrow \theta - \alpha \nabla_\theta \mathcal{L}_{\text{batch}}(\theta). \]

Full-batch giống nghe hết album rồi mới vặn một cái — chính xác theo loss toàn tập nhưng đắt và đôi khi cứng nhắc. Mini-batch ồn, nhưng ồn đó thường giúp thoát vùng xấu và thực tế chạy được.

Tìm đáy thung lũng trong sương cũng cùng hình: mỗi bước chỉ nhìn vài tảng đá gần chân (batch) thay vì khảo sát cả thung lũng.

Với RL bạn đã biết: mỗi rollout chỉ là một mẫu quỹ đạo — gradient còn ồn hơn supervised rất nhiều. Bài này nhắc lại dụng cụ chung để bạn không “đổi PPO↔SAC” khi thật ra chỉ cần giảm lr mười lần.

2. Cốt lõi + sơ đồ

2. Cốt lõi + sơ đồ

2.1. Full-batch vs mini-batch

Dữ liệu / rollouts
        │
        ▼
   lấy batch B  ──►  ∇L_B(θ) ≈ ∇L(θ) + (~ nhiễu)
        │
        ▼
   θ ← θ − α · ∇L_B     (hoặc +α với policy gradient)
        │
        ▼
   log loss / return ──► chỉnh α, batch size, schedule

2. Cốt lõi + sơ đồ

2.2. Learning rate và họ tối ưu

  η quá lớn:  nhảy loạn   /\/\/\/\     loss/reward nổ hoặc NaN
  η vừa:      hội tụ      ~~~~★
  η quá nhỏ:  bò mãi      _________.-   tưởng “thuật toán kém”

2. Cốt lõi + sơ đồ

2.3. Liên hệ RL

Policy gradient / actor-critic cũng là gradient trên kỳ vọng return, nhưng ước lượng ồn hơn nhiều (credit assignment, non-i.i.d., non-stationarity). Cần baseline, advantage normalization, GAE, clip (PPO), v.v. — cùng tinh thần giảm phương sai ước lượng gradient.

Lr policy quá lớn → giật giống controller \(K_p\) lớn (Lec 3). Đừng nhầm “loss” của metaheuristic path-planning với SGD trên mạng — ngôn ngữ gần nhưng cơ chế khác.

3. Demo — SGD nhiễu vs lr lớn/nhỏ

"""
Demo Lec20: tối ưu E[(θ - 3)^2]/2 bằng SGD 1-mẫu.
So sánh 3 learning rate trên cùng seed nhiễu.
Thêm: batch lớn hơn → std gradient nhỏ hơn (ít ồn).
"""
import numpy as np

def run_sgd(lr, steps=40, seed=0):
    rng = np.random.default_rng(seed)
    theta = 0.0
    hist = [theta]
    for _ in range(steps):
        y = 3.0 + 0.5 * rng.normal()   # một mẫu quanh mục tiêu 3
        grad = (theta - y)             # d/dθ của 0.5 (θ-y)^2
        theta = theta - lr * grad
        hist.append(theta)
    return np.asarray(hist)

for lr in (0.05, 0.3, 1.5):
    h = run_sgd(lr)
    print(f"lr={lr:>4}: θ_cuối={h[-1]:7.3f} | max|θ|={np.max(np.abs(h)):7.3f} | "
          f"đường đi [::8]={np.round(h[::8], 2)}")

# So sánh nhiễu: trung bình nhiều bước vs một bước đơn
rng = np.random.default_rng(1)
grads = []
theta = 1.0
for _ in range(32):
    y = 3.0 + 0.5 * rng.normal()
    grads.append(theta - y)
print("std grad 1-mẫu ≈", round(float(np.std(grads)), 3))
print("std grad mean-8 ≈", round(float(np.std(
    [np.mean(grads[i:i+8]) for i in range(0, 32, 8)])), 3))
print("→ Batch lớn hơn → gradient ít ồn hơn (hướng gần full-batch).")

🧪 Kỳ vọng demo:
- lr=0.3: \(\theta\) tiến gần 3, dao động nhẹ.
- lr=0.05: tiến chậm hơn, chưa tới 3 sau 40 bước.
- lr=1.5: |θ| lớn / dao động mạnh (nổ hoặc lệch xa).
- std của mean-8 nhỏ hơn 1-mẫu — đúng tinh thần mini-batch vs noise.

4. Gắn RL–UAV

• Sample inefficiency của RL đến một phần từ gradient ồn + dữ liệu không i.i.d.
• Khi debug học không ra: kiểm tra lr, scale reward/advantage, độ dài rollout, normalize obs — trước khi đổ lỗi kiến trúc mạng.
• So hai thuật toán phải cùng budget mẫu / cùng số gradient step công bằng.
• Đa mục tiêu (năng lượng, phủ, mượt, gió): scale từng hạng tử reward khác nhau = “lr hiệu dụng” khác nhau trên từng hướng tín hiệu.
• PPO/SAC cũng là SGD (hoặc biến thể) trên objective surrogate — chọn \(\alpha\) vẫn là nút thắt.

5. Ưu / nhược

6. Lỗi thường gặp

1. Đổi thuật toán RL liên tục trong khi lr/reward scale đang vỡ.
2. So sánh hai thuật toán với budget mẫu khác nhau rồi kết luận “thuật toán A hơn”.
3. Lr detector và lr policy head lệch nhau mà không tách nhóm tham số.
4. Quên normalize advantage / obs → lr “đúng trên giấy” vẫn nổ.
5. Early stopping theo train return thay vì held-out (sang Lec 21).
6. Batch size = 1 luôn trên mạng lớn → gradient quá ồn, không kết luận được gì.

7. Checklist

1. Vì sao dùng mini-batch thay full-batch?
2. Adam khác SGD thuần ở ý tưởng nào?
3. Vì sao gradient RL thường ồn hơn supervised?
4. Ba việc kiểm tra trước khi đổi PPO→SAC?
5. Vẽ nhanh (bằng lời) đường \(\theta(t)\) khi lr quá lớn / quá nhỏ.
6. Trong reward đa mục tiêu, hạng tử nào đang “át” gradient?

⚡ Nhớ một câu: Mini-batch đổi độ chính xác lấy tốc độ; lr sai thì thuật toán nào cũng ngu — sửa lr trước khi đổi tên method.

🔗 Sang bài sau mang theo: Hội tụ trên train chưa đủ — Lec 21 phân biệt overfit và domain gap (sim↔real, gió, map).

Trước: Lec19 — Deep Learning Vision · Sau: Lec21 — Overfitting