जिमनेज़ियम के साथ रिइनफोर्समेंट लर्निंग: एक व्यावहारिक गाइड

Gymnasium सेटअप करना

Gymnasium को विभिन्न डिपेंडेंसी प्रोग्राम्स (जैसे NumPy और PyTorch) के विशिष्ट संस्करणों (न कि नवीनतम रिलीज़) की आवश्यकता होती है। इसलिए, हम अनुशंसा करते हैं कि आप एक नया Conda या venv एनवायरनमेंट या नया नोटबुक बनाएँ, ताकि Gymnasium इंस्टॉल और उपयोग कर सकें और RL प्रोग्राम चला सकें। 

आप इस DataLab वर्कबुक का उपयोग करके ट्यूटोरियल के साथ-साथ चल सकते हैं।

Gymnasium इंस्टॉल करना

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

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

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

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

उपरोक्त कमांड Gymnasium और डिपेंडेंसीज़ के सही संस्करण इंस्टॉल करता है।

Gymnasium एनवायरनमेंट्स की खोज

नवंबर 2024 तक, Gymnasium में 60 से अधिक इनबिल्ट एनवायरनमेंट्स शामिल हैं। उपलब्ध इनबिल्ट एनवायरनमेंट्स ब्राउज़ करने के लिए gym.envs.registry.all() फ़ंक्शन का उपयोग करें, जैसा कि नीचे के उदाहरण में दर्शाया गया है: 

import gymnasium as gym
for i in gym.envs.registry.keys():
	print(i)संचालित द्वारा

आप Gymnasium होमपेज भी देख सकते हैं। बाएं कॉलम में सभी एनवायरनमेंट्स के लिंक हैं। प्रत्येक एनवायरनमेंट का वेबपेज उसके बारे में विवरण देता है, जैसे क्रियाएँ, स्टेट्स आदि। 

एनवायरनमेंट्स को श्रेणियों में संगठित किया गया है, जैसे क्लासिक कंट्रोल, Box2D, आदि। नीचे, मैं प्रत्येक समूह में कुछ सामान्य एनवायरनमेंट्स सूचीबद्ध करता हूँ:

• क्लासिक कंट्रोल: ये RL विकास में प्रयुक्त मानक एनवायरनमेंट हैं; कई पाठ्यपुस्तक उदाहरणों का आधार बनते हैं। ये नए RL एल्गोरिथ्म का परीक्षण और बेंचमार्क करने के लिए जटिलता और सरलता का सही संयोजन देते हैं। Gymnasium में क्लासिक कंट्रोल एनवायरनमेंट्स में शामिल हैं: 
• Acrobot
• Cart Pole
• Mountain Car Discrete
• Mountain Car Continuous
• Pendulum
• Box2D: Box2D गेम्स के लिए एक 2D फिज़िक्स इंजन है। इस इंजन पर आधारित एनवायरनमेंट्स में ये सरल गेम शामिल हैं:
• Lunar Lander
• Car Racing
• ToyText: ये छोटे और सरल एनवायरनमेंट होते हैं, जो अक्सर RL एल्गोरिथ्म को डिबग करने में उपयोग किए जाते हैं। इनमें से कई एनवायरनमेंट छोटे ग्रिड वर्ल्ड मॉडल और सरल कार्ड गेम्स पर आधारित हैं। उदाहरण: 
• Blackjack
• Taxi
• Frozen Lake
• MuJoCo: मल्टी-जॉइंट डायनेमिक्स विथ कॉन्टैक्ट (MuJoCo) एक ओपन-सोर्स फिज़िक्स इंजन है, जो रोबोटिक्स, बायोमैकेनिक्स, ML आदि जैसे अनुप्रयोगों के लिए एनवायरनमेंट्स का सिमुलेशन करता है। Gymnasium में MuJoCo एनवायरनमेंट्स में शामिल हैं:
• Ant
• Hopper
• Humanoid
• Swimmer
• आदि

इनबिल्ट एनवायरनमेंट्स के अलावा, Gymnasium को समान API का उपयोग करते हुए कई बाहरी एनवायरनमेंट्स के साथ भी उपयोग किया जा सकता है। 

