पॉलिसी ग्रेडिएंट थियोरम समझें: एक व्यवहारिक परिचय

Policy Gradient मेथड्स क्यों उपयोग करें?

पॉलिसी ग्रेडिएंट मेथड्स का एक प्रमुख लाभ यह है कि वे जटिल एक्शन स्पेस को संभाल सकते हैं, जहाँ पारंपरिक वैल्यू-आधारित दृष्टिकोण संघर्ष करते हैं।

उच्च-आयामी एक्शन स्पेसेज़ को संभालना

Q-लर्निंग जैसी वैल्यू-आधारित मेथड्स सभी संभावित एक्शंस के लिए वैल्यू फंक्शन का आकलन करके काम करती हैं। जब परिवेश का एक्शन स्पेस सतत हो, या असतत लेकिन बहुत बड़ा हो, तो यह कठिन हो जाता है। 

पॉलिसी ग्रेडिएंट मेथड्स पॉलिसी को पैरामीटराइज़ करती हैं और कुल रिवार्ड्स के ग्रेडिएंट का आकलन पॉलिसी पैरामीटर्स के सापेक्ष करती हैं। वे इस ग्रेडिएंट का उपयोग पॉलिसी के पैरामीटर्स को अपडेट करके सीधे पॉलिसी का अनुकूलन करने में करती हैं। इसलिए, वे उच्च-आयामी या सतत एक्शन स्पेसेज़ को कुशलता से संभाल सकती हैं। पॉलिसी ग्रेडिएंट्स मानव फीडबैक (RLHF) का उपयोग करने वाली रिइनफोर्समेंट लर्निंग विधियों का भी आधार हैं। 

पॉलिसी को पैरामीटराइज़ करके और ग्रेडिएंट्स के आधार पर उसके पैरामीटर्स को समायोजित करके, पॉलिसी ग्रेडिएंट सतत और उच्च-आयामी एक्शंस को कुशलता से संभाल सकते हैं। यह सीधा दृष्टिकोण बेहतर सामान्यीकरण और अधिक लचीले एक्सप्लोरेशन को सक्षम करता है, जिससे यह रोबोटिक कंट्रोल और अन्य जटिल परिवेशों जैसे कार्यों के लिए उपयुक्त बनता है।

स्टोकेस्टिक पॉलिसीज़ सीखना

एक दिए गए ऑब्ज़र्वेशन सेट के लिए: 

• डिटरमिनिस्टिक पॉलिसी बताती है कि एजेंट कौन-सा एक्शन लेगा। 
• स्टोकेस्टिक पॉलिसी संभावित एक्शंस और प्रत्येक एक्शन को चुनने की प्रायिकता बताती है। 

स्टोकेस्टिक पॉलिसी का अनुपालन करने पर, वही ऑब्ज़र्वेशन अलग-अलग इटरेशन में अलग एक्शंस चुनने का कारण बन सकता है। यह एक्शन स्पेस के अन्वेषण को बढ़ावा देता है और पॉलिसी को लोकल ऑप्टिमा में फँसने से रोकता है। इसलिए, स्टोकेस्टिक पॉलिसीज़ उन परिवेशों में उपयोगी होती हैं जहाँ अधिकतम रिटर्न तक पहुँचने वाला मार्ग खोजने के लिए एक्सप्लोरेशन आवश्यक है। 

पॉलिसी-आधारित मेथड्स में, पॉलिसी आउटपुट को एक प्रायिकता वितरण में बदला जाता है, जिसमें प्रत्येक संभावित एक्शन को एक प्रायिकता सौंपी जाती है। एजेंट इस वितरण से सैंपल करके एक्शन चुनता है, जिससे स्टोकेस्टिक पॉलिसी लागू करना संभव हो जाता है। इस प्रकार, पॉलिसी ग्रेडिएंट मेथड्स एक्सप्लोरेशन और एक्सप्लॉइटेशन का संयोजन करते हैं, जो जटिल रिवार्ड संरचनाओं वाले परिवेशों में उपयोगी है। 

Policy Gradient Theorem का व्युत्पादन

व्युत्पादन में उतरने से पहले, प्रमाण में प्रयुक्त गणितीय संकेतन और मुख्य अवधारणाएँ स्थापित करना महत्वपूर्ण है।

गणितीय संकेतन और प्रारंभिक बातें

जैसा कि पिछले अनुभाग में उल्लेख किया गया है, पॉलिसी ग्रेडिएंट थियोरम कहता है कि अपेक्षित रिटर्न का डेरिवेटिव, रिटर्न और पॉलिसी के लघुगणक के डेरिवेटिव के गुणनफल की अपेक्षा के बराबर है। 

थियोरम का व्युत्पादन करने से पहले, हम संकेतन प्रस्तुत करते हैं:

