Phase 09: Reinforcement Learning

अभिनेता-आलोचक ए2सी और ए3सी

Type: Build

Languages: Python

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

Time: ~75 minutes

समस्या

वैनिला रिइंफोर्स काम करता है, लेकिन इसके भिन्नता भयानक है.G_tएपिसोड के बीच 10 गुणा स्विच कर सकते हैं।∇ log πऔर औसत एक ग्रेडिएंट अनुमानक बनाता है जो नीति को उसी दूरी पर ले जाने के लिए हजारों एपिसोड लेता है जिसे आप इसे बहुत कम डीक्यूएन अपडेट के साथ ले जा सकते हैं।

अंतर कच्चे रिटर्न का उपयोग करने से आता है. यदि आप एक मूल रेखा को घटाते हैं b(s_t) किसी भी स्थिति के कार्य, एक सीखा मूल्य सहित उम्मीद अपरिवर्तित है और भिन्नता गिरती है। सबसे अच्छा व्यवहार्य आधार रेखा है V̂(s_t)अब मात्रा गुणा∇ log πयह लाभ हैः

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

एक कार्रवाई अच्छी है यदि यह औसत से ऊपर रिटर्न उत्पन्न करती है; खराब है यदि नीचे। एक शिक्षित आलोचक के साथ REINFORCE अभिनेता-आलोचक है। आलोचक अभिनेता को एक कम-वियरिएंस शिक्षक देता है। यह 2015 के बाद हर गहरी नीति पद्धति है (ए 2 सी, ए 3 सी, पीपीओ, एसएसी, इम्पला) ।

अवधारणा

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

Two networks, one shared loss:

• Actor π_θ(a | s)नीतिगत ढांचे के साथ प्रशिक्षित।
• Critic V_φ(s): अनुमानों राज्य से अपेक्षित वापसी. न्यूनतम करने के लिए प्रशिक्षित (V_φ(s) - target)². .

The advantage.दो मानक फॉर्मः

• MC लाभA_t = G_t - V_φ(s_t)निष्पक्ष, उच्च भिन्नता।
• टीडी लाभA_t = r_{t+1} + γ V_φ(s_{t+1}) - V_φ(s_t). पूर्वाग्रह (उपयोग V_φ), बहुत कम भिन्नता। इसे TD अवशिष्ट भी कहा जाता है।δ_t. .

n-step advantage.इन दोनों के बीच अंतर करेंः

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

n = 1शुद्ध टीडी है। n = ∞अधिकांश कार्यान्वयन n = 5अत्तारी के लिए, n = 2048MuJoCo पर पीपीओ के लिए.

Generalized Advantage Estimation (GAE).Schulman et al. (2016) ने सभी n-चरण लाभों पर एक घातीय रूप से भारित औसत प्रस्तावित कियाः

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

के साथλ ∈ [0, 1]. .λ = 0TD (कम भिन्नता, उच्च पूर्वाग्रह) है। λ = 1MC (उच्च भिन्नता, निष्पक्ष) है। λ = 0.952026 डिफ़ॉल्ट ट्यून है जब तक पूर्वाग्रह / भिन्नता डायल आप चाहते हैं जहां यह है।

A2C: synchronous advantage actor-critic.इकट्ठा करें Tपार कदम Nसमानांतर वातावरण. प्रत्येक चरण के लिए लाभ गणना. अभिनेता और आलोचक को संयुक्त बैच पर अद्यतन. दोहराएं. सरल, अधिक स्केलेबल भाई A3C.

A3C: asynchronous advantage actor-critic.Mnih et al. (2016). Spawn Nप्रत्येक कार्यकर्ता अपने स्वयं के रोलआउट पर स्थानीय रूप से ग्रेडिएंट की गणना करता है, फिर उन्हें एक साझा पैरामीटर सर्वर पर असिंक्रोनस रूप से लागू करता है। कोई रिप्ले बफर की आवश्यकता नहीं है श्रमिक विभिन्न पटरियों को चलाने से डिकोरेरेरेटेड करते हैं। ए 3 सी ने साबित किया कि आप पैमाने पर सीपीयू पर प्रशिक्षण दे सकते हैं। 2026 में, जीपीयू-आधारित ए 2 सी (बैच्ड समानांतर एनवीएस) हावी है क्योंकि जीपीयू बड़े बैच चाहते हैं।

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

तीन शर्तेंः पॉलिसी-ग्रेडिएंट हानि, मूल्य प्रतिगमन, एंट्रोपी बोनस। c_v ~ 0.5,c_e ~ 0.01वे कैनोनिक प्रारंभिक बिंदु हैं।

इसे बनाओ

चरण 1: आलोचक

रैखिक आलोचक V_φ(s) = w · features(s)एमएसई के साथ अद्यतन किया गयाः

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

एक तालिकात्मक वातावरण पर आलोचक कुछ सौ एपिसोड में एक साथ आते हैं। अत्तारी पर, सीएनएन साझा ट्रंक + मूल्य हेड के साथ रैखिक आलोचक को प्रतिस्थापित करें।

चरण 2: n-चरण लाभ

लंबाई की एक रोलआउट को देखते हुए Tऔर एक बूटस्ट्रैप फाइनल 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