हम इस ट्यूटोरियल में मानक क्लासिक कंट्रोल एनवायरनमेंट्स में से एक का उपयोग करेंगे। किसी विशेष एनवायरनमेंट को आयात करने के लिए .make() कमांड का उपयोग करें और आर्ग्युमेंट के रूप में एनवायरनमेंट का नाम पास करें। उदाहरण के लिए, CartPole (संस्करण 1) पर आधारित नया एनवायरनमेंट बनाने के लिए, नीचे दिया कमांड उपयोग करें: 

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

Gymnasium में रिइनफोर्समेंट लर्निंग अवधारणाएँ समझना

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

एक RL एनवायरनमेंट के घटक

RL एनवायरनमेंट के मुख्य घटक इस प्रकार हैं: 

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

ऑब्ज़र्वेशन स्पेस और एक्शन स्पेस

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

एक स्पेस गणितीय सेट के समान है। स्पैन में वस्तुओं X का स्पेस X की सभी संभावित इंस्टैंसेज़ को शामिल करता है। X का स्पेस सभी X प्रकार की वस्तुओं की संरचना (सिंटैक्स और फ़ॉर्मेट) भी परिभाषित करता है। प्रत्येक Gymnasium एनवायरनमेंट में दो स्पेसेज़ होते हैं—एक्शन स्पेस, action_space, और ऑब्ज़र्वेशन स्पेस, observation_space। एक्शन और ऑब्ज़र्वेशन दोनों स्पेस, पैरेंट gymnasium.spaces.Space सुपरक्लास से व्युत्पन्न होते हैं। 

ऑब्ज़र्वेशन स्पेस 

ऑब्ज़र्वेशन स्पेस वह स्पेस है जिसमें सभी संभावित ऑब्ज़र्वेशन शामिल होते हैं। यह यह भी परिभाषित करता है कि ऑब्ज़र्वेशन किस फ़ॉर्मेट में संग्रहीत हैं। ऑब्ज़र्वेशन स्पेस आमतौर पर डेटा टाइप Box के एक ऑब्जेक्ट के रूप में दर्शाया जाता है। यह एक ndarray है जो ऑब्ज़र्वेशन के पैरामीटर्स का वर्णन करता है। बॉक्स प्रत्येक डायमेंशन की सीमाएँ निर्दिष्ट करता है। आप किसी एनवायरनमेंट के लिए observation_space मेथड का उपयोग करके ऑब्ज़र्वेशन स्पेस देख सकते हैं:

print("observation space: ", env.observation_space)संचालित द्वारा

CartPole-v1 के मामले में, आउटपुट नीचे दिए उदाहरण जैसा दिखता है: 

observation space:  Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)संचालित द्वारा

इस उदाहरण में, CartPole-v1 का ऑब्ज़र्वेशन स्पेस 4 डायमेंशनों का है। ऑब्ज़र्वेशन एरे के 4 अवयव हैं:

• कार्ट पोज़िशन - -4.8 से +4.8 के बीच बदलता है
• कार्ट वेलोसिटी - - से + के बीच रहता है
• पोल ऐंगल - -0.4189 से +0.4189 के बीच बदलता है
• पोल ऐंगुलर वेलोसिटी -  - से + के बीच रहता है

किसी व्यक्तिगत ऑब्ज़र्वेशन एरे का उदाहरण देखने के लिए .reset() कमांड का उपयोग करें। 

observation, info = env.reset()
print("observation: ", observation)संचालित द्वारा

CartPole-v1 के मामले में, आउटपुट नीचे दिए उदाहरण जैसा दिखता है: 

[ 0.03481963 -0.0277232   0.01703267 -0.04870504]                                                                                                       संचालित द्वारा

इस एरे के चार अवयव, पहले बताए अनुसार, चार अवलोकित मात्राओं (कार्ट पोज़िशन, कार्ट वेलोसिटी, पोल ऐंगल, पोल ऐंगुलर वेलोसिटी) से मेल खाते हैं। 

एक्शन स्पेस