• E[X] यादृच्छिक चर X की प्रायिकता-आधारित अपेक्षा को दर्शाता है। 
• गणितीय रूप से, पॉलिसी को एक प्रायिकता मैट्रिक्स के रूप में व्यक्त किया जाता है, जो विभिन्न ऑब्ज़र्वेशंस के आधार पर विभिन्न एक्शंस को चुनने की प्रायिकता देता है। आमतौर पर पॉलिसी को पैरामीटरयुक्त फंक्शन के रूप में मॉडल किया जाता है, जिसके पैरामीटर्स को θ से दर्शाया जाता है।
• π_θ से तात्पर्य है θ द्वारा पैरामीटराइज़्ड पॉलिसी। व्यवहार में, ये पैरामीटर्स उस न्यूरल नेटवर्क के वेट्स होते हैं जो पॉलिसी को मॉडल करता है। 
• ट्राजेक्टरी, τ, स्टेट्स के अनुक्रम को संदर्भित करती है, जो आमतौर पर एक रैंडम प्रारंभिक स्टेट से शुरू होकर मौजूदा टाइमस्टेप या टर्मिनल स्टेट तक जाती है। 
• ∇_θf से तात्पर्य फंक्शन f के पैरामीटर(स्) θ के सापेक्ष ग्रेडिएंट से है। 
• J(π_θ) उस अपेक्षित रिटर्न को दर्शाता है जो एजेंट पॉलिसी π_θ का पालन करते हुए प्राप्त करता है। यही ग्रेडिएंट असेंट के लिए ऑब्जेक्टिव फंक्शन भी है। 
• परिवेश प्रत्येक टाइमस्टेप पर एजेंट की क्रिया के अनुसार रिवार्ड देता है। रिटर्न से तात्पर्य प्रारंभिक स्टेट से मौजूदा टाइमस्टेप तक के संचयी रिवार्ड्स से है। 
• R(τ) ट्राजेक्टरी τ पर प्राप्त रिटर्न को दर्शाता है। 

व्युत्पादन के चरण

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

ऑब्जेक्टिव फंक्शन (समीकरण 1)

पॉलिसी ग्रेडिएंट मेथड में ऑब्जेक्टिव फंक्शन वह रिटर्न है 

J जो पॉलिसी π को पैरामीटर्स θ के रूप में व्यक्त करते हुए ट्राजेक्टरी का अनुसरण करके संचित होता है। यह ऑब्जेक्टिव फंक्शन इस प्रकार दिया गया है: 

ऊपर के समीकरण में: 

• बाएँ पक्ष (LHS) पॉलिसी π_θ.
• दाएँ पक्ष (RHS) अपेक्षा है (ट्राजेक्टरी τ पर, जो हर स्टेप में पॉलिसी π_θ का पालन करके जनरेट होती है) ट्राजेक्टरी R(τ) की।  

ऑब्जेक्टिव फंक्शन का डिफरेंशियल (समीकरण 2)

ऊपर के समीकरण के दोनों पक्षों का ( θ के सापेक्ष) डिफरेंशिएशन करने पर मिलता है:

एपेक्सपेक्टेशन का ग्रेडिएंट (समीकरण 3)

RHS पर दी गई अपेक्षा को निम्न गुणनफल पर इंटेग्रल के रूप में व्यक्त किया जा सकता है: 

• ट्राजेक्टरी τ
• ट्राजेक्टरी τ पर उत्पन्न रिटर्न्स

अतः, समीकरण 2 का RHS इस प्रकार लिखा जा सकता है: 

किसी इंटेग्रल का ग्रेडिएंट, ग्रेडिएंट के इंटेग्रल के बराबर होता है। इसलिए, ऊपर के व्यंजक में हम ग्रेडिएंट ∇ को इंटेग्रल चिन्ह के अंदर ला सकते हैं। अतः, RHS होगा: 

अतः, समीकरण 2 को यूँ लिखा जा सकता है:

ट्राजेक्टरी की प्रायिकता (समीकरण 4)

अब हम P(τ|θ), यानी पॉलिसी पैरामीटर्स θ दिए जाने पर एजेंट के ट्राजेक्टरी (और इस प्रकार पॉलिसी π_θ) पर चलने की प्रायिकता को, अधिक बारीकी से देखते हैं। एक ट्राजेक्टरी कई स्टेप्स से बनी होती है। अतः: 

• ट्राजेक्टरी τ प्राप्त होने की प्रायिकता है,
• सभी व्यक्तिगत स्टेप्स का अनुसरण करने की प्रायिकताओं के गुणनफल के बराबर। 

• टाइम स्टेप t में, एजेंट स्टेट s से स्टेट s_t+1 पर एक्शन a_t के जरिए जाता है। इसके होने की प्रायिकता निम्न के गुणनफल के रूप में दी जाती है:
• स्टेट s_t में पॉलिसी द्वारा एक्शन a_t की भविष्यवाणी करने की प्रायिकता
• दिए गए एक्शन a_t और स्टेट s_t के लिए स्टेट s_t+1 में पहुँचने की प्रायिकता

अतः, प्रारंभिक स्टेट s₀ से शुरू करते हुए, पॉलिसी π_θ के आधार पर एजेंट के ट्राजेक्टरी τ पर चलने की प्रायिकता इस प्रकार दी जाती है: 

सरल बनाने के लिए, हम ऊपर RHS में दिए गुणनफल को योग के रूप में व्यक्त करना चाहते हैं। इसलिए, हम ऊपर के समीकरण के दोनों पक्षों पर लॉगरिथ्म लेते हैं:

लॉग-प्रायिकता का डेरिवेटिव (समीकरण 5) 

अब हम ऊपर के समीकरण में लॉग प्रायिकता का डेरिवेटिव ( θ के सापेक्ष) लेते हैं। 

ऊपर के समीकरण के RHS पर: 

• पहला पद log ρ₀(s₀), θ के सापेक्ष स्थिर है। इसका डेरिवेटिव 0 है। 
• समेशन के अंदर का पहला पद P(s_t+1|s_t, a_t) भी θ से स्वतंत्र है और θ के सापेक्ष इसका डेरिवेटिव भी 0 है। 

