PyTorch और Gymnasium के साथ प्रॉक्सिमल पॉलिसी ऑप्टिमाइज़ेशन

1. वातावरण सेट करना 

PPO लागू करने से पहले, हमें आवश्यक सॉफ़्टवेयर लाइब्रेरीज़ इंस्टॉल करनी होंगी और पॉलिसी लागू करने के लिए उपयुक्त वातावरण चुनना होगा। 

PyTorch और आवश्यक लाइब्रेरीज़ इंस्टॉल करना 

हमें निम्न सॉफ़्टवेयर इंस्टॉल करने की आवश्यकता है: 

• PyTorch और अन्य सॉफ़्टवेयर लाइब्रेरीज़, जैसे numpy (गणितीय और सांख्यिकीय फ़ंक्शन के लिए) और matplotlib (ग्राफ़ प्लॉट करने के लिए)।
• OpenAI का ओपन-सोर्स Gym सॉफ़्टवेयर पैकेज, एक Python लाइब्रेरी जो विभिन्न वातावरणों और खेलों का सिमुलेशन करती है, जिन्हें रिइनफोर्समेंट लर्निंग का उपयोग करके हल किया जा सकता है। आप अपने एल्गोरिदम को वातावरण के साथ इंटरैक्ट कराने के लिए Gym API का उपयोग कर सकते हैं। चूँकि gym की कार्यक्षमता कभी-कभी अपग्रेड के दौरान बदल जाती है, इसलिए इस उदाहरण में, हम इसका संस्करण 0.25.2 पर फ्रीज़ करते हैं।

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

$ pip install torch numpy matplotlib gym==0.25.2संचालित द्वारा

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

!pip install torch numpy matplotlib gym==0.25.2संचालित द्वारा

CartPole वातावरण बनाना

OpenAI Gym का उपयोग करके CartPole वातावरण की दो इंस्टेंस (एक प्रशिक्षण के लिए और दूसरी परीक्षण के लिए) बनाएं:

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

2. PyTorch में PPO लागू करना

अब, आइए PyTorch का उपयोग करके PPO लागू करते हैं।

पॉलिसी नेटवर्क परिभाषित करना

जैसा कि पहले समझाया गया, PPO एक एक्टर-क्रिटिक मॉडल के रूप में लागू किया जाता है। एक्टर पॉलिसी को लागू करता है, और क्रिटिक उसका अनुमानित मान बताता है। दोनों, एक्टर और क्रिटिक न्यूरल नेटवर्क, समान इनपुट लेते हैं—हर टाइमस्टेप पर स्टेट। इसलिए, एक्टर और क्रिटिक मॉडल एक सामान्य न्यूरल नेटवर्क साझा कर सकते हैं, जिसे बैकबोन आर्किटेक्चर कहा जाता है। एक्टर और क्रिटिक बैकबोन आर्किटेक्चर को अतिरिक्त लेयर्स से बढ़ा सकते हैं। 

बैकबोन नेटवर्क परिभाषित करें

निम्न चरण बैकबोन नेटवर्क का वर्णन करते हैं:

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

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

class BackboneNetwork(nn.Module):
    def __init__(self, in_features, hidden_dimensions, out_features, dropout):
        super().__init__()
        self.layer1 = nn.Linear(in_features, hidden_dimensions)
        self.layer2 = nn.Linear(hidden_dimensions, hidden_dimensions)
        self.layer3 = nn.Linear(hidden_dimensions, out_features)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        x = self.layer1(x)
        x = f.relu(x)
        x = self.dropout(x)
        x = self.layer2(x)
        x = f.relu(x)
        x = self.dropout(x)
        x = self.layer3(x)
        return xसंचालित द्वारा

एक्टर-क्रिटिक नेटवर्क परिभाषित करें

अब हम इस नेटवर्क का उपयोग करके ActorCritic नामक एक्टर-क्रिटिक क्लास परिभाषित कर सकते हैं। एक्टर पॉलिसी को मॉडल करता है और एक्शन का पूर्वानुमान करता है। क्रिटिक वैल्यू फ़ंक्शन को मॉडल करता है और वैल्यू का पूर्वानुमान करता है। दोनों स्टेट को इनपुट के रूप में लेते हैं। 

class ActorCritic(nn.Module):
    def __init__(self, actor, critic):
        super().__init__()
        self.actor = actor
        self.critic = critic
    def forward(self, state):
        action_pred = self.actor(state)
        value_pred = self.critic(state)
        return action_pred, value_predसंचालित द्वारा

एक्टर और क्रिटिक नेटवर्क इंस्टैंशिएट करें

हम ऊपर परिभाषित नेटवर्क का उपयोग करके एक एक्टर और एक क्रिटिक बनाएँगे। फिर, हम एक एजेंट बनाएँगे, जिसमें एक्टर और क्रिटिक शामिल होंगे। 

एजेंट बनाने से पहले, नेटवर्क के पैरामीटर इनिशियलाइज़ करें:

• हिडन लेयर के आयाम, H, जो एक कॉन्फ़िगर करने योग्य पैरामीटर है। हिडन लेयर्स का आकार और संख्या समस्या की जटिलता पर निर्भर करती है। हम 64 X 64 आयाम वाली हिडन लेयर का उपयोग करेंगे। 
• इनपुट फीचर्स, N, जहाँ N स्टेट ऐरे का आकार है। इनपुट लेयर के आयाम N X H हैं। CartPole वातावरण में स्टेट 4-तत्वों का ऐरे है। इसलिए N = 4। 
• एक्टर नेटवर्क के आउटपुट फीचर्स, O, जहाँ O वातावरण में एक्शनों की संख्या है। एक्टर की आउटपुट लेयर के आयाम H x O हैं। CartPole वातावरण में 2 एक्शन हैं। 
• क्रिटिक नेटवर्क के आउटपुट फीचर्स। चूँकि क्रिटिक नेटवर्क केवल अपेक्षित वैल्यू (दिए गए इनपुट स्टेट पर) का अनुमान लगाता है, आउटपुट फीचर्स की संख्या 1 है। 
• ड्रॉपआउट का मान फ्रैक्शन के रूप में।

