Mục lục#

• 1. Machine Learning và vị trí của Reinforcement Learning
• 2. Bài toán RL và mô hình MDP
• 3. Q‑learning nền tảng
• 4. Deep Q‑Network (DQN)
• 5. Hai kỹ thuật ổn định cốt lõi
• 6. Khám phá với (\varepsilon)-greedy
• 7. Quy trình huấn luyện DQN
• 8. Pseudocode tối giản
• 9. Biến thể quan trọng
• 10. Thực hành & siêu tham số gợi ý
• 11. Khi nào dùng/không dùng DQN
• 12. Bẫy thường gặp
• 13. Ứng dụng thực tế
• 14. Tài liệu tham khảo ngắn

1. Machine Learning và vị trí của Reinforcement Learning#

Machine Learning (ML) là nhánh của AI cho phép mô hình học từ dữ liệu/kinh nghiệm để đưa ra dự đoán hoặc quyết định. Ba nhánh lớn thường gặp:

• Supervised learning: có nhãn, tối ưu dự đoán $y$ từ $x$.
• Unsupervised learning: không nhãn, khám phá cấu trúc dữ liệu (clustering, giảm chiều, …).
• Reinforcement learning (RL): học từ tương tác với môi trường để tối đa hóa tổng phần thưởng chiết khấu.

DQN thuộc RL, giải quyết các tác vụ hành động rời rạc trên không gian trạng thái lớn (vd. ảnh Atari).

2. Bài toán RL và mô hình MDP#

Một tác tử (agent) tương tác với môi trường theo các bước thời gian $t=0,1,2,...$:

• quan sát trạng thái $s_t$,
• chọn hành động $a_t$,
• nhận phần thưởng $r_t$ và trạng thái mới $s_{t+1}$.

Mục tiêu là tối đa hóa

$G_t = \sum_{k=0}^{\infty} \gamma^k r_{t+k}, \quad 0 \leq \gamma < 1$

Bài toán thường mô hình là MDP (Markov Decision Process) với $(S, A, P, R, \gamma)$. Hai hàm giá trị quan trọng:

• Giá trị trạng thái: $V^\pi(s) = \mathbb{E}[G_t | s_t=s, \pi]$
• Giá trị hành động: $Q^\pi(s,a) = \mathbb{E}[G_t | s_t=s, a_t=a, \pi]$

3. Q‑learning nền tảng#

Q‑learning học trực tiếp $Q^*(s,a)$ thông qua phương trình tối ưu Bellman:

$Q^*(s,a) = \mathbb{E}[r + \gamma \max_{a'} Q^*(s',a') | s,a]$ Bản cổ điển dùng bảng (Q‑table) → không khả thi khi trạng thái lớn/ảnh.

4. Deep Q‑Network (DQN)#

Ý tưởng: thay Q‑table bằng mạng nơ‑ron $Q(s,a;\theta)$ để xấp xỉ $Q^*(s,a)$.

Mục tiêu học: khớp dự đoán với đích Bellman:

$y = r + \gamma (1-\text{done}) \max_{a'} Q(s', a'; \theta^-)$

trong đó $\theta$ là tham số mạng online, $\theta^-$ là tham số mạng target (cập nhật chậm).

Hàm mất mát (thường dùng Huber để ổn định):

$\mathcal{L}(\theta) = \mathbb{E}_{(s,a,r,s') \sim \mathcal{D}}[\text{Huber}(Q(s,a;\theta)-y)]$

5. Hai kỹ thuật ổn định cốt lõi#

1. Experience Replay: lưu mẫu $(s,a,r,s',\text{done})$ vào bộ đệm $\mathcal{D}$, lấy mini‑batch ngẫu nhiên để phá vỡ tương quan thời gian và tái sử dụng dữ liệu hiệu quả.
2. Target Network: sao chép định kỳ (cập nhật cứng) hoặc cập nhật mềm $\theta^- \leftarrow \tau\theta + (1-\tau)\theta^-$ nhằm cố định mục tiêu trong ngắn hạn → huấn luyện ổn định.

6. Khám phá với (\varepsilon)-greedy#

• Với xác suất $\varepsilon$, chọn hành động ngẫu nhiên (khám phá).
• Ngược lại, chọn $a=\arg\max_a Q(s,a;\theta)$ (khai thác).
• Giảm $\varepsilon$ dần (vd. 1.0 → 0.05) theo số bước huấn luyện.

7. Quy trình huấn luyện DQN#

1. Khởi tạo mạng Q online và Q target (cùng kiến trúc), $\theta^- \leftarrow \theta$.
2. Khởi tạo replay buffer $\mathcal{D}$.
3. Lặp qua các bước/episode:
   • Quan sát $s$; chọn $a$ theo $\varepsilon$-greedy.
   • Thực thi $a$ → nhận $r, s', \text{done}$; đẩy mẫu vào $\mathcal{D}$.
   • Lấy một mini‑batch từ $\mathcal{D}$; tính $y$ và tối ưu $\mathcal{L}(\theta)$ bằng SGD/Adam.
   • Mỗi $C$ bước, cập nhật target (cứng) hoặc dùng cập nhật mềm đều đặn.
   • Giảm $\varepsilon$ theo lịch khám phá.

8. Pseudocode tối giản#

# Khởi tạo
Q_online, Q_target = init_networks()
Q_target.load_state_dict(Q_online.state_dict())
replay = ReplayBuffer(capacity)
epsilon = 1.0

for t in range(total_steps):
    # Chọn hành động
    if random() < epsilon:
        a = random_action()
    else:
        a = argmax(Q_online(s))  # Q_online(s) -> Q cho mọi action

    s_next, r, done = env.step(a)
    replay.push(s, a, r, s_next, done)
    s = s_next if not done else env.reset()

    # Học khi đủ dữ liệu
    if len(replay) >= warmup and t % learn_every == 0:
        batch = replay.sample(batch_size)

        with torch.no_grad():
            q_next = Q_target(batch.s_next).max(dim=1).values
            y = batch.r + gamma * (1 - batch.done) * q_next

        q_sa = Q_online(batch.s).gather(1, batch.a.unsqueeze(1)).squeeze(1)
        loss = huber(q_sa - y)

        optimizer.zero_grad()
        loss.backward()
        clip_grad_norm_(Q_online.parameters(), 10.0)
        optimizer.step()

    # Cập nhật target định kỳ
    if t % target_update == 0:
        Q_target.load_state_dict(Q_online.state_dict())

    # Giảm epsilon
    epsilon = max(eps_min, eps_max - (eps_max - eps_min) * t / eps_decay_steps)

9. Biến thể quan trọng#

• Double DQN: giảm overestimation bias bằng cách chọn hành động tối ưu bằng mạng online nhưng đánh giá bằng mạng target:

$a^* = \arg\max_a Q(s',a;\theta), \quad y = r + \gamma (1-\text{done}) Q(s', a^*; \theta^-)$

• Dueling DQN: tách mạng thành Value $V(s)$ và Advantage $A(s,a)$, rồi kết hợp

$Q(s,a) = V(s) + \left(A(s,a) - \frac{1}{|A|}\sum_{a'} A(s,a')\right)$

• Prioritized Experience Replay (PER): ưu tiên mẫu có |TD‑error| lớn; dùng trọng số bù lệch (IS weights).
• Noisy Networks: thay $\varepsilon$-greedy bằng lớp tuyến tính có nhiễu để khám phá có điều khiển.
• N‑step returns: dùng $n$-bước để lan truyền tín hiệu thưởng nhanh hơn.
• Distributional DQN (C51), Quantile (QR‑DQN), Rainbow: kết hợp nhiều cải tiến để đạt hiệu năng cao.

10. Thực hành & siêu tham số gợi ý#

CartPole (trạng thái vector, 2 hành động):

• Mạng: MLP 2 tầng ẩn (128‑128, ReLU), đầu ra 2 giá trị $Q$.
• $\gamma=0.99$; batch=64; lr=1e-3; buffer=50k–200k;
• Bắt đầu học sau 1–5k bước; cập nhật target mỗi 500–2k bước;
• $\varepsilon$: 1.0 ↓ 0.05 trong ~100k bước; Huber loss, gradient clipping.

Atari (ảnh):

• Tiền xử lý: chuyển xám, resize 84×84, stack 4 khung.
• CNN 3 conv + 2 FC theo cấu hình DQN gốc; có thể reward clipping.

11. Khi nào dùng/không dùng DQN#

• Dùng: hành động rời rạc, quan sát lớn (ảnh/video), phần thưởng không quá khan hiếm.
• Không dùng: hành động liên tục (dùng DDPG/TD3/SAC), yêu cầu chính sách xác suất phức tạp.

12. Bẫy thường gặp#

• Bất ổn huấn luyện → dùng target network, replay, Huber loss, gradient clipping.
• Thiếu khám phá → kéo dài lịch giảm $\varepsilon$ hoặc dùng NoisyNet.
• Phần thưởng hiếm/ồn → n‑step, reward clipping/normalization, dueling.
• Overfitting buffer nhỏ → tăng kích thước $\mathcal{D}$, xáo trộn mạnh.

13. Ứng dụng thực tế#

• Chơi game (Atari), điều khiển (robot rời rạc), scheduling, tối ưu hoá chiến lược thử nghiệm, A/B testing động, hệ thống khuyến nghị có tương tác tuần tự (khi hành động rời rạc).

14. Tài liệu tham khảo ngắn#

• Mnih et al., 2015 – Human-level control through deep reinforcement learning (DQN).
• Hasselt et al., 2016 – Deep Reinforcement Learning with Double Q-learning (Double DQN).
• Wang et al., 2016 – Dueling Network Architectures for Deep RL (Dueling).
• Schaul et al., 2016 – Prioritized Experience Replay (PER).
• Hessel et al., 2018 – Rainbow: Combining Improvements in Deep RL.
• Sutton & Barto – Reinforcement Learning: An Introduction (sách giáo khoa).

Tài liệu tham khảo:

• DQN Paper - DeepMind
• OpenAI Spinning Up
• Sutton & Barto - RL Book

Chúc bạn thành công với Deep Q-Network! 🚀🤖