ऊपर के शून्य-पद हटाने पर, हमारे पास (समीकरण 5) बचता है: 

समीकरण 2 से याद करें कि: 

समीकरण 5, समीकरण 2 के RHS के पहले भाग के लॉग का मान देता है। हमें किसी पद के डेरिवेटिव को उसके लॉगरिथ्म से जोड़ना है। हम यह चेन रूल और लॉग-डेरिवेटिव ट्रिक का उपयोग करके करते हैं। 

लॉग-डेरिवेटिव ट्रिक

हम थोड़ी देर कैलकुलस के नियमों का उपयोग करके एक परिणाम निकालते हैं, जिसका उपयोग हम पिछले समीकरण को सरल बनाने और उसे कम्प्यूटेशनल विधियों के अनुकूल बनाने में करेंगे। 

कैलकुलस में, लॉगरिथ्म का डेरिवेटिव इस प्रकार व्यक्त किया जा सकता है: 

अतः, ऊपर के समीकरण को पुनर्व्यवस्थित करके, x का डेरिवेटिव, log(x) के डेरिवेटिव के रूप में व्यक्त किया जा सकता है:

इसे कभी-कभी लॉग-डेरिवेटिव ट्रिक कहा जाता है। 

चेन रूल

चेन रूल के अनुसार, यदि z(y), y का एक फंक्शन है और y स्वयं θ का फंक्शन है, y(θ), तो z का θ के सापेक्ष अवकलज होगा:

यहाँ y(θ) का अर्थ है P(θ) और z(y) का अर्थ है log(y)। अत: 

चेन रूल लागू करना

हमें कैलकुलस से ज्ञात है कि d(log(y)) / dy = 1/y। इसे ऊपर RHS के पहले पद में उपयोग करें। 

y को LHS पर ले जाएँ और संकेतन का उपयोग करें:

y का अर्थ P(θ) है। इसलिए ऊपर का समीकरण समतुल्य है: 

लॉग-डेरिवेटिव ट्रिक लागू करना

ऊपर का परिणाम, समीकरण 2 (नीचे दिखाया गया) के RHS के पहले व्यंजक को देता है।  

समीकरण 2 के RHS में परिणाम का उपयोग करने पर हमें मिलता है: 

हम RHS इंटेग्रल के अंदर के पदों को इस प्रकार पुनर्व्यवस्थित करते हैं:

अंतिम परिणाम निकालना

ध्यान दें कि ऊपर का व्यंजक एक अपेक्षा के इंटेग्रल विस्तार को सम्मिलित करता है: ∫P(θ)∇logP(θ) = E[∇logP(θ)]

अतः, ऊपर के RHS को अपेक्षा के रूप में व्यक्त किया जा सकता है: 

हम अपेक्षित रिवार्ड के व्यंजक में लॉग प्रायिकता का डेरिवेटिव प्रतिस्थापित करते हैं: 

ऊपर के समीकरण में, ∇logP(θ) का मान समीकरण 5 से रखकर हमें मिलता है: 

यह पॉलिसी ग्रेडिएंट थियोरम के अनुसार रिवार्ड फंक्शन के ग्रेडिएंट का व्यंजक है। 

पॉलिसी ग्रेडिएंट के पीछे का सहज बोध

पॉलिसी ग्रेडिएंट मेथड्स पॉलिसी के आउटपुट को एक प्रायिकता वितरण में बदलते हैं। एजेंट इस वितरण से सैंपल लेकर एक्शन चुनता है। पॉलिसी ग्रेडिएंट मेथड्स पॉलिसी पैरामीटर्स को समायोजित करते हैं। इससे हर इटरेशन में यह प्रायिकता वितरण अपडेट होता है। अपडेटेड वितरण में उन एक्शंस को चुनने की संभावना अधिक होती है जो उच्च रिवार्ड्स की ओर ले जाते हैं। 

पॉलिसी ग्रेडिएंट एल्गोरिदम पॉलिसी पैरामीटर्स के सापेक्ष अपेक्षित रिटर्न का ग्रेडिएंट निकालता है। पॉलिसी पैरामीटर्स को इस ग्रेडिएंट की दिशा में बढ़ाते हुए, एजेंट ट्रेनिंग के दौरान ऐसे एक्शंस चुनने की प्रायिकता बढ़ाता है जो उच्च रिवार्ड्स देते हैं। 

मूल रूप से, जिन एक्शंस ने बेहतर परिणाम दिए, वे भविष्य में चुने जाने की अधिक संभावना रखते हैं, जिससे पॉलिसी धीरे-धीरे सुधारती है और दीर्घकालिक रिवार्ड्स को अधिकतम करती है।

Python में Policy Gradients लागू करना

पॉलिसी ग्रेडिएंट के मूल सिद्धांतों पर चर्चा करने के बाद, हम PyTorch और Gymnasium का उपयोग करके उन्हें कैसे लागू करें, यह दिखाते हैं। 

पर्यावरण सेटअप करना

पहले चरण के रूप में, हमें gymnasium और NumPy तथा PyTorch जैसी कुछ सपोर्टिंग लाइब्रेरियाँ इंस्टॉल करनी होंगी।

सर्वर या लोकल मशीन पर gymnasium और उसकी डिपेंडेंसीज़ इंस्टॉल करने के लिए चलाएँ:

$ pip install gymnasium संचालित द्वारा