निम्न कोड दिखाता है कि बैकबोन नेटवर्क के आधार पर एक्टर और क्रिटिक नेटवर्क कैसे घोषित करें:

def create_agent(hidden_dimensions, dropout):
    INPUT_FEATURES = env_train.observation_space.shape[0]
    HIDDEN_DIMENSIONS = hidden_dimensions
    ACTOR_OUTPUT_FEATURES = env_train.action_space.n
    CRITIC_OUTPUT_FEATURES = 1
    DROPOUT = dropout
    actor = BackboneNetwork(
            INPUT_FEATURES, HIDDEN_DIMENSIONS, ACTOR_OUTPUT_FEATURES, DROPOUT)
    critic = BackboneNetwork(
            INPUT_FEATURES, HIDDEN_DIMENSIONS, CRITIC_OUTPUT_FEATURES, DROPOUT)
    agent = ActorCritic(actor, critic)
    return agentसंचालित द्वारा

रिटर्न की गणना

एजेंट की क्रिया के अनुसार, हर स्टेप से अगले स्टेप तक वातावरण एक रिवॉर्ड देता है। रिवॉर्ड, R, इस प्रकार व्यक्त किया जाता है:

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

इस ट्यूटोरियल (और कई अन्य सन्दर्भों) में, रिटर्न का मतलब डिस्काउंटेड रिटर्न से है। 

रिटर्न की गणना करने के लिए:

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

फ़ंक्शन calculate_returns() ये गणनाएँ करता है, जैसा कि नीचे दिखाया गया है:

def calculate_returns(rewards, discount_factor):
    returns = []
    cumulative_reward = 0
    for r in reversed(rewards):
        cumulative_reward = r + cumulative_reward * discount_factor
        returns.insert(0, cumulative_reward)
    returns = torch.tensor(returns)
    # normalize the return
    returns = (returns - returns.mean()) / returns.std()
    return returnsसंचालित द्वारा

एडवांटेज फ़ंक्शन लागू करना

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

मूल PPO पेपर (समीकरण 10) में, एडवांटेज, टाइमस्टेप T तक आगे देखते हुए, इस प्रकार व्यक्त किया गया है:

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

इस प्रकार, नीचे दिया सरल सूत्र यह व्यक्त करता है कि चुनने का एडवांटेज: 

• एक विशेष एक्शन 
• एक दिए गए स्टेट में 
• किसी विशेष पॉलिसी के तहत 
• किसी विशेष टाइमस्टेप पर 

इस प्रकार व्यक्त होता है: 

OpenAI भी इस फ़ॉर्मूले का उपयोग RL लागू करने के लिए करता है। नीचे दिया calculate_advantages() फ़ंक्शन एडवांटेज की गणना करता है:

def calculate_advantages(returns, values):
    advantages = returns - values
    # Normalize the advantage
    advantages = (advantages - advantages.mean()) / advantages.std()
    return advantagesसंचालित द्वारा

सरोगेट लॉस और क्लिपिंग मैकेनिज्म

विशेष तकनीकों जैसे PPO के बिना, पॉलिसी लॉस मानक पॉलिसी ग्रेडिएंट लॉस होगा। मानक पॉलिसी ग्रेडिएंट लॉस की गणना इनका गुणनफल लेकर की जाती है:

• पॉलिसी एक्शन प्रायिकताएँ 
• एडवांटेज फ़ंक्शन, जिसकी गणना निम्न के अंतर के रूप में होती है:
• पॉलिसी रिटर्न 
• अपेक्षित वैल्यू

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

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

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

क्लिपिंग मैकेनिज्म

पॉलिसी अनुपात, R, नई और पुरानी पॉलिसियों के बीच का अंतर है और इसे नई तथा पुरानी पॉलिसी पैरामीटरों के तहत पॉलिसी के लॉग प्रायिकताओं के अनुपात के रूप में दिया जाता है:

क्लिप्ड पॉलिसी अनुपात, R', इस तरह बाधित है कि: 

पिछले अनुभाग में दिखाए अनुसार एडवांटेज At तथा ऊपर दिखाए पॉलिसी अनुपात के दिए जाने पर, सरोगेट लॉस की गणना इस प्रकार होती है:

नीचे दिया कोड क्लिपिंग मैकेनिज्म और सरोगेट लॉस को लागू करना दिखाता है। 

def calculate_surrogate_loss(
        actions_log_probability_old,
        actions_log_probability_new,
        epsilon,
        advantages):
    advantages = advantages.detach()
    policy_ratio = (
            actions_log_probability_new - actions_log_probability_old
            ).exp()
    surrogate_loss_1 = policy_ratio * advantages
    surrogate_loss_2 = torch.clamp(
            policy_ratio, min=1.0-epsilon, max=1.0+epsilon
            ) * advantages
    surrogate_loss = torch.min(surrogate_loss_1, surrogate_loss_2)
    return surrogate_lossसंचालित द्वारा

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

अब, आइए एजेंट को ट्रेन करें।