एक्शन स्पेस में वे सभी संभावित क्रियाएँ शामिल होती हैं जो एजेंट कर सकता है। एक्शन स्पेस यह भी परिभाषित करता है कि क्रियाएँ किस फ़ॉर्मेट में दर्शाई जाती हैं। किसी एनवायरनमेंट के लिए आप action_space मेथड का उपयोग करके एक्शन स्पेस देख सकते हैं:

print("action space: ", env.action_space)संचालित द्वारा

CartPole-v1 के मामले में, आउटपुट नीचे दिए उदाहरण जैसा दिखता है: 

action space:  Discrete(2)संचालित द्वारा

CartPole-v1 के मामले में, एक्शन स्पेस डिस्क्रीट है। कुल दो क्रियाएँ हैं जो एजेंट कर सकता है:

• 0: कार्ट को बाएँ धकेलना
• 1: कार्ट को दाएँ धकेलना

Gymnasium के साथ अपना पहला RL एजेंट बनाना

पिछले अनुभागों में, हमने RL और Gymnasium की बुनियादी अवधारणाएँ देखीं। इस अनुभाग में, आप सीखेंगे कि Gymnasium का उपयोग करके एक RL एजेंट कैसे बनाया जाए। 

एनवायरनमेंट बनाना और रीसेट करना

पहला कदम एनवायरनमेंट का एक इंस्टेंस बनाना है। नए एनवायरनमेंट बनाने के लिए .make() मेथड का उपयोग करें। 

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

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

SEED = 1111
env.reset(seed=SEED)संचालित द्वारा

क्रियाओं का सैम्पलिंग भी रैंडमनेस शामिल करता है। इस रैंडमनेस को नियंत्रित करने और पूरी तरह पुनरुत्पाद्य प्रशिक्षण पथ पाने के लिए, हम NumPy और PyTorch के रैंडम जेनरेटर को सीड कर सकते हैं:

np.random.seed(SEED)
torch.manual_seed(SEED)संचालित द्वारा

रैंडम बनाम बुद्धिमान क्रियाएँ

मार्कोव प्रक्रिया के हर स्टेप में, एजेंट रैंडम रूप से कोई क्रिया चुन सकता है और टर्मिनल स्टेट तक पहुँचने तक एनवायरनमेंट को एक्सप्लोर कर सकता है। रैंडम क्रियाएँ चुनने पर: 

• टर्मिनल स्टेट तक पहुँचने में बहुत समय लग सकता है।
• संचयी रिवार्ड्स उस स्तर से कहीं कम होंगे जो हो सकते थे।

एजेंट को अपने पिछले अनुभवों (एनवायरनमेंट के साथ अंतर्क्रिया) के आधार पर क्रियाओं के चयन को अनुकूलित करने के लिए प्रशिक्षित करना, दीर्घकालीन रिवार्ड्स को अधिकतम करने के लिए अधिक कुशल है। 

अनट्रेंड एजेंट रैंडमली इनिशियलाइज़ पॉलिसी पर आधारित रैंडम क्रियाओं से शुरू करता है। यह पॉलिसी आमतौर पर एक न्यूरल नेटवर्क के रूप में दर्शायी जाती है। प्रशिक्षण के दौरान, एजेंट रिवार्ड्स को अधिकतम करने वाली सर्वोत्तम पॉलिसी सीखता है। RL में, प्रशिक्षण प्रक्रिया को पॉलिसी ऑप्टिमाइज़ेशन भी कहा जाता है। 

पॉलिसी ऑप्टिमाइज़ेशन के विभिन्न तरीके हैं। बेलमैन समीकरण बताते हैं कि RL पॉलिसीज़ का मान कैसे निकाला जाए और सर्वोत्तम पॉलिसी कैसे निर्धारित की जाए। इस ट्यूटोरियल में, हम पॉलिसी ग्रेडिएंट्स नामक एक सरल तकनीक का उपयोग करेंगे। अन्य तरीकों में Proximal Policy Optimization (PPO) शामिल है। 

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

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

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

हम पॉलिसी लागू करने के लिए एक न्यूरल नेटवर्क का उपयोग करते हैं। क्योंकि CartPole-v1 एक सरल एनवायरनमेंट है, हम ऐसा नेटवर्क उपयोग करते हैं जिसमें:

• इनपुट डायमेंशन, एनवायरनमेंट के ऑब्ज़र्वेशन स्पेस की डाइमेंशनलिटी के बराबर हों। 
• 64 न्यूरॉन्स वाली एकल हिडन लेयर। 
• आउटपुट डायमेंशन, एनवायरनमेंट के एक्शन स्पेस की डाइमेंशनलिटी के बराबर हों।

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

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संचालित द्वारा

रिवार्ड संग्रह और फॉरवर्ड पास

जैसा कि बताया गया, मार्कोव प्रक्रिया के हर स्टेप में, एजेंट की क्रिया और स्टेट के आधार पर एनवायरनमेंट एक रिवार्ड देता है। RL में लक्ष्य कुल रिटर्न को अधिकतम करना है। 

• हर समय-चरण पर रिटर्न उस स्टेप तक प्राप्त रिवार्ड्स का संचयी योग है। 
• हर एपिसोड में कुल रिटर्न, उस एपिसोड के सभी स्टेपवाइज़ रिवार्ड्स को जोड़कर प्राप्त किया जाता है। अतः कुल रिटर्न, अंतिम समय-चरण का रिटर्न होता है (जब एजेंट टर्मिनल स्टेट तक पहुँचता है)। 

व्यवहार में, रिवार्ड्स को जोड़ते समय, आम तौर पर यह किया जाता है: 

• भविष्य के रिवार्ड्स को डिस्काउंट फैक्टर से समायोजित करना। 
• स्टेपवाइज़ रिटर्न्स के एरे को नॉर्मलाइज़ करना ताकि प्रशिक्षण स्मूथ और स्थिर रहे। 

नीचे दिया कोड बताता है कि यह कैसे करें: 

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() फ़ंक्शन का उपयोग करके एनवायरनमेंट में एजेंट को टर्मिनेशन तक क्रमिक रूप से चलाएँ:
• एनवायरनमेंट की स्टेट का ऑब्ज़र्वेशन प्राप्त करें।
• ऑब्ज़र्वेशन के आधार पर पॉलिसी द्वारा पूर्वानुमानित क्रिया प्राप्त करें।
• Softmax फ़ंक्शन का उपयोग करके पूर्वानुमानित क्रिया को लेने की प्रायिकता का अनुमान लगाएँ।
• इन अनुमानित प्रायिकताओं के आधार पर एक श्रेणीबद्ध प्रायिकता वितरण का अनुकरण करें।
• एजेंट की क्रिया प्राप्त करने के लिए इस वितरण से सैंपल लें।
• सिम्युलेटेड वितरण से सैंपल की गई क्रिया की लॉग-प्रायिकता का अनुमान लगाएँ। 
• हर स्टेप से एक्शन्स की लॉग-प्रायिकता और रिवार्ड्स को उनके-अपने बफर्स में जोड़ें। 
• रिवार्ड्स के आधार पर हर स्टेप के रिटर्न के नॉर्मलाइज़्ड और डिस्काउंटेड मानों का अनुमान लगाएँ। 

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()संचालित द्वारा

रिटर्न्स के ग्रेडिएंट के आधार पर पॉलिसी को अपडेट करना पॉलिसी ग्रेडिएंट मेथड कहलाता है। 

पॉलिसी का प्रशिक्षण

अब हमारे पास पॉलिसी को प्रशिक्षित और मूल्यांकित करने के लिए सभी घटक हैं। हम प्रशिक्षण लूप को निम्नलिखित चरणों के अनुसार लागू करते हैं:  

शुरू करने से पहले, हम हाइपरपैरामीटर्स घोषित करते हैं, एक पॉलिसी बनाते हैं, और एक ऑप्टिमाइज़र तैयार करते हैं:

• हाइपरपैरामीटर्स को Python कॉन्स्टेंट्स के रूप में घोषित करें:
• MAX_EPOCHS वह अधिकतम संख्या है जितनी बार हम पॉलिसी को प्रशिक्षित करने के लिए इटरेशन चलाने को तैयार हैं। 
• DISCOUNT_FACTOR भविष्य के समय-चरणों के रिवार्ड्स की सापेक्ष महत्ता तय करता है। 1 का डिस्काउंट फैक्टर मतलब सभी रिवार्ड्स समान रूप से महत्वपूर्ण हैं, जबकि 0 का मान मतलब केवल वर्तमान समय-चरण का रिवार्ड महत्वपूर्ण है। 
• N_TRIALS वे एपिसोड्स की संख्या है जिन पर हम रिटर्न्स का औसत लेकर एजेंट के प्रदर्शन का मूल्यांकन करते हैं। यदि N_TRIALS एपिसोड्स पर औसत रिटर्न थ्रेशहोल्ड से ऊपर है, तो हम प्रशिक्षण को सफल मानते हैं। 
• REWARD_THRESHOLD: यदि पॉलिसी थ्रेशहोल्ड से अधिक रिटर्न प्राप्त कर सकती है, तो इसे सफल माना जाता है। 
• DROPOUT यह तय करता है कि कितने भाग के वेट्स को रैंडम रूप से शून्य किया जाना चाहिए। ड्रॉपआउट फ़ंक्शन मॉडल वेट्स के एक भाग को रैंडम रूप से शून्य सेट करता है। यह विशिष्ट न्यूरॉन्स पर निर्भरता कम करता है और ओवरफिटिंग को रोकता है, जिससे नेटवर्क अधिक मज़बूत बनता है।
• LEARNING_RATE यह तय करता है कि हर स्टेप में पॉलिसी पैरामीटर्स को कितना बदला जा सकता है। प्रत्येक इटरेशन में पैरामीटर्स का अपडेट ग्रेडिएंट और लर्निंग रेट के गुणनफल के बराबर होता है। 
• पॉलिसी को PolicyNetwork क्लास (जो पहले लागू की गई) के एक इंस्टेंस के रूप में परिभाषित करें। 
• सीखने की दर के साथ Adam एल्गोरिथ्म का उपयोग करके एक ऑप्टिमाइज़र बनाएँ। 

पॉलिसी को प्रशिक्षित करने के लिए, हम प्रशिक्षण स्टेप्स को आवृत्तिमूलक रूप से तब तक चलाते हैं जब तक कि औसत रिटर्न (N_TRIALS पर) रिवार्ड थ्रेशहोल्ड से अधिक न हो जाए:

• हर एपिसोड के लिए, फॉरवर्ड पास एक बार चलाएँ। उस एपिसोड से एक्शन्स की लॉग-प्रायिकता, स्टेपवाइज़ रिटर्न्स और कुल रिटर्न एकत्र करें। एपिसोडिक रिटर्न्स को एक एरे में जोड़ते जाएँ। 
• लॉग-प्रायिकताओं और स्टेपवाइज़ रिटर्न्स का उपयोग करके लॉस की गणना करें। लॉस पर बैकप्रोपेगेशन चलाएँ। ऑप्टिमाइज़र का उपयोग करके पॉलिसी पैरामीटर्स अपडेट करें। 
• 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 वर्कबुक का उपयोग करके ऊपर दिया एल्गोरिथ्म सीधे चलाएँ और RL का उपयोग करके CartPole एनवायरनमेंट को हल करें। 

Gymnasium में उन्नत तकनीकें

एक RL एल्गोरिथ्म को लागू करना दिखाने के बाद, अब हम कुछ उन्नत तकनीकों पर चर्चा करते हैं जो व्यवहार में सामान्यतः उपयोग की जाती हैं। 

प्री-बिल्ट आर्किटेक्चर का उपयोग

स्क्रैच से RL एल्गोरिथ्म लागू करना एक लंबी और कठिन प्रक्रिया है, खासकर जटिल एनवायरनमेंट्स और स्टेट-ऑफ-द-आर्ट पॉलिसीज़ के लिए। 

एक अधिक व्यावहारिक विकल्प है Stable Baselines3 जैसा सॉफ्टवेयर। इसमें RL एल्गोरिथ्म के आजमाए और परखे हुए इंप्लीमेंटेशन आते हैं। इसमें प्री-ट्रेंड एजेंट्स, ट्रेनिंग स्क्रिप्ट्स, इवैल्यूएशन टूल्स, और ग्राफ़ प्लॉट करने तथा वीडियो रिकॉर्ड करने के मॉड्यूल शामिल हैं। 