Google Colab या DataLab जैसे नोटबुक में इंस्टॉल करने के लिए उपयोग करें: 

!pip install gymnasiumसंचालित द्वारा

इन पैकेजों को Python वातावरण में इस प्रकार इम्पोर्ट करें:

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.distributions as distributions
import numpy as np
import gymnasium as gym  संचालित द्वारा

एक सरल पॉलिसी ग्रेडिएंट एजेंट कोड करना

पर्यावरण का एक इंस्टेंस .make() मेथड का उपयोग करके बनाएँ।

env = gym.make('CartPole-v1')संचालित द्वारा

अन्य मशीन लर्निंग विधियों की तरह, हम पॉलिसी ग्रेडिएंट एजेंट को लागू करने के लिए एक न्यूरल नेटवर्क का उपयोग करते हैं। 

CartPole-v1 एक सरल पर्यावरण है, इसलिए हम 64 न्यूरॉन्स की 1 हिडन लेयर वाला एक सरल नेटवर्क डिज़ाइन करते हैं। इनपुट लेयर का आयाम ऑब्ज़र्वेशन स्पेस के आयाम के बराबर होता है। आउटपुट लेयर का आयाम पर्यावरण के एक्शन स्पेस के आकार के बराबर होता है। इस प्रकार, पॉलिसी नेटवर्क ऑब्ज़र्व्ड स्टेट्स को एक्शंस पर मैप करता है। किसी ऑब्ज़र्वेशन को इनपुट के रूप में देने पर, नेटवर्क पॉलिसी के अनुसार एक्शन प्रेडिक्ट करता है। 

नीचे दिया कोड पॉलिसी नेटवर्क को लागू करता है: 

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()

        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return xसंचालित द्वारा

एजेंट को ट्रेन करना

पर्यावरण प्रत्येक टाइमस्टेप पर एजेंट की स्टेट और एक्शन पर निर्भर रिवार्ड देता है। पॉलिसी ग्रेडिएंट अप्रोच में ग्रेडिएंट डिसेंट (असल में असेंट) को संचयी रिवार्ड्स (रिटर्न) पर चलाया जाता है। लक्ष्य कुल रिटर्न को अधिकतम करना है। 

किसी एपिसोड में रिटर्न निकालने के लिए, आप उस एपिसोड के सभी टाइमस्टेप्स के रिवार्ड्स को (डिस्काउंट फैक्टर के साथ) जोड़ते हैं। अतिरिक्त रूप से, रिटर्न्स को नॉर्मलाइज़ करना प्रशिक्षण को स्मूद और स्थिर रखने में सहायक होता है। नीचे दिया कोड यह दिखाता है:

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0

    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returnsसंचालित द्वारा

फॉरवर्ड पास की प्रत्येक इटरेशन में, हम निम्न चरण करते हैं: 

• एजेंट को मौजूदा पॉलिसी के आधार पर .step() फंक्शन से चलाएँ। पॉलिसी प्रत्येक टाइमस्टेप में चुने गए एक्शन को लेने की प्रायिकता प्रेडिक्ट करती है।
• एजेंट के एक्शन के आधार पर पर्यावरण से रिवार्ड प्राप्त करें।
• जब तक एजेंट टर्मिनल स्टेट तक न पहुँच जाए, स्टेपवाइज़ रिवार्ड्स और एक्शंस के लॉग प्रायिकताओं को एकत्र करें।

नीचे दिया कोड फॉरवर्ड पास को लागू करता है:

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0

    policy.train()
    observation, info = env.reset()

    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)

        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated

        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward

    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)

    return episode_return, stepwise_returns, log_prob_actionsसंचालित द्वारा

बैकप्रोपेगेशन और ग्रेडिएंट असेंट से पॉलिसी अपडेट करना

पारंपरिक मशीन लर्निंग में:

• लॉस, प्रेडिक्टेड और वास्तविक आउटपुट के बीच के अंतर को संदर्भित करता है। 
• हम ग्रेडिएंट डिसेंट से लॉस को न्यूनतम करते हैं।

RL में:

• लॉस उस मात्रा का प्रॉक्सी है जिस पर ग्रेडिएंट डिसेंट (या असेंट) लागू किया जाना है। 
• हम ग्रेडिएंट असेंट का उपयोग करके रिटर्न (संचयी रिवार्ड) को अधिकतम करते हैं।
• ग्रेडिएंट डिसेंट के लिए प्रॉक्सी के रूप में अपेक्षित रिटर्न वैल्यू का उपयोग किया जाता है। अपेक्षित रिटर्न वैल्यू निम्न का गुणनफल है:
• प्रत्येक स्टेप से अपेक्षित रिटर्न्स 
• प्रत्येक स्टेप में सैंपल किए गए एक्शन को चुनने की प्रायिकता। 
• बैकप्रोपेगेशन के जरिए ग्रेडिएंट असेंट लागू करने के लिए, हम लॉस का ऋणात्मक उपयोग करते हैं। 

नीचे दिया कोड लॉस की गणना करता है:

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return lossसंचालित द्वारा

मानक मशीन लर्निंग एल्गोरिदम की तरह, पॉलिसी को अपडेट करने के लिए आप लॉस फंक्शन के सापेक्ष बैकप्रोपेगेशन चलाते हैं। नीचे दिया update_policy() मेथड calculate_loss() को कॉल करता है। फिर यह लॉस पर बैकप्रोपेगेशन चलाकर पॉलिसी पैरामीटर्स (यानी पॉलिसी नेटवर्क के मॉडल वेट्स) को अपडेट करता है। 

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    return loss.item()संचालित द्वारा

