Phase 09: Reinforcement Learning

Aktör-Kritik A2C ve A3C

Type: Build

Languages: Python

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

Time: ~75 minutes

Sorun

Vanilla REINFORCE işe yarıyor ama farkı korkunç.G_tBu sesleri 10 katına çarparak çarpıyor.∇ log πve ortalama bir gradient tahmincisi üretir. Bu politikaları daha az DQN güncellemeleri ile taşıyabileceğiniz mesafeyi taşımak için binlerce bölüm alıyor.

Değişiklik çiğ geri dönüş kullanılarak ortaya çıkar.b(s_t) öğrenilen bir değer de dahil olmak üzere herhangi bir durum fonksiyonu beklenti değişmez ve varyansa düşer. En iyi ele alınan temel çizgi V̂(s_t)Şimdi miktar çarpı.∇ log π avantaj:

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

Bir eylem ortalama üzerinde bir getiri üretirse iyi olur; aşağıda ise kötüdür. Öğrenmiş bir eleştirmen ile REINFORCE actor-critic. eleştirmen, aktörü düşük değişkenlik öğretmeni yapar. Bu 2015'ten sonra tüm derin politika yöntemleri (A2C, A3C, PPO, SAC, IMPALA).

Anlaşım

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

Two networks, one shared loss:

• Actor π_θ(a | s)Politikası. Yürümeye örneklenmiş. Politikası derecesi ile eğitilmiş.
• Critic V_φ(s)Bu nedenle, bu durumun en az bir şekilde azaltılması için eğitilmiştir.(V_φ(s) - target)²- Evet .

The advantage.İki standart form:

• MC avantajı: A_t = G_t - V_φ(s_t)Tarafsız, daha yüksek bir değişim.
• TD avantajı: A_t = r_{t+1} + γ V_φ(s_{t+1}) - V_φ(s_t). Tarafsız (kullanımlar V_φTD geri kalanı olarak da adlandırılır.δ_t- Evet .

n-step advantage.İkisi arasında bir arada dur:

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

n = 1saf TD.n = ∞MC'dir. Çoğu uygulamada kullanılır n = 5Atari için,n = 2048MuJoCo'da PPO için.

Generalized Advantage Estimation (GAE).Schulman et al. (2016) tüm n-adım avantajları üzerinde eksponensel olarak ağırlanan bir ortalama önerdi:

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

• Evet .λ ∈ [0, 1]- Evet .λ = 0TD ( düşük değişkenlik, yüksek önyargı). λ = 1MC (yüksek farklılık, tarafsızlık)λ = 0.952026'da, öntanımlı ayarı, öntanımlı/varians diyalığı istediğiniz yere kadar.

A2C: synchronous advantage actor-critic.Toplayın .TDönüşümler NParalel ortamlar. Her adım için avantajlar hesaplayın. Birleştirilmiş seri için aktör ve eleştirmeni güncelleyin. Tekrarla.

A3C: asynchronous advantage actor-critic.Mnih et al. (2016). Spawn Nİşçi ipleri, her biri bir çevre çalıştırır. Her işçi kendi dağıtımında yerel olarak gradientleri hesaplar, sonra eşzamanlı olarak paylaşılan bir parametre sunucusuna uyguluyor. Hiçbir tekrarlama tamponu gerekmez işçiler farklı yörüngeler çalıştırarak dekorrele. A3C ölçekte CPU'larda eğitim alabileceğini kanıtladı. 2026'da, GPU tabanlı A2C (batched parallel envs) baskın çünkü GPU'lar büyük partiler istiyor.

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))]

Üç şart: politika derecesi kaybı, değer gerileme, entropi bonusu. c_v ~ 0.5- Evet .c_e ~ 0.01Kanonik başlangıç noktalarıdır.

Yapın

Adım 1: eleştirmen

Düzsel eleştirmenV_φ(s) = w · features(s)MSE ile güncelleştirilmiştir:

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

Bir tablo ortamında eleştirmen birkaç yüz bölümde bir araya gelir. Atari'de, çizgisi eleştirmeni CNN'in paylaşılan bir çekirdek + değer başlığı ile değiştirin.