पॉलिसी और वैल्यू लॉस की गणना 

अब हम पॉलिसी और वैल्यू लॉस की गणना करने के लिए तैयार हैं: 

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

ऊपर गणना किए गए दोनों लॉस टेन्सर होते हैं। ग्रेडिएंट डिसेंट स्केलर मानों पर आधारित है। लॉस का एक एकल स्केलर मान प्राप्त करने के लिए, .sum() फ़ंक्शन का उपयोग करके टेन्सर तत्वों का योग लें। नीचे दिया फ़ंक्शन यह दिखाता है: 

def calculate_losses(
        surrogate_loss, entropy, entropy_coefficient, returns, value_pred):
    entropy_bonus = entropy_coefficient * entropy
    policy_loss = -(surrogate_loss + entropy_bonus).sum()
    value_loss = f.smooth_l1_loss(returns, value_pred).sum()
    return policy_loss, value_lossसंचालित द्वारा

ट्रेनिंग लूप परिभाषित करना

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

def init_training():
    states = []
    actions = []
    actions_log_probability = []
    values = []
    rewards = []
    done = False
    episode_reward = 0
    return states, actions, actions_log_probability, values, rewards, done, episode_rewardसंचालित द्वारा

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

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

ट्रेनिंग लूप चलाने से पहले:

• मॉडल को ट्रेनिंग मोड में सेट करें agent.train() का उपयोग करके। 
• पर्यावरण को एक रैंडम स्टेट में रीसेट करें env.reset() का उपयोग करके। यह इस ट्रेनिंग इटरेशन के लिए शुरुआती स्टेट है। 

ट्रेनिंग लूप में हर टाइमस्टेप में क्या होता है, यह चरण बताते हैं: 

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

ट्रेनिंग एपिसोड तब समाप्त होता है जब env.step() फ़ंक्शन done के बूलियन रिटर्न मान के लिए true लौटाता है। 

एपिसोड समाप्त होने के बाद, प्रत्येक टाइमस्टेप से संचित मानों का उपयोग करके इस एपिसोड के क्यूम्युलेटिव रिटर्न की गणना करें, प्रत्येक टाइमस्टेप के रिवॉर्ड को जोड़कर। ऐसा करने के लिए हम पहले बताई गई calculate_returns() फ़ंक्शन का उपयोग करते हैं। इस फ़ंक्शन के इनपुट डिस्काउंट फ़ैक्टर और प्रत्येक टाइमस्टेप से रिवॉर्ड वाले बफ़र हैं। हम इन रिटर्न और प्रत्येक टाइमस्टेप से संचित वैल्यू का उपयोग calculate_advantages() फ़ंक्शन का उपयोग करके एडवांटेज की गणना करने के लिए करते हैं। 

निम्न Python फ़ंक्शन दिखाता है कि इन चरणों को कैसे लागू करें:

def forward_pass(env, agent, optimizer, discount_factor):
    states, actions, actions_log_probability, values, rewards, done, episode_reward = init_training()
    state = env.reset()
    agent.train()
    while not done:
        state = torch.FloatTensor(state).unsqueeze(0)
        states.append(state)
        action_pred, value_pred = agent(state)
        action_prob = f.softmax(action_pred, dim=-1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)
        state, reward, done, _ = env.step(action.item())
        actions.append(action)
        actions_log_probability.append(log_prob_action)
        values.append(value_pred)
        rewards.append(reward)
        episode_reward += reward
    states = torch.cat(states)
    actions = torch.cat(actions)
    actions_log_probability = torch.cat(actions_log_probability)
    values = torch.cat(values).squeeze(-1)
    returns = calculate_returns(rewards, discount_factor)
    advantages = calculate_advantages(returns, values)
    return episode_reward, states, actions, actions_log_probability, advantages, returnsसंचालित द्वारा

मॉडल पैरामीटर अपडेट करना

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

CartPole वातावरण में अधिकतम टाइमस्टेप्स 500 हैं। अधिक जटिल वातावरणों में टाइमस्टेप्स अधिक होते हैं, यहाँ तक कि लाखों। ऐसे मामलों में, ट्रेनिंग रिज़ल्ट्स डेटासेट को बैचों में विभाजित करना आवश्यक है। प्रत्येक बैच में टाइमस्टेप्स की संख्या को ऑप्टिमाइज़ेशन बैच साइज़ कहा जाता है। 

इस प्रकार, मॉडल पैरामीटर अपडेट करने के चरण हैं:

• ट्रेनिंग रिज़ल्ट्स डेटासेट को बैचों में विभाजित करें। 
• प्रत्येक बैच के लिए:
• प्रत्येक स्टेट के लिए एजेंट की क्रिया और पूर्वानुमानित वैल्यू प्राप्त करें।
• इन पूर्वानुमानित एक्शनों का उपयोग नई एक्शन प्रायिकता वितरण का अनुमान लगाने के लिए करें। 
• इस वितरण का उपयोग एंट्रॉपी की गणना के लिए करें। 
• इस वितरण का उपयोग ट्रेनिंग रिज़ल्ट्स डेटासेट में मौजूद क्रियाओं के लॉग प्रायिकताओं को प्राप्त करने के लिए करें। यह उन क्रियाओं के नए लॉग प्रायिकताओं का सेट है। इन ही क्रियाओं के पुराने लॉग प्रायिकताओं का सेट पिछले अनुभाग में समझाए ट्रेनिंग लूप में गणना किया गया था। 
• क्रियाओं के पुराने और नए प्रायिकता वितरणों का उपयोग करके सरोगेट लॉस की गणना करें। 
• सरोगेट लॉस, एंट्रॉपी और एडवांटेज का उपयोग करके पॉलिसी और वैल्यू लॉस की गणना करें। 
• पॉलिसी और वैल्यू लॉस पर अलग-अलग .backward() चलाएँ। यह लॉस फ़ंक्शंस पर ग्रेडिएंट अपडेट करता है। 
• ऑप्टिमाइज़र पर .step() चलाकर पॉलिसी पैरामीटर अपडेट करें। इस मामले में, हम गति और स्थिरता के संतुलन के लिए Adam ऑप्टिमाइज़र का उपयोग करते हैं। 
• पॉलिसी और वैल्यू लॉस को संचित करें। 
• प्रत्येक बैच पर बैकवर्ड पास (ऊपर के ऑपरेशंस) को कुछ बार दोहराएँ, जो पैरामीटर PPO_STEPS के मान पर निर्भर करता है। प्रत्येक बैच पर बैकवर्ड पास को दोहराना कम्प्यूटेशनली कुशल है क्योंकि यह अतिरिक्त फ़ॉरवर्ड पास चलाए बिना ट्रेनिंग डेटासेट के आकार को प्रभावी रूप से बढ़ाता है। सैंपलिंग और ऑप्टिमाइज़ेशन के बीच हर अदला-बदली में वातावरण के स्टेप्स की संख्या को इटरेशन बैच साइज़ कहा जाता है। 
• औसत पॉलिसी लॉस और वैल्यू लॉस लौटाएँ।

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

def update_policy(
        agent,
        states,
        actions,
        actions_log_probability_old,
        advantages,
        returns,
        optimizer,
        ppo_steps,
        epsilon,
        entropy_coefficient):
    BATCH_SIZE = 128
    total_policy_loss = 0
    total_value_loss = 0
    actions_log_probability_old = actions_log_probability_old.detach()
    actions = actions.detach()
    training_results_dataset = TensorDataset(
            states,
            actions,
            actions_log_probability_old,
            advantages,
            returns)
    batch_dataset = DataLoader(
            training_results_dataset,
            batch_size=BATCH_SIZE,
            shuffle=False)
    for _ in range(ppo_steps):
        for batch_idx, (states, actions, actions_log_probability_old, advantages, returns) in enumerate(batch_dataset):
            # get new log prob of actions for all input states
            action_pred, value_pred = agent(states)
            value_pred = value_pred.squeeze(-1)
            action_prob = f.softmax(action_pred, dim=-1)
            probability_distribution_new = distributions.Categorical(
                    action_prob)
            entropy = probability_distribution_new.entropy()
            # estimate new log probabilities using old actions
            actions_log_probability_new = probability_distribution_new.log_prob(actions)
            surrogate_loss = calculate_surrogate_loss(
                    actions_log_probability_old,
                    actions_log_probability_new,
                    epsilon,
                    advantages)
            policy_loss, value_loss = calculate_losses(
                    surrogate_loss,
                    entropy,
                    entropy_coefficient,
                    returns,
                    value_pred)
            optimizer.zero_grad()
            policy_loss.backward()
            value_loss.backward()
            optimizer.step()
            total_policy_loss += policy_loss.item()
            total_value_loss += value_loss.item()
    return total_policy_loss / ppo_steps, total_value_loss / ppo_stepsसंचालित द्वारा

4. PPO एजेंट चलाना 

आइए अंततः PPO एजेंट चलाएँ।

प्रदर्शन का मूल्यांकन 

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

def evaluate(env, agent):
    agent.eval()
    rewards = []
    done = False
    episode_reward = 0
    state = env.reset()
    while not done:
        state = torch.FloatTensor(state).unsqueeze(0)
        with torch.no_grad():
            action_pred, _ = agent(state)
            action_prob = f.softmax(action_pred, dim=-1)
        action = torch.argmax(action_prob, dim=-1)
        state, reward, done, _ = env.step(action.item())
        episode_reward += reward
    return episode_rewardसंचालित द्वारा

ट्रेनिंग परिणामों का विज़ुअलाइज़ेशन

हम ट्रेनिंग प्रक्रिया की प्रगति को विज़ुअलाइज़ करने के लिए Matplotlib लाइब्रेरी का उपयोग करेंगे। नीचे दिया फ़ंक्शन ट्रेनिंग और टेस्टिंग लूप से प्राप्त रिवॉर्ड्स को कैसे प्लॉट करें, दिखाता है:

def plot_train_rewards(train_rewards, reward_threshold):
    plt.figure(figsize=(12, 8))
    plt.plot(train_rewards, label='Training Reward')
    plt.xlabel('Episode', fontsize=20)
    plt.ylabel('Training Reward', fontsize=20)
    plt.hlines(reward_threshold, 0, len(train_rewards), color='y')
    plt.legend(loc='lower right')
    plt.grid()
    plt.show()संचालित द्वारा

def plot_test_rewards(test_rewards, reward_threshold):
    plt.figure(figsize=(12, 8))
    plt.plot(test_rewards, label='Testing Reward')
    plt.xlabel('Episode', fontsize=20)
    plt.ylabel('Testing Reward', fontsize=20)
    plt.hlines(reward_threshold, 0, len(test_rewards), color='y')
    plt.legend(loc='lower right')
    plt.grid()
    plt.show()संचालित द्वारा

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

ट्रेनिंग रिवॉर्ड (ट्रेनिंग वातावरण में पॉलिसी लागू करके प्राप्त)। छवि: लेखक।