Ray RLib RL के लिए एक और लोकप्रिय टूल है। RLib को स्केलेबल समाधान के रूप में डिज़ाइन किया गया है, जिससे मल्टी-GPU सिस्टम पर RL एल्गोरिथ्म लागू करना आसान हो जाता है। यह मल्टी-एजेंट RL को भी सपोर्ट करता है, जो नई संभावनाएँ खोलता है, जैसे:

• स्वतंत्र मल्टी-एजेंट लर्निंग: प्रत्येक एजेंट अन्य एजेंट्स को एनवायरनमेंट का हिस्सा मानता है।
• सहयोगात्मक मल्टी-एजेंट प्रशिक्षण: एजेंट्स का एक समूह एक ही पॉलिसी और वैल्यू फ़ंक्शन साझा करता है और समानांतर में एक-दूसरे के अनुभवों से सीखता है। 
• एडवर्सेरियल प्रशिक्षण: एजेंट (या एजेंट्स के समूह) प्रतिस्पर्धी गेम-जैसे एनवायरनमेंट्स में एक-दूसरे के खिलाफ प्रतिस्पर्धा करते हैं। 

RLib और Stable Baselines3 दोनों के साथ, आप OpenAI Gymnasium से एनवायरनमेंट्स आयात कर सकते हैं और उपयोग कर सकते हैं। 

कस्टम एनवायरनमेंट्स

Gymnasium के साथ पैकेज किए गए एनवायरनमेंट्स नई RL रणनीतियों का परीक्षण और पॉलिसीज़ को प्रशिक्षित करने के लिए उपयुक्त हैं। हालाँकि, अधिकतर व्यावहारिक अनुप्रयोगों के लिए, आपको ऐसा एनवायरनमेंट बनाना और उपयोग करना होगा जो उस समस्या को सटीक रूप से दर्शाए जिसे आप हल करना चाहते हैं। आप Gymnasium का उपयोग करके कस्टम एनवायरनमेंट बना सकते हैं। Gymnasium कस्टम एनवायरनमेंट्स का लाभ यह है कि RLib और Stable Baselines3 जैसे कई बाहरी टूल पहले से ही Gymnasium API संरचना के साथ काम करने के लिए कॉन्फ़िगर किए गए हैं। 

Gymnasium में कस्टम एनवायरनमेंट बनाने के लिए, आपको निम्नलिखित परिभाषित करने होंगे: 

• ऑब्ज़र्वेशन स्पेस।
• टर्मिनल कंडीशंस।
• एजेंट द्वारा चुनी जा सकने वाली क्रियाओं का सेट।
• एनवायरनमेंट को कैसे इनिशियलाइज़ करें (जब reset() फ़ंक्शन कॉल किया जाए)। 
• एजेंट की क्रियाओं के मद्देनज़र एनवायरनमेंट अगली स्टेट कैसे तय करता है (जब step() फ़ंक्शन कॉल किया जाए)। 

अधिक जानने के लिए, Gymnasium की कस्टम एनवायरनमेंट बनाने की गाइड का अनुसरण करें। 

Gymnasium उपयोग के लिए सर्वोत्तम प्रथाएँ

विभिन्न एनवायरनमेंट्स के साथ प्रयोग करें

इस ट्यूटोरियल के कोड ने CartPole एनवायरनमेंट में पॉलिसी ग्रेडिएंट एल्गोरिथ्म कैसे लागू करें, यह दिखाया। यह एक सरल एनवायरनमेंट है जिसका एक्शन स्पेस डिस्क्रीट है। RL को बेहतर समझने के लिए, हम सलाह देते हैं कि आप इसी पॉलिसी ग्रेडिएंट एल्गोरिथ्म (और अन्य एल्गोरिद्म, जैसे PPO) को अन्य एनवायरनमेंट्स में लागू करें। 

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