Adım 2: N-adım avantajı

Uzunluktan dolayı .TVe bir de bir final.V(s_T)- ...

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

returnseleştirmen hedef.advantages- Çokluyor.∇ log π- Evet .

Adım 3: birleşik güncelleme

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]

Politikada, her güncelleme için bir çıkış, aktör ve eleştirmen için ayrı öğrenme oranları.

Adım 4: paralellik (A3C vs. A2C)

• A3C:Çekil NHer biri kendi env ve kendi ileri geçişini yürütür. Periodik olarak gradient güncelleştirmeleri paylaşılmış bir usta.
• A2C:ÇıkışNTek bir süreçte örnekler oluşturmak, gözlemleri bir [N, obs_dim]Batch, batch forward pass, batch backward pass daha yüksek GPU kullanımı, belirleyici, akıl yürütmek daha kolay.

Oyuncak kodumuz netlik için tek iplik; A2C'ye yeniden yazmak üç satır numpy.

Tuzaklar

• Critic bias before actor gradient.Eğer eleştirmen rastgele ise, temel çizgisi bilgilendirici değil ve saf gürültü üzerinde eğitim veriyorsunuz.
• Advantage normalization.Parçaya sıfır ortalama/birlik std'ye avantajları normalleştirir.
• Shared trunk.Görüntü girişlerinde oyuncu ve eleştirmen için ortak bir özellik çıkarıcı kullanın. Ayrı başlar. Paylaşılan özellikler her iki kayıpta da serbest sürüş.
• On-policy contract.A2C, verileri tam bir güncelleme için tekrar kullanır. Daha fazla ve gradiyenti tarafsızdır (PPO'nun eklediği önemlilik örneği düzeltmesidir).
• Entropy collapse.- Hayır .c_e > 0Bu politika birkaç yüz güncelleme ile neredeyse belirlenmiş hale gelir ve araştırmayı bırakır.
• Reward scale.Avantaj büyüklükleri ödül ölçeğine bağlıdır. Görevler arasında tutarlı gradient büyüklükleri için ödülleri (örneğin, çalıştırma-std bölüşmesi) normallaştırın.

Kullan

A2C/A3C 2026'da nadiren son seçimdir ama sonraları en iyi yapılan mimarlıklardır:

2026'da bir makalede "kalah" görürseniz, oyuncu eleştirmeni düşünün.

Gönder

• Kaydet .outputs/skill-actor-critic-trainer.md- ...

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.

Egzersizler

1. Easy.MC avantajı olan aktör-kritik tren (G_t - V(s_t)Örnek verimliliğini ders 06'tan REINFORCE-with-running-mean baseline ile karşılaştırın.
2. Medium.TD-salı avantajına geçiş (r + γ V(s') - V(s)En iyisi, avantaj partilerinin farkını ölçmek.
3. Hard.GAE'yi uygula.λ ∈ {0, 0.5, 0.9, 0.95, 1.0}Bu görevin önyargısı/varians tatlı noktası nerede?

Anahtar Terimler

Daha Fazla Okumak

• Mnih et al. (2016). Asynchronous Methods for Deep Reinforcement Learning A3C, orijinal asynk aktör-kritik kağıdı.
• Schulman et al. (2016). High-Dimensional Continuous Control Using Generalized Advantage Estimation GAE.
• Sutton & Barto (2018). Ch. 13 — Actor-Critic Methods Temeller; eleştirmen bir sinir ağı olduğunda fonksiyon yaklaşımıyla ilgili 9. bölüm ile eşleştirin.
• Espeholt et al. (2018). IMPALA V- izleme politika dışı düzeltme ile ölçeklenebilir dağıtılı aktör eleştirmen.
• OpenAI Baselines / Stable-Baselines3 üretim A2C/PPO uygulamaları okumaya değer.
• Konda & Tsitsiklis (2000). Actor-Critic Algorithms iki katlı aktör-kritik parçalanma için temel bir yakınlaşma sonucu.

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.