टेस्टिंग रिवॉर्ड (टेस्ट वातावरण में पॉलिसी लागू करके प्राप्त)। छवि: लेखक। 

ऊपर दिखाए आउटपुट ग्राफ़्स में, ट्रेनिंग प्रक्रिया की प्रगति देखें:

• रिवॉर्ड कम मानों से शुरू होता है। जैसे-जैसे ट्रेनिंग आगे बढ़ती है, रिवॉर्ड बढ़ते हैं। 
• रिवॉर्ड बढ़ते समय यादृच्छिक रूप से उतार-चढ़ाव करते हैं। यह एजेंट द्वारा पॉलिसी स्पेस का अन्वेषण करने के कारण होता है। 
• ट्रेनिंग समाप्त हो जाती है, और टेस्टिंग रिवॉर्ड कई इटरेशंस के लिए थ्रेशहोल्ड (475) के आसपास स्थिर हो जाते हैं। 
• रिवॉर्ड 500 पर कैप्ड हैं। ये वातावरण (Gym CartPole v1) द्वारा लगाए गए प्रतिबंध हैं। 

इसी प्रकार, आप इटरेशंस के दौरान वैल्यू और पॉलिसी लॉस को भी प्लॉट कर सकते हैं:

def plot_losses(policy_losses, value_losses):
    plt.figure(figsize=(12, 8))
    plt.plot(value_losses, label='Value Losses')
    plt.plot(policy_losses, label='Policy Losses')
    plt.xlabel('Episode', fontsize=20)
    plt.ylabel('Loss', fontsize=20)
    plt.legend(loc='lower right')
    plt.grid()
    plt.show()संचालित द्वारा

नीचे दिया उदाहरण प्लॉट ट्रेनिंग एपिसोड्स के दौरान ट्रैक किए गए लॉस दिखाता है:

ट्रेनिंग प्रक्रिया के दौरान वैल्यू और पॉलिसी लॉस। छवि: लेखक

प्लॉट को देखें और ध्यान दें:

• लॉस यादृच्छिक रूप से वितरित प्रतीत होते हैं और किसी पैटर्न का पालन नहीं करते। 
• यह RL ट्रेनिंग की सामान्य विशेषता है, जहाँ लक्ष्य लॉस को न्यूनतम करना नहीं, बल्कि रिवॉर्ड को अधिकतम करना होता है। 

PPO एल्गोरिदम चलाएँ

अब आपके पास PPO का उपयोग करके एजेंट को ट्रेन करने के लिए सभी घटक हैं। सब कुछ एक साथ रखने के लिए, आपको यह करना होगा:

• डिस्काउंट फ़ैक्टर, बैच साइज़, लर्निंग रेट आदि जैसे हाइपरपैरामीटर घोषित करें। 
• हर इटरेशन से रिवॉर्ड और लॉस स्टोर करने के लिए बफ़र्स को null ऐरे के रूप में इंस्टैंशिएट करें। 
• create_agent() फ़ंक्शन का उपयोग करके एक एजेंट इंस्टेंस बनाएँ।
• forward_pass() और update_policy() फ़ंक्शंस का उपयोग करके क्रमिक रूप से फ़ॉरवर्ड और बैकवर्ड पास चलाएँ। 
• evaluate() फ़ंक्शन का उपयोग करके पॉलिसी के प्रदर्शन का परीक्षण करें। 
• ट्रेनिंग और इवैल्युएशन फ़ंक्शंस से प्राप्त पॉलिसी, वैल्यू लॉस और रिवॉर्ड को संबंधित बफ़र्स में जोड़ें। 
• पिछले कुछ टाइमस्टेप्स पर रिवॉर्ड और लॉस का औसत निकालें। नीचे दिए उदाहरण में पिछले 40 टाइमस्टेप्स पर औसत लिया गया है। 
• हर कुछ स्टेप्स पर इवैल्युएशन के परिणाम प्रिंट करें। नीचे दिया उदाहरण हर 10 स्टेप पर प्रिंट करता है। 
• जब औसत रिवॉर्ड एक निश्चित थ्रेशहोल्ड पार कर जाए, तो प्रक्रिया समाप्त करें। 

नीचे दिया कोड दिखाता है कि Python में ऐसा फ़ंक्शन कैसे घोषित करें:

def run_ppo():
    MAX_EPISODES = 500
    DISCOUNT_FACTOR = 0.99
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    PPO_STEPS = 8
    N_TRIALS = 100
    EPSILON = 0.2
    ENTROPY_COEFFICIENT = 0.01
    HIDDEN_DIMENSIONS = 64
    DROPOUT = 0.2
    LEARNING_RATE = 0.001
    train_rewards = []
    test_rewards = []
    policy_losses = []
    value_losses = []
    agent = create_agent(HIDDEN_DIMENSIONS, DROPOUT)
    optimizer = optim.Adam(agent.parameters(), lr=LEARNING_RATE)
    for episode in range(1, MAX_EPISODES+1):
        train_reward, states, actions, actions_log_probability, advantages, returns = forward_pass(
                env_train,
                agent,
                optimizer,
                DISCOUNT_FACTOR)
        policy_loss, value_loss = update_policy(
                agent,
                states,
                actions,
                actions_log_probability,
                advantages,
                returns,
                optimizer,
                PPO_STEPS,
                EPSILON,
                ENTROPY_COEFFICIENT)
        test_reward = evaluate(env_test, agent)
        policy_losses.append(policy_loss)
        value_losses.append(value_loss)
        train_rewards.append(train_reward)
        test_rewards.append(test_reward)
        mean_train_rewards = np.mean(train_rewards[-N_TRIALS:])
        mean_test_rewards = np.mean(test_rewards[-N_TRIALS:])
        mean_abs_policy_loss = np.mean(np.abs(policy_losses[-N_TRIALS:]))
        mean_abs_value_loss = np.mean(np.abs(value_losses[-N_TRIALS:]))
        if episode % PRINT_INTERVAL == 0:
            print(f'Episode: {episode:3} | \
                  Mean Train Rewards: {mean_train_rewards:3.1f} \
                  | Mean Test Rewards: {mean_test_rewards:3.1f} \
                  | Mean Abs Policy Loss: {mean_abs_policy_loss:2.2f} \
                  | Mean Abs Value Loss: {mean_abs_value_loss:2.2f}')
        if mean_test_rewards >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break
    plot_train_rewards(train_rewards, REWARD_THRESHOLD)
    plot_test_rewards(test_rewards, REWARD_THRESHOLD)
    plot_losses(policy_losses, value_losses)संचालित द्वारा