ट्रेनिंग लूप 

हम पॉलिसी को ट्रेन करने के लिए पहले परिभाषित फंक्शंस का उपयोग करते हैं। प्रशिक्षण शुरू करने से पहले, हमें चाहिए: 

• PolicyNetwork क्लास का एक रैंडमाइज़्ड इंस्टेंस के रूप में इनिशियलाइज़ की गई अनट्रेंड पॉलिसी। 
• Adam एल्गोरिदम वाला एक ऑप्टिमाइज़र। 
• डिस्काउंट फैक्टर, लर्निंग रेट, ड्रॉपआउट रेट, रिवार्ड थ्रेशहोल्ड, और अधिकतम ट्रेनिंग एपॉक्स के लिए हाइपरपैरामीटर्स। 

हम ट्रेनिंग लूप को तब तक चलाते हैं जब तक औसत रिटर्न रिवार्ड थ्रेशहोल्ड से अधिक न हो जाए। प्रत्येक इटरेशन में, हम निम्न चरण करते हैं: 

• हर एपिसोड के लिए, फॉरवर्ड पास एक बार चलाएँ। उस एपिसोड से एक्शंस की लॉग प्रायिकताएँ, स्टेपवाइज़ रिटर्न्स और कुल रिटर्न एकत्र करें। एपिसोडिक रिटर्न्स को एक एरे में जोड़ें। 
• लॉग प्रायिकताओं और स्टेपवाइज़ रिटर्न्स का उपयोग करके लॉस की गणना करें। लॉस पर बैकप्रोपेगेशन चलाएँ। ऑप्टिमाइज़र का उपयोग करके पॉलिसी पैरामीटर्स अपडेट करें। 
• जाँचें कि N_TRIALS पर औसत रिटर्न रिवार्ड थ्रेशहोल्ड से अधिक है या नहीं। 

नीचे दिया कोड इन चरणों को लागू करता है:

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5

    episode_returns = []

    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)

    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)

    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)

        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])

        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')

        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            breakसंचालित द्वारा

प्रशिक्षण प्रोग्राम को main() फंक्शन कॉल करके चलाएँ:

main()संचालित द्वारा

यह DataLab वर्कबुक उपर्युक्त पॉलिसी ग्रेडिएंट एल्गोरिदम का इम्प्लीमेंटेशन समाहित करती है। आप इसे सीधे चला सकते हैं या एल्गोरिदम में संशोधन करने के लिए शुरुआती बिंदु के रूप में उपयोग कर सकते हैं।

Policy Gradient मेथड्स के फायदे और चुनौतियाँ

पॉलिसी ग्रेडिएंट मेथड्स कई फायदे प्रदान करती हैं, जैसे:

• सतत एक्शन स्पेसेज़ को संभालना: वैल्यू-आधारित मेथड्स (जैसे Q-लर्निंग) सतत एक्शन स्पेसेज़ में अक्षम होती हैं क्योंकि उन्हें पूरे एक्शन स्पेस पर वैल्यू का आकलन करना पड़ता है। पॉलिसी ग्रेडिएंट मेथड्स अपेक्षित रिटर्न के ग्रेडिएंट का उपयोग करके सीधे पॉलिसी का अनुकूलन कर सकती हैं। यह दृष्टिकोण सतत एक्शन डिस्ट्रीब्यूशंस के साथ अच्छा काम करता है। इसलिए, पॉलिसी ग्रेडिएंट मेथड्स रोबोटिक कंट्रोल जैसे सतत एक्शन स्पेसेज़ पर आधारित कार्यों के लिए उपयुक्त हैं।
• स्टोकेस्टिक पॉलिसीज़: पॉलिसी ग्रेडिएंट मेथड्स स्टोकेस्टिक पॉलिसीज़ सीख सकती हैं—जो प्रत्येक संभावित एक्शन को चुनने की प्रायिकता देती हैं। यह एजेंट को तरह-तरह के एक्शंस आज़माने देता है और लोकल ऑप्टिमा में फँसने का जोखिम घटाता है। यह जटिल परिवेशों में मददगार है जहाँ इष्टतम पॉलिसी खोजने के लिए एक्शन स्पेस का अन्वेषण आवश्यक है। स्टोकेस्टिक प्रकृति एक्सप्लोरेशन (नए एक्शन आज़माना) और एक्सप्लॉइटेशन (सबसे अच्छे ज्ञात एक्शन चुनना) के बीच संतुलन बनाने में सहायक होती है, जो अनिश्चितता या स्पार्स रिवार्ड्स वाले परिवेशों के लिए महत्वपूर्ण है।
• डायरेक्ट पॉलिसी ऑप्टिमाइज़ेशन: पॉलिसी ग्रेडिएंट्स वैल्यू फंक्शंस का उपयोग करने की बजाय सीधे पॉलिसी को ऑप्टिमाइज़ करते हैं। सतत या उच्च-आयामी एक्शन स्पेसेज़ में हर एक्शन के लिए वैल्यू का अनुमान लगाना कम्प्यूटेशनल रूप से महँगा हो सकता है। इसलिए, पॉलिसी-आधारित मेथड्स ऐसे परिवेशों में अच्छा प्रदर्शन करती हैं। 

