Phase 09: Reinforcement Learning

Đánh giá diễn viên A2C và A3C

Type: Build

Languages: Python

Prerequisites: Phase 9 · 04 (TD Learning), Phase 9 · 06 (REINFORCE)

Time: ~75 minutes

Vấn đề

Vanilla ReINFORCE có hiệu quả, nhưng sự khác biệt của nó là khủng khiếp.G_tcó thể dao động qua một nhân tố 10 giữa các tập.∇ log πvà trung bình tạo ra một ước tính gradient mất hàng ngàn tập để di chuyển chính sách cùng khoảng cách bạn có thể di chuyển nó với nhiều hơn cập nhật DQN.

Sự khác biệt xuất phát từ việc sử dụng các lợi nhuận nguyên liệu. Nếu bạn trừ một đường cơ bản b(s_t) bất kỳ hàm nào của trạng thái, bao gồm cả một giá trị được học kỳ vọng không thay đổi và sự biến đổi giảm.V̂(s_t)Bây giờ số lượng nhân∇ log πlà lợi thế:

A(s, a) = G - V̂(s)

Một hành động là tốt nếu nó tạo ra lợi nhuận trên mức trung bình; xấu nếu dưới. REINFORCE với một nhà phê bình học tập là actor-critic. Nhà phê bình cho diễn viên một giáo viên biến thể thấp. Đây là mọi phương pháp chính sách sâu sắc sau năm 2015 (A2C, A3C, PPO, SAC, IMPALA).

Khái niệm

!Actor-critic: policy net plus value net, TD residual as advantage

Two networks, one shared loss:

• Actor π_θ(a | s)Các nhà nghiên cứu đã được đào tạo để làm việc.
• Critic V_φ(s): ước tính dự kiến thu hồi từ nhà nước.(V_φ(s) - target)²- Tôi không biết.

The advantage.Hai mẫu tiêu chuẩn:

• Lợi thế MC: A_t = G_t - V_φ(s_t)Không thiên vị, sự khác biệt cao hơn.
• Lợi thế TD: A_t = r_{t+1} + γ V_φ(s_{t+1}) - V_φ(s_t). Nhận định (sử dụng)V_φ), sự biến động thấp hơn nhiều.δ_t- Tôi không biết.

n-step advantage.Chuyển đổi giữa hai:

A_t^{(n)} = r_{t+1} + γ r_{t+2} + … + γ^{n-1} r_{t+n} + γ^n V_φ(s_{t+n}) - V_φ(s_t)

n = 1là TD tinh khiết. n = ∞là MC. Hầu hết các thực hiện sử dụng n = 5cho Atari, n = 2048cho PPO trên MuJoCo.

Generalized Advantage Estimation (GAE).Schulman et al. (2016) đề xuất một trung bình cân nặng theo tỷ lệ theo số lượng lớn trên tất cả các lợi thế của n- bước:

A_t^{GAE} = Σ_{l=0}^{∞} (γλ)^l δ_{t+l}

với λ ∈ [0, 1]- λ = 0là TD (varian thấp, thiên vị cao). λ = 1là MC (trang độ cao, không thiên vị). λ = 0.95là âm thanh mặc định 2026 cho đến khi số số bias / biến số là nơi bạn muốn nó.

A2C: synchronous advantage actor-critic.Thu thậpTbước qua NCác môi trường song song tính lợi thế cho mỗi bước cập nhật diễn viên và nhà phê bình trên loạt kết hợp lặp lại.

A3C: asynchronous advantage actor-critic.Mnih et al. (2016). Spawn NCác work thread, mỗi người chạy một env. Mỗi worker tính toán gradient tại địa phương trên bản triển khai của riêng mình, sau đó áp dụng chúng theo cách không đồng bộ cho một máy chủ tham số chia sẻ. Không cần bộ đệm lặp lại nhân viên giải khớp bằng cách chạy các quỹ đạo khác nhau. A3C chứng minh bạn có thể đào tạo trên CPU ở quy mô. Năm 2026, A2C dựa trên GPU (batched parallel envs) thống trị vì GPUs muốn các lô lớn.

The combined loss.

L(θ, φ) = -E[ A_t · log π_θ(a_t | s_t) ] + c_v · E[(V_φ(s_t) - G_t)²] - c_e · E[H(π_θ(·|s_t))]

Ba điều khoản: lỗ theo mức chính sách, sự lùi giá trị, tiền thưởng entropy. c_v ~ 0.5- c_e ~ 0.01là các điểm khởi đầu theo luật pháp.

Hãy xây dựng nó

Bước 1: một nhà phê bình

Nhận xét tuyến tínhV_φ(s) = w · features(s)được cập nhật với MSE:

pythonCopydef critic_update(w, x, target, lr):
    v_hat = dot(w, x)
    err = target - v_hat
    for j in range(len(w)):
        w[j] += lr * err * x[j]
    return v_hat

Trên một bảng xếp hạng, nhà phê bình hội tụ trong vài trăm tập. trên Atari, thay thế nhà phê bình tuyến tính bằng một shared CNN trunk + value head.

Bước 2: lợi thế n- bước

Với một sự triển khai dài Tvà một trận chung kết không được khởi động V(s_T)- Có thể là:

pythonCopydef compute_advantages(rewards, values, gamma=0.99, lam=0.95, last_value=0.0):
    advantages = [0.0] * len(rewards)
    gae = 0.0
    for t in reversed(range(len(rewards))):
        next_v = values[t + 1] if t + 1 < len(values) else last_value
        delta = rewards[t] + gamma * next_v - values[t]
        gae = delta + gamma * lam * gae
        advantages[t] = gae
    returns = [a + v for a, v in zip(advantages, values)]
    return advantages, returns