returnsयह महत्वपूर्ण लक्ष्य है।advantagesजो गुणा करता है ∇ log π. .

चरण 3: संयुक्त अद्यतन

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]

नीति पर, प्रति अद्यतन एक रोलआउट, अभिनेता और आलोचक के लिए अलग सीखने की दरें।

चरण 4: समानांतर (A3C बनाम A2C)

• A3C:घूम Nहर एक अपने स्वयं के एनवी और अपने स्वयं के आगे पास चलाता है. आवधिक रूप से एक साझा मास्टर के लिए ग्रेडिएंट अपडेट धक्का. कोई ताला मास्टर पर दौड़ ठीक है, वे सिर्फ शोर जोड़ते हैं.
• A2C:दौड़नाNएक प्रक्रिया में उदाहरणों को शामिल करें, एक प्रक्रिया में अवलोकनों को स्टैक करें।[N, obs_dim]बैच, बैच फॉरवर्ड पास, बैच बैकवर्ड पास उच्च जीपीयू उपयोग, निर्धारक, तर्क करने में आसान। 2026 में डिफ़ॉल्ट।

हमारे खिलौना कोड स्पष्टता के लिए एकल-तार है; बैच ए 2 सी में फिर से लिखना तीन पंक्तियों का है।

फंदे

• Critic bias before actor gradient.यदि आलोचक यादृच्छिक है, तो इसकी आधार रेखा अनसूचनात्मक है और आप शुद्ध शोर पर प्रशिक्षण कर रहे हैं। नीति ग्रेडिएंट को चालू करने से पहले आलोचक को कुछ सौ चरणों के लिए गर्म करें, या धीमी अभिनेता सीखने की दर का उपयोग करें।
• Advantage normalization.प्रति बैच शून्य-औसत/एकीकृत-स्टडी के लिए लाभ सामान्यीकरण। लगभग शून्य लागत पर बड़े पैमाने पर प्रशिक्षण को स्थिर करता है।
• Shared trunk.छवि इनपुट पर अभिनेता और आलोचक के लिए साझा सुविधा निकालने का उपयोग करें। अलग सिर। साझा सुविधाएं दोनों नुकसान पर फ्री-राइड हैं।
• On-policy contract.A2C एक अद्यतन के लिए डेटा को पुनः उपयोग करता है। अधिक और आपका ग्रेडिएंट पक्षपातपूर्ण है (महत्व-सैंपलिंग सुधार वह है जो PPO जोड़ता है) ।
• Entropy collapse.बिनाc_e > 0, नीति कुछ सौ अद्यतन के बाद लगभग निर्धारक हो जाता है और खोज बंद कर देता है।
• Reward scale.लाभ परिमाण पुरस्कार पैमाने पर निर्भर करते हैं। कार्यों के बीच लगातार ग्रेडिएंट परिमाण के लिए पुरस्कारों (जैसे, रनिंग-एसटीडी विभाजन) को सामान्य बनाएं।

इसका प्रयोग करें

A2C/A3C शायद ही कभी 2026 में अंतिम विकल्प हैं लेकिन वे वास्तुकला हैं जो बाद में सब कुछ परिष्कृत करता हैः

यदि आप 2026 के पेपर में "लाभ" देखते हैं, तो अभिनेता-निरोधक के बारे में सोचें।

इसे भेजें

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.

व्यायाम

1. Easy.एमसी लाभ के साथ अभिनेता-आलोचक को प्रशिक्षित करें (G_t - V(s_t)4. पाठ 06 से रीइंफोर्स-के साथ-चलन-मध्यम-आधार रेखा के साथ नमूना दक्षता की तुलना करें।
2. Medium.टीडी-अवशिष्ट लाभ पर स्विच करें (r + γ V(s') - V(s)) लाभ बैचों के अंतर को मापें। यह कितना गिरता है?
3. Hard.GAE (GAE) को लागू करें।λ ∈ {0, 0.5, 0.9, 0.95, 1.0}. प्लॉट अंतिम रिटर्न बनाम नमूना दक्षता. इस कार्य के लिए पूर्वाग्रह/वियरिएंस का सबसे अच्छा बिंदु कहां है?

प्रमुख शर्तें

आगे पढ़ना

• Mnih et al. (2016). Asynchronous Methods for Deep Reinforcement Learning ए३सी, मूल असिनक्रॉन अभिनेता-आलोचक पेपर।
• Schulman et al. (2016). High-Dimensional Continuous Control Using Generalized Advantage Estimation जीएई।
• Sutton & Barto (2018). Ch. 13 — Actor-Critic Methods नींव; इस के साथ जोड़ा Ch. 9 पर कार्य अनुमान जब आलोचक एक तंत्रिका जाल है।
• Espeholt et al. (2018). IMPALA V-trace नीति से बाहर सुधार के साथ स्केलेबल वितरित अभिनेता-आलोचक।
• OpenAI Baselines / Stable-Baselines3 उत्पादन A2C/PPO कार्यान्वयन पढ़ना लायक है।
• Konda & Tsitsiklis (2000). Actor-Critic Algorithms दो-समय-स्तर के अभिनेता-आलोचनात्मक विघटन के लिए मौलिक अभिसरण परिणाम।

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.