कई फायदों के बावजूद, पॉलिसी ग्रेडिएंट मेथड्स में कुछ अंतर्निहित चुनौतियाँ होती हैं:

• ग्रेडिएंट आकलनों में उच्च वैरिएंस: पॉलिसी ग्रेडिएंट मेथड्स प्रायिकता वितरण से सैंपल लेकर एक्शंस चुनती हैं। प्रभावतः, वे अपेक्षित रिटर्न का अनुमान लगाने के लिए ट्राजेक्टरी को सैंपल करती हैं। चूँकि सैंपलिंग प्रक्रिया स्वभावतः रैंडम होती है, इसलिए बाद के इटरेशन में अनुमानित रिटर्न्स में उच्च वैरिएंस हो सकता है। इससे एजेंट के लिए कुशलतापूर्वक सीखना कठिन हो सकता है क्योंकि पॉलिसी अपडेट्स इटरेशंस के बीच काफी बदल सकते हैं। 
• ट्रेनिंग के दौरान अस्थिरता: 
• पॉलिसी ग्रेडिएंट मेथड्स हाइपरपैरामीटर्स के प्रति संवेदनशील होती हैं। यदि लर्निंग रेट बहुत अधिक है, तो पॉलिसी पैरामीटर्स के अपडेट बहुत बड़े हो सकते हैं, जिससे प्रशिक्षण इष्टतम पैरामीटर्स को चूक सकता है। दूसरी ओर, यदि लर्निंग रेट बहुत कम है, तो अभिसरण धीमा हो सकता है। 
• पॉलिसी ग्रेडिएंट मेथड्स को एक्सप्लोरेशन और एक्सप्लॉइटेशन के बीच संतुलन बनाना होता है। यदि एजेंट पर्याप्त एक्सप्लोर नहीं करता, तो वह इष्टतम पॉलिसी के पड़ोस तक नहीं पहुँच पाएगा। विपरीत रूप में, यदि वह बहुत अधिक एक्सप्लोर करता है, तो वह इष्टतम पॉलिसी पर अभिसरण नहीं करेगा और एक्शन स्पेस के आसपास डोलता रहेगा। 
• सैंपल अक्षमता: पॉलिसी ग्रेडिएंट मेथड्स प्रत्येक पॉलिसी का अनुगमन टर्मिनेशन तक करके और प्रत्येक स्टेप से रिवार्ड्स जोड़कर रिटर्न का अनुमान लगाती हैं। इसलिए, उन्हें बड़ी संख्या में सैंपल ट्राजेक्टरी निकालने के लिए पर्यावरण के साथ कई इंटरैक्शंस की आवश्यकता होती है। यह बड़े स्टेट या एक्शन स्पेस वाले परिवेशों के लिए अक्षम और महँगा है। 

स्थिरता के लिए समाधान

चूँकि पॉलिसी ग्रेडिएंट मेथड्स में अस्थिरता अपेक्षाकृत सामान्य समस्या है, डेवलपर्स ने प्रशिक्षण प्रक्रिया को स्थिर करने के लिए विभिन्न समाधान अपनाए हैं। नीचे, हम पॉलिसी ग्रेडिएंट्स का उपयोग करके ट्रेनिंग को स्थिर करने के आम समाधान प्रस्तुत करते हैं: 

बेसलाइन फंक्शंस का उपयोग

अक्षम सैंपलिंग के कारण, प्रशिक्षण इटरेशंस के दौरान अनुमानित रिटर्न्स के ग्रेडिएंट्स में उच्च वैरिएंस हो सकता है, जिससे ट्रेनिंग अस्थिर और धीमी हो जाती है। वैरिएंस को कम करने का एक सामान्य तरीका बेसलाइन फंक्शंस का उपयोग करना है, जैसे Advantage Actor-Critic (A2C) मेथड। विचार यह है कि ऑब्जेक्टिव फंक्शन के लिए अनुमानित रिटर्न की बजाय एक प्रॉक्सी (एडवांटेज फंक्शन) का उपयोग किया जाए। 

एडवांटेज, सैंपल की गई ट्राजेक्टरी से प्राप्त वास्तविक रिटर्न और प्रारंभिक स्टेट के लिए अपेक्षित रिटर्न के अंतर के रूप में गणना किया जाता है। इस दृष्टिकोण में वैल्यू फंक्शन का उपयोग स्टेट्स और स्टेट-एक्शन पेयर्स के अपेक्षित मान के रूप में किया जाता है। लॉस को केवल रिटर्न्स के रूप में व्यक्त करने के बजाय वास्तविक और अपेक्षित रिटर्न के अंतर के रूप में व्यक्त करके, A2C लॉस फंक्शन और इसलिए ग्रेडिएंट्स में वैरिएंस को कम करता है, जिससे ट्रेनिंग अधिक स्थिर हो जाती है। 

एंट्रॉपी रेग्युलराइज़ेशन का उपयोग

कुछ परिवेशों में, जैसे स्पार्स रिवार्ड्स (जहाँ बहुत कम स्टेट्स रिवार्ड देते हैं), पॉलिसी जल्दी ही डिटरमिनिस्टिक अप्रोच अपना लेती है। यह एक लोभी (greedy) अप्रोच भी अपना लेती है और पहले से खोजे गए मार्गों का शोषण करती है। इससे आगे का एक्सप्लोरेशन रुक जाता है और अक्सर लोकल ऑप्टिमा तथा सब-ऑप्टिमल पॉलिसीज़ पर अभिसरण हो जाता है। 