प्रोग्राम चलाएँ: 

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

आउटपुट नीचे दिए सैंपल जैसा दिखना चाहिए: 

Episode:  10 | Mean Train Rewards: 22.3 | Mean Test Rewards: 30.4 | Mean Abs Policy Loss: 0.37 | Mean Abs Value Loss: 0.39 
Episode:  20 | Mean Train Rewards: 38.6 | Mean Test Rewards: 69.8 | Mean Abs Policy Loss: 0.46 | Mean Abs Value Loss: 0.37 
.
.
.
Episode: 100 | Mean Train Rewards: 289.5 | Mean Test Rewards: 427.3 | Mean Abs Policy Loss: 1.73 | Mean Abs Value Loss: 0.21 
Episode: 110 | Mean Train Rewards: 357.7 | Mean Test Rewards: 461.4 | Mean Abs Policy Loss: 1.86 | Mean Abs Value Loss: 0.22 
Reached reward threshold in 116 episodesसंचालित द्वारा

आप कार्यरत प्रोग्राम को इस DataLab नोटबुक पर देख और चला सकते हैं!

5. हाइपरपैरामीटर ट्यूनिंग और ऑप्टिमाइज़ेशन

मशीन लर्निंग में, हाइपरपैरामीटर ट्रेनिंग प्रक्रिया को नियंत्रित करते हैं। नीचे, मैं PPO में उपयोग किए जाने वाले कुछ महत्वपूर्ण हाइपरपैरामीटर समझाता हूँ: 

• लर्निंग रेट: लर्निंग रेट तय करता है कि प्रत्येक इटरेशन में पॉलिसी पैरामीटर कितने बदल सकते हैं। स्टोकेस्टिक ग्रेडिएंट डिसेंट में, प्रत्येक इटरेशन में पॉलिसी पैरामीटर जितनी मात्रा से अपडेट होते हैं, वह लर्निंग रेट और ग्रेडिएंट के गुणनफल से तय होती है। 
• क्लिपिंग पैरामीटर: इसे एप्सिलॉन, ε, भी कहा जाता है। यह तय करता है कि पॉलिसी अनुपात कितनी सीमा तक क्लिप किया जाए। नई और पुरानी पॉलिसी के अनुपात को सीमा [1-ε, 1+ε] में रहने की अनुमति है। जब यह इस सीमा से परे होता है, तो इसे कृत्रिम रूप से इसी सीमा में क्लिप कर दिया जाता है। 
• बैच साइज़: यह प्रत्येक ग्रेडिएंट अपडेट के लिए विचार किए जाने वाले स्टेप्स की संख्या को संदर्भित करता है। PPO में, बैच साइज़ उन टाइमस्टेप्स की संख्या है जिनकी आवश्यकता पॉलिसी लागू करने और पॉलिसी पैरामीटर अपडेट करने के लिए सरोगेट लॉस की गणना करने में होती है। इस लेख में, हमने 64 के बैच साइज़ का उपयोग किया। 
• इटरेशन स्टेप्स: यह वह संख्या है जितनी बार प्रत्येक बैच का पुन: उपयोग बैकवर्ड पास चलाने के लिए किया जाता है। इस लेख के कोड में इसे PPO_STEPS कहा गया है। जटिल वातावरणों में, कई बार फ़ॉरवर्ड पास चलाना कम्प्यूटेशनली महंगा होता है। एक अधिक कुशल विकल्प प्रत्येक बैच को कुछ बार फिर से चलाना है। आमतौर पर 5 से 10 के बीच का मान उपयोग करने की सिफारिश की जाती है। 
• डिस्काउंट फ़ैक्टर: इसे गामा, γ, भी कहा जाता है। यह व्यक्त करता है कि तात्कालिक रिवॉर्ड भविष्य के रिवॉर्ड की तुलना में कितने अधिक मूल्यवान हैं। यह पैसे के समय मूल्य की गणना में ब्याज दरों की अवधारणा के समान है। जब 0 के करीब होता है, तो इसका मतलब है कि भविष्य के रिवॉर्ड कम मूल्यवान हैं और एजेंट को तात्कालिक रिवॉर्ड को प्राथमिकता देनी चाहिए। जब 1 के करीब होता है, तो इसका मतलब है कि भविष्य के रिवॉर्ड महत्वपूर्ण हैं। 
• एंट्रॉपी कोएफ़िशिएंट: एंट्रॉपी कोएफ़िशिएंट एंट्रॉपी बोनस तय करता है, जिसकी गणना एंट्रॉपी कोएफ़िशिएंट और वितरण की एंट्रॉपी के गुणनफल के रूप में होती है। एंट्रॉपी बोनस की भूमिका पॉलिसी में अधिक रैंडमनेस जोड़ना है। यह एजेंट को पॉलिसी स्पेस का अन्वेषण करने के लिए प्रोत्साहित करता है। हालाँकि, जब यह रैंडमनेस बहुत अधिक होती है, तो ट्रेनिंग किसी इष्टतम पॉलिसी पर कन्वर्ज नहीं होती। 
• ट्रेनिंग के लिए सफलता के मापदंड: आपको यह तय करने के लिए मापदंड सेट करने होंगे कि ट्रेनिंग कब सफल मानी जाए। एक आम तरीका यह है कि शर्त रखें कि पिछले N ट्रायल्स (एपिसोड्स) पर औसत रिवॉर्ड एक निश्चित थ्रेशहोल्ड से ऊपर हो। ऊपर दिए उदाहरण कोड में, यह वैरिएबल N_TRIALS से व्यक्त किया गया है। जब इसे उच्च मान पर सेट किया जाता है, तो ट्रेनिंग में अधिक समय लगता है क्योंकि पॉलिसी को अधिक एपिसोड्स में थ्रेशहोल्ड रिवॉर्ड हासिल करना होता है। यह अधिक मज़बूत पॉलिसी का परिणाम देता है, लेकिन कम्प्यूटेशनली अधिक महंगा होता है। ध्यान दें कि PPO एक स्टोकेस्टिक पॉलिसी है, और ऐसे एपिसोड होंगे जब एजेंट थ्रेशहोल्ड पार नहीं करेगा। इसलिए, यदि N_TRIALS का मान बहुत अधिक है, तो आपकी ट्रेनिंग समाप्त नहीं भी हो सकती।