विभिन्न एल्गोरिथ्म के साथ अलग-अलग एनवायरनमेंट्स में प्रयोग करने से आपको अलग तरह के RL समाधानों और उनकी चुनौतियों को बेहतर ढंग से समझने में मदद मिलती है। 

प्रशिक्षण प्रगति की निगरानी करें

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

Gymnasium में, env.render() मेथड एजेंट की एनवायरनमेंट के साथ अंतर्क्रिया को विज़ुअलाइज़ करता है। यह एनवायरनमेंट की वर्तमान स्टेट—गेम स्क्रीन, पेंडुलम या कार्ट पोल की स्थिति आदि—को ग्राफ़िकली दिखाता है। एजेंट की क्रियाओं और एनवायरनमेंट की प्रतिक्रियाओं का दृश्य फीडबैक प्रशिक्षण प्रक्रिया के दौरान एजेंट के प्रदर्शन और प्रगति की निगरानी में मदद करता है। 

रेंडर मोड्स चार हैं: “human”, “rgb_array”, “ansi”, और “rgb_array_list”。 एजेंट के प्रदर्शन को विज़ुअलाइज़ करने के लिए “human” रेंडर मोड का उपयोग करें। रेंडर मोड एनवायरनमेंट इनिशियलाइज़ करते समय निर्दिष्ट किया जाता है। उदाहरण:

env = gym.make(‘CartPole-v1’, render_mode=’human’)संचालित द्वारा

रेंडरिंग करने के लिए, एजेंट द्वारा की गई हर क्रिया (यानी .step() मेथड कॉल करने) के बाद .render() मेथड को कॉल करें। नीचे दिया छद्म-कोड दर्शाता है कि यह कैसे करें:

while not done:
    …
   step, reward, terminated, truncated, info = env.step(action.item())
   env.render()
    …संचालित द्वारा

सामान्य त्रुटियों का समाधान

Gymnasium जटिल RL एनवायरनमेंट्स के साथ इंटरफेस करना आसान बनाता है। हालाँकि, यह लगातार अपडेट होने वाला सॉफ़्टवेयर है, जिसकी कई डिपेंडेंसीज़ हैं। इसलिए, कुछ सामान्य प्रकार की त्रुटियों पर नज़र रखना आवश्यक है।

वर्ज़न मिसमैच

• Gymnasium वर्ज़न मिसमैच: Farama का Gymnasium सॉफ़्टवेयर पैकेज OpenAI के Gym 0.26.2 से फोर्क किया गया था। पुराने Gym वर्ज़न्स और नए Gymnasium वर्ज़न्स के बीच कुछ ब्रेकिंग बदलाव हुए हैं। बहुत-सी सार्वजनिक रूप से उपलब्ध इंप्लीमेंटेशन पुराने Gym रिलीज़ पर आधारित हैं और सीधे नवीनतम रिलीज़ के साथ काम नहीं कर सकतीं। ऐसे मामलों में, या तो इंस्टॉलेशन को पुराने वर्ज़न पर रोलबैक करना आवश्यक है या कोड को नए रिलीज़ के साथ काम करने हेतु अनुकूलित करना होगा। 
• एनवायरनमेंट वर्ज़न मिसमैच: कई Gymnasium एनवायरनमेंट्स के अलग-अलग वर्ज़न होते हैं। उदाहरण के लिए, दो CartPole एनवायरनमेंट हैं—CartPole-v1 और CartPole-v0। यद्यपि दोनों वर्ज़न्स में एनवायरनमेंट का व्यवहार समान है, फिर भी कुछ पैरामीटर्स, जैसे एपिसोड लंबाई, रिवार्ड थ्रेशहोल्ड आदि, अलग हो सकते हैं। एक वर्ज़न पर प्रशिक्षित पॉलिसी, उसी एनवायरनमेंट के दूसरे वर्ज़न पर उतना अच्छा प्रदर्शन न कर सके। आपको प्रशिक्षण पैरामीटर्स अपडेट करने और प्रत्येक एनवायरनमेंट वर्ज़न के लिए पॉलिसी को फिर से प्रशिक्षित करने की आवश्यकता होगी। 
• डिपेंडेंसीज़ वर्ज़न मिसमैच: Gymnasium की डिपेंडेंसीज़ में NumPy और PyTorch जैसी लाइब्रेरीज़ शामिल हैं। दिसंबर 2024 तक, इन डिपेंडेंसीज़ के नवीनतम वर्ज़न numpy 2.1.3 और torch 2.5.1 हैं। हालाँकि, Gymnasium torch 1.13.0 और numpy 1.23.3 के साथ सबसे अच्छा काम करता है। यदि आप Gymnasium को ऐसे एनवायरनमेंट में इंस्टॉल करते हैं जहाँ ये डिपेंडेंसीज़ पहले से प्री-इंस्टॉल्ड हैं, तो आपको समस्याएँ आ सकती हैं। हम सलाह देते हैं कि Gymnasium को एक नए Conda एनवायरनमेंट में इंस्टॉल करें और उसी में कार्य करें। 