समाधान यह है कि पॉलिसी को अत्यधिक डिटरमिनिस्टिक होने पर दंडित करके एक्सप्लोरेशन को प्रोत्साहित किया जाए। यह ऑब्जेक्टिव फंक्शन में एंट्रॉपी-आधारित पद जोड़कर किया जाता है। एंट्रॉपी पॉलिसी में रैंडमनेस की मात्रा मापती है। एंट्रॉपी जितनी अधिक, एजेंट द्वारा चुने गए एक्शंस में उतनी ही अधिक रैंडमनेस। यह एंट्रॉपी-आधारित पद एंट्रॉपी कोएफिशिएंट और मौजूदा पॉलिसी की एंट्रॉपी का गुणनफल होता है। 

ऑब्जेक्टिव फंक्शन में एंट्रॉपी सम्मिलित करना एक्सप्लॉइटेशन और एक्सप्लोरेशन के बीच संतुलन साधने में मदद करता है। 

Policy Gradient एक्सटेंशंस

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

REINFORCE एल्गोरिदम

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

नीचे, हम REINFORCE एल्गोरिदम के मूल चरण प्रस्तुत करते हैं:

• रैंडम पैरामीटर्स के साथ पॉलिसी इनिशियलाइज़ करें
• कई ट्रेनिंग एपिसोड्स दोहराएँ। प्रत्येक एपिसोड के लिए: 
• पूरे एपिसोड के प्रत्येक स्टेप को इस प्रकार जनरेट करें: 
• स्टेट को पॉलिसी फंक्शन में पास करें। 
• पॉलिसी फंक्शन प्रत्येक संभावित एक्शन के लिए प्रायिकताएँ उत्पन्न करता है।
• इस प्रायिकता वितरण से रैंडम रूप से एक एक्शन सैंपल करें।
• एपिसोड के प्रत्येक स्टेट के लिए, स्टेप तक के रिटर्न्स (डिस्काउंटेड संचयी रिवार्ड्स) का अनुमान लगाएँ।
• ऑब्जेक्टिव फंक्शन के ग्रेडिएंट का अनुमान लगाएँ (पॉलिसी ग्रेडिएंट थियोरम के अनुसार), जिसे प्रत्येक स्टेप के लिए स्टेपवाइज़ रिटर्न्स और एक्शन प्रायिकताओं के गुणनफल के रूप में व्यक्त किया जाता है। 
• ग्रेडिएंट्स लागू करके पॉलिसी पैरामीटर्स अपडेट करें

किसी भी पॉलिसी के लिए, आप ग्रेडिएंट का अनुमान एक एकल ट्राजेक्टरी से लगा सकते हैं (जैसा ऊपर दिखाया गया) या उसी पॉलिसी के तहत सैंपल की गई कई ट्राजेक्टरी पर ग्रेडिएंट का औसत ले सकते हैं। 

एक्टर-क्रिटिक मेथड्स

एक्टर-क्रिटिक मेथड्स, पॉलिसी ग्रेडिएंट मेथड्स (जैसे REINFORCE) को वैल्यू फंक्शंस के साथ जोड़ती हैं।

• एक्टर का कार्य पॉलिसी ग्रेडिएंट मेथड्स जैसा ही होता है। एक्टर पॉलिसी को लागू करता है, हर स्टेप में पॉलिसी के आधार पर एक्शन चुनता है। यह अपेक्षित रिटर्न के ग्रेडिएंट का अनुसरण करते हुए पॉलिसी को अपडेट करता है। 
• क्रिटिक वैल्यू फंक्शन को लागू करता है, जिसका उपयोग बेसलाइन (पिछले अनुभाग में चर्चा) के रूप में किया जाता है। यह ट्रेनिंग को अधिक कुशल और स्थिर बनाने में मदद करता है। 

REINFORCE जैसी पॉलिसी ग्रेडिएंट मेथड्स कच्चे रिटर्न का उपयोग करके प्रत्येक ट्राजेक्टरी के साथ ग्रेडिएंट्स का अनुमान लगाती हैं। चूँकि ये ट्राजेक्टरी सैंपलिंग प्रक्रिया से निकाली जाती हैं, इससे रिटर्न्स और ग्रेडिएंट्स में बड़े वैरिएंस हो सकते हैं। कच्चे रिटर्न की बजाय एडवांटेज फंक्शन का उपयोग करना इस समस्या को हल करता है। एडवांटेज फंक्शन वास्तविक और अपेक्षित रिटर्न (यानी वैल्यू फंक्शन) के बीच का अंतर है। एक्टर-क्रिटिक मेथड्स एल्गोरिदम का एक वर्ग हैं। जब क्रिटिक को एडवांटेज फंक्शन (सबसे आम तरीका) से लागू किया जाता है, तो इसे Advantage Actor-Critic (A2C) भी कहा जाता है। 

प्रॉक्सिमल पॉलिसी ऑप्टिमाइज़ेशन (PPO)

जटिल परिवेशों में, केवल A2C जैसी एक्टर-क्रिटिक मेथड्स रिटर्न्स और ग्रेडिएंट्स में वैरिएंस को नियंत्रित करने के लिए पर्याप्त नहीं होतीं। ऐसे मामलों में, प्रत्येक इटरेशन में पॉलिसी में होने वाले परिवर्तन की मात्रा को कृत्रिम रूप से प्रतिबंधित करना सहायक होता है। इससे अपडेटेड (ग्रेडिएंट असेंट के बाद) पॉलिसी पुराने पॉलिसी के पड़ोस में रहने के लिए बाध्य होती है। 

