पाइथन के साथ एआई सीखें · पाठ

Policy Gradient विधियाँ: REINFORCE

Policy gradient प्रमेय, REINFORCE algorithm, baseline subtraction और variance reduction।

पाठ 1, कुल 4 में से13 चरण

Policy Gradient विधियाँ: REINFORCE, CoddyKit पर पाइथन के साथ एआई सीखें का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह पाइथन के साथ एआई सीखें सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। पाइथन के साथ एआई सीखें पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

मूल्य-आधारित बनाम Policy-आधारित RL

कुछ RL विधियाँ actions के मूल्य को सीखती हैं और फिर लालची ढंग से कार्य करती हैं। इसके बजाय पॉलिसी ग्रेडिएंट विधियाँ पॉलिसी को सीधे सीखती हैं: एक ऐसा function जो action probabilities output करता है। यह continuous actions और stochastic policies को स्वाभाविक रूप से संभालता है।

Policy pi(a|s)

एक पैरामीटरयुक्त पॉलिसी pi(a|s, theta) किसी state को actions पर प्रायिकता वितरण में बदलती है। इसके parameters theta एक neural network होते हैं। प्रशिक्षण theta को इस तरह समायोजित करता है कि अधिक reward देने वाले actions को प्राथमिकता मिले।

class Policy(nn.Module):
    def __init__(self, obs_dim, n_actions):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, 128), nn.ReLU(),
            nn.Linear(128, n_actions)
        )
    def forward(self, s):
        return torch.softmax(self.net(s), dim=-1)

Actions का नमूनाकरण

क्योंकि पॉलिसी एक वितरण होती है, इसलिए आप अधिकतम मान चुनने के बजाय कोई action sample करते हैं। नमूनाकरण exploration प्रदान करता है और पॉलिसी को stochastic बनाता है।

probs = policy(state)
dist = torch.distributions.Categorical(probs)
action = dist.sample()
log_prob = dist.log_prob(action)

Trajectory चलाना

एक episode (trajectory) आरंभ से अंत तक states, actions और rewards का क्रम होता है। आप environment में तब तक कार्य करके पूरी trajectory एकत्र करते हैं, जब तक वह समाप्त न हो जाए।

states, actions, rewards, log_probs = [], [], [], []
state, _ = env.reset()
done = False
while not done:
    probs = policy(torch.tensor(state).float())
    dist = torch.distributions.Categorical(probs)
    a = dist.sample()
    state, r, term, trunc, _ = env.step(a.item())
    rewards.append(r); log_probs.append(dist.log_prob(a))
    done = term or trunc

Discounted Return G_t

प्रतिफल G_t समय t से मिलने वाला कुल future reward होता है, जिसे gamma से discount किया जाता है ताकि निकट के rewards को अधिक महत्व मिले। यह बताता है कि step t से आगे किए गए actions कितने अच्छे सिद्ध हुए।

def returns(rewards, gamma=0.99):
    G, out = 0, []
    for r in reversed(rewards):
        G = r + gamma * G
        out.insert(0, G)
    return torch.tensor(out)

REINFORCE का उद्देश्य

REINFORCE अपेक्षित प्रतिफल पर ग्रेडिएंट आरोहण करता है। सहज रूप से समझें: अधिक प्रतिफल देने वाली क्रियाओं की प्रायिकता बढ़ाएँ और कम प्रतिफल देने वाली क्रियाओं की घटाएँ। प्रत्येक क्रिया का भार उसके G_t से निर्धारित होता है।

नीति ग्रेडिएंट

हानि -sum(log_prob * G_t) है। ऋण चिह्न ग्रेडिएंट आरोहण को अवरोहण में बदल देता है, इसलिए अनुकूलक प्रतिफल को अधिकतम करता है। अधिक प्रतिफल वाली क्रियाओं की लॉग-प्रायिकता बढ़ाई जाती है।

G = returns(rewards)
loss = -torch.sum(torch.stack(log_probs) * G)

नीति को अद्यतन करना

पश्चप्रसार करें और सामान्य रूप से step चलाएँ। एक अद्यतन में पूरा अनुभव-पथ उपयोग होता है, फिर उसे हटा दिया जाता है (REINFORCE वर्तमान नीति पर आधारित है: केवल वर्तमान नीति से मिले डेटा का उपयोग होता है)।

optimizer.zero_grad()
loss.backward()
optimizer.step()

उच्च विचरण की समस्या

साधारण REINFORCE अत्यंत अस्थिर और उच्च-विचरण वाला है: अलग-अलग एपिसोडों में प्रतिफल बहुत बदलते हैं, इसलिए ग्रेडिएंट के अनुमान शोरयुक्त होते हैं और सीखना धीमा तथा अनियमित रहता है।

विचरण घटाने के लिए आधाररेखा

G_t से एक आधाररेखा (जैसे औसत प्रतिफल) घटाने पर ग्रेडिएंट में पक्षपात लाए बिना विचरण कम होता है। हम क्रियाओं को केवल सकारात्मक प्रतिफल के लिए नहीं, बल्कि अपेक्षा से बेहतर होने पर पुरस्कृत करते हैं।

baseline = G.mean()
advantage = G - baseline
loss = -torch.sum(torch.stack(log_probs) * advantage)

REINFORCE क्यों महत्वपूर्ण है

REINFORCE सभी नीति ग्रेडिएंट विधियों का आधार है। इसकी कमियाँ—उच्च विचरण और नमूना-दक्षता की कमी—उन actor-critic और PPO विधियों की प्रेरणा हैं जिन्हें आप आगे देखेंगे।

त्वरित जाँच

नीति ग्रेडिएंट की अपनी समझ का परीक्षण करें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावृत्ति: REINFORCE

आपने नीति pi(a|s,theta) को पैरामीटरयुक्त करना, अनुभव-पथ चलाना, डिस्काउंट किया हुआ प्रतिफल G_t निकालना और -sum(log_prob * G_t) हानि के साथ ग्रेडिएंट आरोहण करना सीखा। आपने REINFORCE का उच्च विचरण और यह भी देखा कि आधाररेखा उसे कैसे घटाती है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 53
पाठ: 225

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Policy Gradient विधियाँ: REINFORCE” पाठ निःशुल्क है?

हाँ — पाइथन के साथ एआई सीखें अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “Policy Gradient विधियाँ: REINFORCE” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। पाइथन के साथ एआई सीखें पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Policy Gradient विधियाँ: REINFORCE” में मैं क्या सीखूँगा?

Policy gradient प्रमेय, REINFORCE algorithm, baseline subtraction और variance reduction। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ पाइथन के साथ एआई सीखें का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या पाइथन के साथ एआई सीखें शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर पाइथन के साथ एआई सीखें शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“Policy Gradient विधियाँ: REINFORCE” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस पाइथन के साथ एआई सीखें पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर पाइथन के साथ एआई सीखें पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← पाइथन के साथ एआई सीखें पर वापस जाएँ