कन्वर्जेन्स समस्याएँ

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

प्रशिक्षण अस्थिरता

• बड़ी लर्निंग रेट्स: यदि लर्निंग रेट बहुत अधिक है, तो हर स्टेप में पॉलिसी पैरामीटर्स में बड़े अपडेट होते हैं। इससे इष्टतम मानों के सेट को मिस करने की संभावना होती है। एक सामान्य समाधान यह है कि लर्निंग रेट को धीरे-धीरे घटाया जाए, ताकि प्रशिक्षण के कन्वर्ज होने पर अपडेट छोटे और अधिक स्थिर हों। 
• अत्यधिक एक्सप्लोरेशन: एक्शन चयन में बहुत अधिक रैंडमनेस (एंट्रॉपी) कन्वर्जेन्स को रोकती है और क्रमिक स्टेप्स के बीच लॉस फ़ंक्शन में बड़े उतार-चढ़ाव लाती है। स्थिर और कन्वर्जेंट प्रशिक्षण प्रक्रिया के लिए, एक्सप्लोरेशन और एक्सप्लॉइटेशन के बीच संतुलन रखें। 
• गलत एल्गोरिथ्म का चयन: सरल एल्गोरिथ्म जैसे पॉलिसी ग्रेडिएंट, बड़े एक्शन और स्टेट स्पेसेज़ वाले जटिल एनवायरनमेंट्स में अस्थिर प्रशिक्षण दे सकते हैं। ऐसे मामलों में, हम PPO और Trust Region Policy Optimization (TRPO) जैसे अधिक मज़बूत एल्गोरिथ्म का उपयोग करने की सलाह देते हैं। ये एल्गोरिथ्म हर स्टेप में बड़े पॉलिसी अपडेट्स से बचते हैं और अधिक स्थिर हो सकते हैं।
• रैंडमनेस: RL एल्गोरिथ्म प्रारंभिक स्टेट्स और एक्शन चयन में निहित रैंडमनेस के प्रति कुख्यात रूप से संवेदनशील होते हैं। जब कोई प्रशिक्षण रन अस्थिर हो, तो कभी-कभी अलग रैंडम सीड का उपयोग करके या पॉलिसी को पुन: इनिशियलाइज़ करके उसे स्थिर किया जा सकता है।

निष्कर्ष

इस ट्यूटोरियल में, हमने RL के बुनियादी सिद्धांतों का अन्वेषण किया, विभिन्न RL एनवायरनमेंट्स के साथ इंटरफेस करने के लिए साफ़-सुथरे API वाले सॉफ़्टवेयर पैकेज के रूप में Gymnasium पर चर्चा की, और दिखाया कि किस प्रकार एक सरल RL एल्गोरिथ्म लागू करने के लिए Python प्रोग्राम लिखा जाए और उसे Gymnasium एनवायरनमेंट में लागू किया जाए।

इस ट्यूटोरियल में मूल बातें समझने के बाद, मैं सलाह देता हूँ कि आप Gymnasium एनवायरनमेंट्स का उपयोग करके RL की अवधारणाओं को व्यावहारिक समस्याएँ—जैसे टैक्सी रूट ऑप्टिमाइज़ेशन और स्टॉक ट्रेडिंग सिमुलेशन—हल करने में लागू करें।