प्रॉक्सिमल पॉलिसी ऑप्टिमाइज़ेशन जैसी विधियाँ पॉलिसी ग्रेडिएंट्स में दो संशोधन करती हैं:

• एडवांटेज फंक्शन का उपयोग करें। सामान्यतः, यह एडवांटेज फंक्शन वैल्यू फंक्शन को बेसलाइन के रूप में उपयोग करता है। इस दृष्टि से ये A2C मेथड्स के समान हैं। 
• प्रत्येक इटरेशन में पॉलिसी पैरामीटर्स में होने वाले परिवर्तन की मात्रा को सीमित करें। यह क्लिप्ड सरोगेट ऑब्जेक्टिव फंक्शन का उपयोग करके किया जाता है। एल्गोरिदम एक रेंज निर्दिष्ट करता है जिसके भीतर नई पॉलिसी और पुरानी पॉलिसी के अनुपात को रहना चाहिए। जब (ग्रेडिएंट अपडेट के बाद) यह अनुपात पूर्वनिर्धारित मानों से अधिक हो जाता है, तो उसे उस रेंज के भीतर क्लिप कर दिया जाता है। 

इस प्रकार, PPO वनीला पॉलिसी ग्रेडिएंट मेथड्स में उल्लेखनीय सुधार करता है, जो जटिल परिवेशों में स्थिरता बढ़ाता है। क्लिप्ड ऑब्जेक्टिव फंक्शन रिटर्न्स और ग्रेडिएंट्स में बड़े वैरिएंस को पॉलिसी अपडेट्स को अस्थिर करने से रोकता है। एक्सप्लोरेशन और एक्सप्लॉइटेशन के बीच संतुलन बनाने के लिए, PPO में एंट्रॉपी रेग्युलराइज़ेशन का उपयोग करना भी संभव है। यह ऑब्जेक्टिव फंक्शन में एक एंट्रॉपी पद (पॉलिसी की एंट्रॉपी से गुणा किया गया स्केलिंग पैरामीटर) जोड़कर किया जाता है। 

हाल के प्रगति

पॉलिसी ग्रेडिएंट्स RL समस्याओं को हल करने के लिए प्रयुक्त शुरुआती विधियों में से हैं। तेज़ GPUs के आगमन के बाद, पॉलिसी ग्रेडिएंट्स पर आधुनिक ML तकनीकों को लागू करने के लिए कई नए दृष्टिकोण प्रस्तावित किए गए हैं। 

ग्रेडिएंट-बूस्टेड रिइनफोर्समेंट लर्निंग 

हाल के वर्षों में, ग्रेडिएंट बूस्टिंग जैसी विधियों को RL एल्गोरिदम पर लागू करने में प्रगति हुई है। ग्रेडिएंट बूस्टिंग कई कमजोर मॉडलों की भविष्यवाणियों को जोड़कर एक सशक्त मॉडल बनाता है। इसे ग्रेडिएंट-बूस्टेड रिइनफोर्समेंट लर्निंग (GBRL) कहा जाता है। GBRL एक Python पैकेज है जो XGBoost के समान है और इन तकनीकों को RL एल्गोरिदम के लिए लागू करता है।

ट्रांसफर रिइनफोर्समेंट लर्निंग 

ट्रांसफर लर्निंग (TL) एक तकनीक है जिसमें एक मॉडल द्वारा अर्जित ज्ञान को दूसरे मॉडल के प्रदर्शन में सुधार के लिए लागू किया जाता है। ट्रांसफर लर्निंग उपयोगी है क्योंकि ML मॉडलों को शून्य से ट्रेन करना महँगा है। TL अप्रोच का उपयोग पॉलिसी ग्रेडिएंट्स के साथ RL मॉडलों के प्रदर्शन में सुधार के लिए किया गया है। इस अप्रोच को ट्रांसफर रिइनफोर्समेंट लर्निंग (TRL) कहा जाता है। 

निष्कर्ष

पॉलिसी ग्रेडिएंट्स RL समस्याओं को हल करने के सबसे बुनियादी अप्रोच में से हैं।

 इस लेख में, हमने पॉलिसी ग्रेडिएंट्स के प्रथम सिद्धांत प्रस्तुत किए और पॉलिसी ग्रेडिएंट थियोरम का व्युत्पादन कैसे करें, यह दिखाया। हमने Gymnasium पर्यावरण में PyTorch का उपयोग करके एक सरल ग्रेडिएंट-आधारित एल्गोरिदम को लागू करने का प्रदर्शन भी किया। अंत में, हमने व्यावहारिक चुनौतियों और बेसिक पॉलिसी ग्रेडिएंट एल्गोरिदम के सामान्य एक्सटेंशंस पर चर्चा की।

यदि आप रिइनफोर्समेंट लर्निंग और PyTorch के साथ डीप लर्निंग की समझ को गहरा करना चाहते हैं, तो ये कोर्स देखें:

• Reinforcement Learning Track – वैल्यू-आधारित मेथड्स से लेकर पॉलिसी ऑप्टिमाइज़ेशन तकनीकों तक RL की नींव सीखें।
• Introduction to Deep Learning with PyTorch – PyTorch के साथ हाथों-हाथ अनुभव पाएँ और स्क्रैच से डीप लर्निंग मॉडल बनाएँ।