returnslà mục tiêu của những người phê bình.advantageslà điều nhân lên.∇ log π- Tôi không biết.

Bước 3: cập nhật kết hợp

pythonCopyfor step_i, (x, a, _r, probs) in enumerate(traj):
    adv = advantages[step_i]
    target_v = returns[step_i]

    # critic
    critic_update(w, x, target_v, lr_v)

    # actor
    for i in range(N_ACTIONS):
        grad_logpi = (1.0 if i == a else 0.0) - probs[i]
        for j in range(N_FEAT):
            theta[i][j] += lr_a * adv * grad_logpi * x[j]

Chính sách, một lần phát hành mỗi bản cập nhật, tỷ lệ học tập riêng biệt cho diễn viên và nhà phê bình.

Bước 4: Phối tương đồng (A3C vs A2C)

• A3C:quay lên Nmỗi bộ chạy bản xoay của riêng mình và thông qua phía trước của riêng mình. định kỳ đẩy cập nhật gradient để một chủ shared. Không khóa trên chủ đua là ok, họ chỉ thêm tiếng ồn.
• A2C:chạyNEnv các trường hợp trong một quá trình, xếp các quan sát thành một [N, obs_dim]Lượng lớn hơn, tính toán xác định, dễ lý luận hơn.

Mã đồ chơi của chúng tôi là một sợi đơn cho sự rõ ràng; viết lại cho A2C đúc là ba dòng numpy.

Những bẫy

• Critic bias before actor gradient.Nếu nhà phê bình là ngẫu nhiên, cơ sở của nó là không thông tin và bạn đang tập luyện trên tiếng ồn thuần túy. Đáp ấm nhà phê bình trong vài trăm bước trước khi bật gradient chính sách, hoặc sử dụng tốc độ học tập diễn viên chậm.
• Advantage normalization.Tiêu chuẩn hóa lợi thế cho số trung bình / đơn vị / std mỗi lô.
• Shared trunk.Sử dụng bộ thu thập tính năng chung cho diễn viên và nhà phê bình trên đầu vào hình ảnh. Đầu tách biệt. Các tính năng chung tự lái trên cả hai lỗ.
• On-policy contract.A2C sử dụng lại dữ liệu cho chính xác một bản cập nhật. Nhiều hơn và gradient của bạn bị thiên vị (chính xác lấy mẫu quan trọng là điều PPO thêm vào).
• Entropy collapse.Không cóc_e > 0, chính sách trở nên gần như quyết định trong vài trăm cập nhật và ngừng khám phá.
• Reward scale.Tầm quan trọng lợi thế phụ thuộc vào quy mô phần thưởng. bình thường hóa phần thưởng (ví dụ, chia run-std) cho độ lớn gradient phù hợp giữa các nhiệm vụ.

Sử dụng nó

A2C/A3C hiếm khi là lựa chọn cuối cùng vào năm 2026 nhưng chúng là kiến trúc mọi thứ sau đó tinh chỉnh:

Nếu bạn thấy "lợi thế" trong một bài báo năm 2026, hãy nghĩ đến nhà phê bình diễn viên.

Chuyển nó

Cứ như outputs/skill-actor-critic-trainer.md- Có thể là:

markdownCopy---
name: actor-critic-trainer
description: Produce an A2C / A3C / GAE configuration for a given environment, with advantage estimation and loss weights specified.
version: 1.0.0
phase: 9
lesson: 7
tags: [rl, actor-critic, gae]
---

Given an environment and compute budget, output:

1. Parallelism. A2C (GPU batched) vs A3C (CPU async) and the number of workers.
2. Rollout length T. Steps per env per update.
3. Advantage estimator. n-step or GAE(λ); specify λ.
4. Loss weights. `c_v` (value), `c_e` (entropy), gradient clip.
5. Learning rates. Actor and critic (separate if using).

Refuse single-worker A2C on environments with horizon > 1000 (too on-policy, too slow). Refuse to ship without advantage normalization. Flag any run with `c_e = 0` and observed entropy < 0.1 as entropy-collapsed.

Các bài tập

1. Easy.Đào tạo diễn viên-chính trị với lợi thế MC (G_t - V(s_t)So sánh hiệu quả mẫu với REINFORCE-with-running-median-baseline từ bài học 06.
2. Medium.Chuyển sang lợi thế TD-r + γ V(s') - V(s)(Điều 1 - 2): đo sự khác biệt của các lô lợi thế.
3. Hard.Thực hiện GAE ((λ).λ ∈ {0, 0.5, 0.9, 0.95, 1.0}Phản hồi cuối cùng của bản đồ so với hiệu quả mẫu.

Các điều khoản chính

Đọc thêm

• Mnih et al. (2016). Asynchronous Methods for Deep Reinforcement Learning A3C, bài báo phê bình diễn viên đồng bộ ban đầu.
• Schulman et al. (2016). High-Dimensional Continuous Control Using Generalized Advantage Estimation GAE.
• Sutton & Barto (2018). Ch. 13 — Actor-Critic Methods nền tảng; kết hợp điều này với chương 9 về việc gần gũi chức năng khi người phê bình là một mạng thần kinh.
• Espeholt et al. (2018). IMPALA có thể mở rộng phân phối các nhà phê bình diễn viên với sự sửa đổi ngoài chính sách theo dấu vết V.
• OpenAI Baselines / Stable-Baselines3 thực hiện A2C/PPO đáng đọc.
• Konda & Tsitsiklis (2000). Actor-Critic Algorithms kết quả hội tụ cơ bản cho sự phân hủy hai thang điểm diễn viên-nhân trọng.

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.