PPO प्रदर्शन को ऑप्टिमाइज़ करने की रणनीतियाँ

PPO एल्गोरिदम के प्रदर्शन को ऑप्टिमाइज़ करना ट्रायल-एंड-एरर और विभिन्न हाइपरपैरामीटर मानों के साथ प्रयोग करना शामिल करता है। फिर भी, कुछ व्यापक दिशानिर्देश हैं: 

• डिस्काउंट फ़ैक्टर: जब दीर्घकालिक रिवॉर्ड महत्वपूर्ण हों, जैसे CartPole वातावरण में, जहाँ डंडे को समय के साथ स्थिर रहना होता है, तो 0.99 जैसे मध्यम गामा मान से शुरू करें। 
• एंट्रॉपी बोनस: जटिल वातावरणों में, एजेंट को इष्टतम पॉलिसी खोजने के लिए एक्शन स्पेस का अन्वेषण करना चाहिए। एंट्रॉपी बोनस एक्सप्लोरेशन को बढ़ावा देता है। एंट्रॉपी बोनस सरोगेट लॉस में जोड़ा जाता है। एंट्रॉपी कोएफ़िशिएंट तय करने से पहले सरोगेट लॉस और वितरण की एंट्रॉपी की मात्रा जाँचें। इस लेख में, हमने 0.01 का एंट्रॉपी कोएफ़िशिएंट उपयोग किया।
• क्लिपिंग पैरामीटर: क्लिपिंग पैरामीटर यह तय करता है कि अपडेटेड पॉलिसी वर्तमान पॉलिसी से कितनी अलग हो सकती है। क्लिपिंग पैरामीटर का बड़ा मान वातावरण के बेहतर अन्वेषण को प्रोत्साहित करता है, लेकिन यह ट्रेनिंग को अस्थिर करने का जोखिम भी पैदा करता है। आपको ऐसा क्लिपिंग पैरामीटर चाहिए जो क्रमिक अन्वेषण की अनुमति दे, जबकि अस्थिर करने वाले अपडेट्स को रोके। इस लेख में, हमने 0.2 का क्लिपिंग पैरामीटर उपयोग किया।
• लर्निंग रेट: जब लर्निंग रेट बहुत अधिक होता है, तो पॉलिसी बड़े कदमों में अपडेट होती है, और हर इटरेशन तथा ट्रेनिंग प्रक्रिया अस्थिर हो सकती है। जब यह बहुत कम होता है, तो ट्रेनिंग में बहुत समय लगता है। इस ट्यूटोरियल में हमने 0.001 का लर्निंग रेट उपयोग किया, जो इस वातावरण के लिए ठीक काम करता है। कई मामलों में, 1e-5 का लर्निंग रेट उपयोग करने की सिफारिश की जाती है। 

PPO में चुनौतियाँ और सर्वोत्तम प्रथाएँ

PPO की अवधारणाएँ और इम्प्लीमेंटेशन विवरण समझाने के बाद, आइए चुनौतियों और सर्वोत्तम प्रथाओं पर चर्चा करें। 

PPO को ट्रेन करने में आम चुनौतियाँ

हालाँकि PPO व्यापक रूप से उपयोग किया जाता है, वास्तविक दुनिया की समस्याओं को सफलतापूर्वक हल करने के लिए संभावित चुनौतियों के प्रति जागरूक रहना आवश्यक है। कुछ ऐसी चुनौतियाँ हैं:

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

PPO मॉडल को ट्रेन करने के सर्वोत्तम अभ्यास

PPO का उपयोग करके अच्छे परिणाम पाने के लिए, मैं कुछ सर्वोत्तम प्रथाएँ सुझाता हूँ, जैसे:

• इनपुट फीचर्स को नॉर्मलाइज़ करें: रिटर्न और एडवांटेज के मानों को नॉर्मलाइज़ करना डेटा में परिवर्तनशीलता को कम करता है और स्थिर ग्रेडिएंट अपडेट्स की ओर ले जाता है। डेटा को नॉर्मलाइज़ करने से सभी मान एक सुसंगत संख्यात्मक सीमा में आ जाते हैं। यह आउट्लायर और चरम मानों के प्रभाव को कम करने में मदद करता है, जो अन्यथा ग्रेडिएंट अपडेट्स को विकृत कर सकते हैं और कन्वर्जेंस को धीमा कर सकते हैं। 
• उचित रूप से बड़े बैच साइज़ का उपयोग करें: छोटे बैच तेज़ अपडेट और ट्रेनिंग की अनुमति देते हैं, लेकिन स्थानीय ऑप्टिमा पर कन्वर्जेंस और ट्रेनिंग प्रक्रिया में अस्थिरता का कारण बन सकते हैं। बड़े बैच साइज़ एजेंट को मज़बूत पॉलिसी सीखने की अनुमति देते हैं, जिससे ट्रेनिंग प्रक्रिया स्थिर होती है। हालाँकि, बहुत बड़े बैच साइज़ भी उप-इष्टतम हैं। कम्प्यूटेशनल लागत बढ़ाने के अलावा, वे पॉलिसी अपडेट्स को वैल्यू फ़ंक्शन के प्रति कम उत्तरदायी बनाते हैं क्योंकि ग्रेडिएंट अपडेट बड़े बैचों पर लिए गए औसत पर आधारित होते हैं। इसके अलावा, यह उस विशिष्ट बैच पर अपडेट्स को ओवरफ़िट करने का कारण बन सकता है। 
• इटरेशन स्टेप्स: आम तौर पर प्रत्येक बैच का 5-10 इटरेशन के लिए पुन: उपयोग करना उचित होता है। यह ट्रेनिंग प्रक्रिया को अधिक कुशल बनाता है। एक ही बैच का बहुत अधिक बार पुन: उपयोग करने से ओवरफ़िटिंग होती है। कोड में इस हाइपरपैरामीटर को PPO_STEPS कहा गया है। 
• नियमित इवैल्युएशन करें: ओवरफ़िटिंग का पता लगाने के लिए, पॉलिसी की प्रभावशीलता की समय-समय पर निगरानी करना आवश्यक है। यदि पॉलिसी कुछ परिदृश्यों में अप्रभावी साबित होती है, तो आगे की ट्रेनिंग या फाइन-ट्यूनिंग आवश्यक हो सकती है। 
• हाइपरपैरामीटर ट्यून करें: जैसा कि पहले समझाया गया, PPO ट्रेनिंग हाइपरपैरामीटर मानों के प्रति संवेदनशील है। अपनी विशेष समस्या के लिए सही मानों का सेट निर्धारित करने के लिए विभिन्न हाइपरपैरामीटर मानों के साथ प्रयोग करें। 
• शेयर्ड बैकबोन नेटवर्क: जैसा कि इस लेख में दर्शाया गया है, शेयर्ड बैकबोन का उपयोग एक्टर और क्रिटिक नेटवर्क के बीच असंतुलन को रोकता है। एक्टर और क्रिटिक के बीच बैकबोन नेटवर्क साझा करने से साझा फीचर एक्सट्रैक्शन और वातावरण की समान समझ में मदद मिलती है। यह सीखने की प्रक्रिया को अधिक कुशल और स्थिर बनाता है। यह एल्गोरिदम की कम्प्यूटेशनल स्पेस और टाइम कॉम्प्लेक्सिटी को कम करने में भी मदद करता है। 
• हिडन लेयर्स की संख्या और आकार: अधिक जटिल वातावरणों के लिए हिडन लेयर्स और उनके आयाम बढ़ाएँ। CartPole जैसे सरल समस्याओं को एक सिंगल हिडन लेयर से हल किया जा सकता है। इस लेख में उपयोग की गई हिडन लेयर 64 आयाम की है। नेटवर्क को आवश्यकता से बहुत बड़ा बनाना कम्प्यूटेशनली व्यर्थ है और इसे अस्थिर बना सकता है। 
• अर्ली स्टॉपिंग: जब इवैल्युएशन मेट्रिक्स पूरी हो जाएँ तो ट्रेनिंग को रोक देना ओवरट्रेनिंग को रोकता है और संसाधनों की बर्बादी से बचाता है। एक सामान्य इवैल्युएशन मेट्रिक तब होता है जब एजेंट पिछले N इवेंट्स में थ्रेशहोल्ड रिवॉर्ड से अधिक प्राप्त करता है। 

निष्कर्ष

इस लेख में, हमने RL समस्याओं को हल करने के एक तरीके के रूप में PPO पर चर्चा की। फिर हमने PyTorch का उपयोग करके PPO लागू करने के चरणों का विवरण दिया। अंत में, हमने PPO के लिए कुछ प्रदर्शन संबंधी सुझाव और सर्वोत्तम प्रथाएँ प्रस्तुत कीं। 

सीखने का सबसे अच्छा तरीका है कि आप स्वयं कोड लागू करें। आप कोड को Gym के अन्य क्लासिक कंट्रोल वातावरणों के साथ काम करने के लिए भी संशोधित कर सकते हैं। Python और OpenAI के Gymnasium का उपयोग करके RL एजेंट्स को लागू करना सीखने के लिए, कोर्स Reinforcement Learning with Gymnasium in Python का अनुसरण करें!