डीप रिइनफोर्समेंट लर्निंग के लिए TorchRL के साथ शुरुआत करें

TorchRL सेट अप करना

इस सेक्शन में, मैं आपको TorchRL इंस्टॉल करना और शुरुआत करना दिखाऊंगा। 

पूर्वापेक्षाएँ

TorchRL इंस्टॉल और उपयोग करने से पहले कुछ निर्भरता सॉफ़्टवेयर पैकेज चाहिए:

• PyTorch: TorchRL, PyTorch पर आधारित है, इसलिए यह पूर्वापेक्षा है। 
• Gymnasium: RL परिवेश इम्पोर्ट करने के लिए आपको Gymnasium पैकेज की ज़रूरत पड़ेगी। जनवरी 2025 तक, Gymnasium का नवीनतम संस्करण TorchRL के साथ संगत नहीं है, जैसा कि इस Git Discussions पेज पर समझाया गया है। इसलिए, पुराना संस्करण 0.29.1 इंस्टॉल करें। 
• PyGame: यह वीडियो गेम के लिए एक Python पैकेज है। TorchRL को CartPole जैसे गेम-जैसे RL परिवेशों का सिमुलेशन करने के लिए इसकी आवश्यकता होती है। 
• TensorDict: न्यूरल नेटवर्क के इनपुट और आउटपुट को डिक्शनरी-जैसी संरचना में स्टोर करने से TorchRL में टेन्सर्स के साथ काम करना आसान हो जाता है। TensorDict एक टेन्सर कंटेनर उपलब्ध कराता है जो की-वैल्यू पेयर्स के रूप में टेन्सर स्टोर करता है। 

पूर्वापेक्षित पैकेज इंस्टॉल करें:

!pip install torch tensordict  gymnasium==0.29.1 pygameसंचालित द्वारा

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

pip का उपयोग कर TorchRL इंस्टॉल करें। यदि आप पर्सनल कंप्यूटर या सर्वर पर काम कर रहे हैं, तो मैं दृढ़ता से सलाह दूंगा कि ये पैकेज Conda एनवायरनमेंट में इंस्टॉल करें। 

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

इंस्टॉलेशन की जाँच

इंस्टॉल करने के बाद, जाँचें कि TorchRL सफलतापूर्वक इंस्टॉल हो गया है। Python शेल (या नोटबुक) में torchrl इम्पोर्ट करने का प्रयास करें। check_env_specs() मेथड का उपयोग कर जाँचे कि कोई मानक परिवेश (जैसे CartPole) torchrl के विनिर्देशों से मेल खाता है या नहीं:

import torchrl 
from torchrl.envs import GymEnv 
from torchrl.envs.utils import check_env_specs

check_env_specs(GymEnv("CartPole-v1"))संचालित द्वारा

आउटपुट यह संकेत देगा कि पर्यावरण सफलतापूर्वक बना लिया गया है और यह TorchRL के साथ काम करता है। 

[torchrl][INFO] check_env_specs succeeded!संचालित द्वारा

TorchRL के प्रमुख घटक

अपना पहला RL एजेंट बनाने से पहले, TorchRL के मुख्य बिल्डिंग ब्लॉक्स पर नज़र डालें।

Environments

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

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

उदाहरण के लिए, Gymnasium से एक परिवेश बनाने के लिए GymEnv मॉड्यूल का उपयोग करें:

env = GymEnv("CartPole-v1")संचालित द्वारा

Transforms

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

from torchrl.envs import GymEnv, StepCounter, TransformedEnv
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())संचालित द्वारा

इसी तरह, ऑपरेशन से पहले टेन्सर को नॉर्मलाइज़ करना एक आम प्रीप्रोसेसिंग स्टेप है। ObservationNorm मॉड्यूल का उपयोग कर नॉर्मलाइज़ेशन ट्रांसफ़ॉर्मेशन टेन्सर को नॉर्मलाइज़ करता है। TransformedEnv फ़ंक्शन के प्रलेखन में विभिन्न प्रकार के ट्रांसफ़ॉर्मेशन पर चर्चा की गई है। 

आप compose() पैरामीटर का उपयोग करके कई ट्रांसफ़ॉर्मेशन को संयोजित भी कर सकते हैं:

base_env = GymEnv('CartPole-v1', device=device) 

env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        StepCounter()
    )
)संचालित द्वारा

एजेंट और पॉलिसीज़

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

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

सबसे सरल पॉलिसी यादृच्छिक रूप से कार्रवाई चुनना है। अभिनेता संभावित कार्रवाइयों के स्पेस में से यादृच्छिक रूप से एक कार्रवाई चुनता है। कभी-कभी मॉडल ट्रेनिंग शुरू करने से पहले इंटरैक्शन का प्रारंभिक डेटासेट बनाने के लिए रैंडम पॉलिसी का उपयोग किया जाता है। 

RandomPolicy मॉड्यूल का उपयोग कर एक रैंडम पॉलिसी बनाएं। यह रैंडम पॉलिसी action_spec पैरामीटर स्वीकार करती है, जो एक्शन-स्पेस निर्दिष्ट करता है। नीचे के उदाहरण में, एक्शन-स्पेस -1 से +1 के बीच (सतत) संख्याएँ हैं। इसलिए, रैंडम पॉलिसी -1 और +1 के बीच किसी यादृच्छिक संख्या द्वारा दर्शाई गई कार्रवाई चुनती है। 

import torchrl 
import torch
from tensordict import TensorDict
from torchrl.data.tensor_specs import Bounded

action_spec = Bounded(-torch.ones(1), torch.ones(1))
actor = torchrl.envs.utils.RandomPolicy(action_spec=action_spec) 
td = actor(TensorDict({}, batch_size=[])) 
print(td.get("action"))संचालित द्वारा

आउटपुट एक टेन्सर होना चाहिए, जैसा नीचे दिखाया गया है:

tensor([0.9258])संचालित द्वारा

एक्टर को फिर से चलाकर जाँचें कि पॉलिसी वास्तव में यादृच्छिक है:

td = actor(TensorDict({}, batch_size=[])) 
print(td.get("action"))संचालित द्वारा

यह एक अलग रैंडम टेन्सर आउटपुट करेगा।

यदि आपको RL कॉन्सेप्ट्स पर प्राइमर चाहिए, तो DataCamp का Reinforcement Learning in Python स्किल ट्रैक देखें!

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

इस सेक्शन में, मैं आपको TorchRL का उपयोग करते हुए एक साधारण रिइनफोर्समेंट लर्निंग एजेंट लागू करना दिखाऊंगा। 

शुरू करने से पहले, Python में आवश्यक सॉफ़्टवेयर पैकेज इम्पोर्ट करें:

• time एजेंट को ट्रेन करने में लगे समय को मापने के लिए।
• GymEnv, StepCounter, और TransformedEnv Gymnasium परिवेशों के साथ काम करने के लिए।
• MLP एक साधारण MLP (मल्टी-लेयर परसेप्ट्रॉन) न्यूरल नेटवर्क बनाने के लिए। 
• EGreedyModule पर्यावरण की खोज (explore) और सर्वश्रेष्ठ ज्ञात पॉलिसी का उपयोग (exploit) करने के बीच संतुलन बनाने के लिए।
• QValueModule और DQNLoss डीप Q-लर्निंग एल्गोरिदम लागू करने के लिए।
• SoftUpdate न्यूरल नेटवर्क को अपडेट करने के लिए।
• SyncDataCollector एजेंट की इंटरैक्शन से डेटा एकत्र करने के लिए। 
• ReplayBuffer एजेंट की इंटरैक्शन से प्राप्त डेटा को स्टोर करने के लिए।
• Adam बैकप्रोपेगेशन के लिए।
• matplotlib प्रशिक्षण प्रगति को विज़ुअल रूप में प्रदर्शित करने के लिए। 
• torchrl_logger प्रशिक्षण सत्र को लॉग करने के लिए।

import time
import matplotlib.pyplot as plt
from torchrl.envs import GymEnv, StepCounter, TransformedEnv
from tensordict.nn import TensorDictModule as TensorDict, TensorDictSequential as Seq
from torchrl.modules import EGreedyModule, MLP, QValueModule
from torchrl.objectives import DQNLoss, SoftUpdate
from torchrl.collectors import SyncDataCollector
from torchrl.data import LazyTensorStorage, ReplayBuffer
from torch.optim import Adam
from torchrl._utils import logger as torchrl_loggerसंचालित द्वारा

स्टेप 1: पर्यावरण परिभाषित करें

इस उदाहरण में, हम CartPole पर्यावरण सुलझाते हैं। स्टेप काउंटर के साथ Gymnasium से यह पर्यावरण इम्पोर्ट करें ताकि प्रशिक्षण स्टेप्स की संख्या पर नज़र रखी जा सके:

env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())संचालित द्वारा

Python और RL पर्यावरण को सीड करें ताकि अलग-अलग प्रशिक्षण सत्रों में समान परिणामों को दोहराया जा सके। 

torch.manual_seed(0)
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())
env.set_seed(0)संचालित द्वारा

प्रशिक्षण के लिए पैरामीटर्स और हाइपरपैरामीटर्स परिभाषित करें: 

• INIT_RAND_STEPS: जितने स्टेप्स तक एजेंट पॉलिसी का उपयोग करने से पहले रैंडम रूप से कार्य करेगा। इन शुरुआती स्टेप्स का उपयोग पॉलिसी प्रशिक्षण शुरू करने के लिए प्रारंभिक डेटा एकत्र करने में होता है।
• FRAMES_PER_BATCH: एक प्रशिक्षण बैच में डेटा पॉइंट्स की संख्या (प्रत्येक इंटरैक्शन या टाइम-स्टेप के लिए एक)। 
• OPTIM_STEPS: जितने स्टेप्स तक लॉस एकत्र किए जाएँ, उसके बाद बैकवर्ड पास का एक पास चलाया जाए। 
• EPS_0: एप्सिलॉन (एक्सप्लोरेशन गुणांक) का प्रारंभिक मान। 
• BUFFER_LEN: रिप्ले बफ़र का आकार।
• ALPHA: लर्निंग रेट।
• TARGET_UPDATE_EPS: soft-update मॉड्यूल का उपयोग कर टार्गेट नेटवर्क अपडेट करने के लिए डिके फ़ैक्टर।
• REPLAY_BUFFER_SAMPLE: प्रत्येक प्रशिक्षण इटरेशन में रिप्ले बफ़र से चुने जाने वाले रैंडम सैंपल का आकार। रिप्ले बफ़र प्रत्येक टाइमस्टेप में एजेंट की पर्यावरण के साथ इंटरैक्शन के परिणामों को स्टोर करता है। 
• LOG_EVERY: जितने स्टेप्स के बाद प्रशिक्षण प्रगति प्रिंट करनी है।
• MLP_SIZE: न्यूरल नेटवर्क का आकार।

INIT_RAND_STEPS = 5000 
FRAMES_PER_BATCH = 100
OPTIM_STEPS = 10
EPS_0 = 0.5
BUFFER_LEN = 100_000
ALPHA = 0.05
TARGET_UPDATE_EPS = 0.95
REPLAY_BUFFER_SAMPLE = 128
LOG_EVERY = 1000
MLP_SIZE = 64संचालित द्वारा

स्टेप 2: पॉलिसी बनाएँ

पॉलिसी लागू करने के लिए एक साधारण न्यूरल नेटवर्क परिभाषित करें: 

• MLP (न्यूरल नेटवर्क) परिभाषित करें। किसी ऑब्ज़र्वेशन पर, MLP एक्शन वैल्यू आउटपुट करता है, और प्रभावी रूप से Q-फ़ंक्शन का काम करता है। 
• TensorDict मॉड्यूल का उपयोग कर ऊपर के MLP पर एक टेन्सर डिक्शनरी परिभाषित करें। यह डिक्शनरी पर्यावरण की अवस्था के ऑब्ज़र्वेशंस (डिक्शनरी कीज़) को उस अवस्था से संबंधित एक्शन प्रॉबेबिलिटी वैल्यूज़ (डिक्शनरी वैल्यूज़) से मैप करती है। 
• QValueModule का उपयोग कर Q-फ़ंक्शन लागू करें। एक्शन वैल्यूज़ वाले टेन्सर को देने पर, यह सर्वोच्च एक्शन वैल्यू से संबंधित कार्रवाई लौटाता है। यह ग्रीडी (exploitation) रणनीति लागू करता है। 
• TensorDictSequential मॉड्यूल का उपयोग कर MLP की टेन्सर डिक्शनरी और QValueModule को संयोजित कर पॉलिसी परिभाषित करें। 

value_mlp = MLP(out_features=env.action_spec.shape[-1], num_cells=[MLP_SIZE, MLP_SIZE])
value_net = TensorDict(value_mlp, in_keys=["observation"], out_keys=["action_value"])
policy = Seq(value_net, QValueModule(spec=env.action_spec))संचालित द्वारा

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

exploration_module = EGreedyModule(
    env.action_spec, annealing_num_steps=BUFFER_LEN, eps_init=EPS_0
)
policy_explore = Seq(policy, exploration_module)संचालित द्वारा

स्टेप 3: एजेंट को ट्रेन करें

एजेंट को ट्रेन करने का पहला चरण पर्यावरण के साथ एजेंट की इंटरैक्शन से डेटा इकट्ठा करना है। SyncDataCollector का उपयोग कर एक कलेक्टर बनाएं जो पॉलिसी चलाए और एजेंट की इंटरैक्शन के नतीजे एकत्र करे: 

collector = SyncDataCollector(
    env,
    policy_explore,
    frames_per_batch=FRAMES_PER_BATCH,
    total_frames=-1,
    init_random_frames=INIT_RAND_STEPS,
)संचालित द्वारा

इंटरैक्शन के परिणामों को स्टोर करने के लिए एक रिप्ले बफ़र बनाएँ:

rb = ReplayBuffer(storage=LazyTensorStorage(BUFFER_LEN))संचालित द्वारा

आपको प्रशिक्षण-विशिष्ट मॉड्यूल भी घोषित करने होंगे, जैसे लॉस फ़ंक्शन (DQN-आधारित लॉस कैलकुलेशन के लिए), ऑप्टिमाइज़र (पारंपरिक Adam एल्गोरिदम), और अपडेटर फ़ंक्शंस (न्यूरल नेटवर्क अपडेट करने के लिए)। ये सभी पूर्व-निर्मित TorchRL मॉड्यूल पर आधारित हैं:

loss = DQNLoss(value_network=policy, action_space=env.action_spec, delay_value=True)
optim = Adam(loss.parameters(), lr=ALPHA)
updater = SoftUpdate(loss, eps=TARGET_UPDATE_EPS)संचालित द्वारा

कुल स्टेप्स और एपिसोड्स की संख्या, प्रति एपिसोड सफल स्टेप्स, और निष्पादन समय ट्रैक करने के लिए काउंटर्स इनिशियलाइज़ करें:

total_count = 0
total_episodes = 0
t0 = time.time()
success_steps = []संचालित द्वारा

ट्रेनिंग फ़ंक्शन में 2 for लूप होते हैं: 

• सबसे ऊपर का लूप पॉलिसी चलाता है और एजेंट की इंटरैक्शन के नतीजों को रिप्ले बफ़र में जोड़ता है।
• भीतरी लूप प्रशिक्षण सैंपल्स को बैचों में बाँटता है। यह प्रत्येक बैच को इस प्रकार प्रोसेस करता है: 
• रिप्ले बफ़र से एक यादृच्छिक सैंपल चुनें।
• लॉस फ़ंक्शन का उपयोग कर लॉस की गणना करें।
• ऑप्टिमाइज़र और अपडेटर चलाएँ।
• काउंटर्स अपडेट करें।

हर स्टेप में TorchRL के पूर्व-निर्मित मॉड्यूल्स को कॉल करना शामिल है—कुछ भी शून्य से कोड नहीं करना पड़ता। नीचे का कोड दिखाता है कि इन स्टेप्स को कैसे लागू करें:

for i, data in enumerate(collector):
    rb.extend(data)
    max_length = rb[:]["next", "step_count"].max()
    if len(rb) > INIT_RAND_STEPS:
        for _ in range(OPTIM_STEPS):
            sample = rb.sample(REPLAY_BUFFER_SAMPLE)
            loss_vals = loss(sample)
            loss_vals["loss"].backward()
            optim.step()

            optim.zero_grad()
            # Update exploration factor
            exploration_module.step(data.numel())

            # Update target params
            updater.step()
            total_count += data.numel()
            total_episodes += data["next", "done"].sum()
    success_steps.append(max_length)संचालित द्वारा

स्टेप 4: एजेंट का मूल्यांकन करें

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

हम TorchRL लॉगर का उपयोग करके नियमित अंतराल पर प्रशिक्षण की प्रगति प्रिंट करते हैं:

if total_count > 0 and total_count % LOG_EVERY == 0:
    torchrl_logger.info(f"Successful steps in the last episode: {max_length}, rb length {len(rb)}, Number of episodes: {total_episodes}")संचालित द्वारा

हम अंतिम एपिसोड में एजेंट द्वारा प्राप्त अधिकतम स्टेप्स का उपयोग यह निर्धारित करने के लिए करते हैं कि प्रशिक्षण सफल है या नहीं। CartPole-v1 पर्यावरण प्रति एपिसोड अधिकतम स्टेप्स और कुल रिवार्ड को 500 पर कैप करता है। प्रचलन यह है कि यदि पॉलिसी 475 से अधिक स्टेप्स प्राप्त करती है तो उसे सफल माना जाता है:

if max_length > 475:
    print("TRAINING COMPLETE")
    breakसंचालित द्वारा

ऊपर दिए गए दोनों कोड स्निपेट्स को प्रशिक्षण लूप (पहले दिखाया गया) के अंत में जोड़ना चाहिए। निम्न स्निपेट एजेंट का मूल्यांकन करने वाले कोड के साथ प्रशिक्षण लूप दिखाता है: 

for i, data in enumerate(collector):
    # Write data in replay buffer
    rb.extend(data)
    max_length = rb[:]["next", "step_count"].max()
    if len(rb) > INIT_RAND_STEPS:
        for _ in range(OPTIM_STEPS):
            sample = rb.sample(REPLAY_BUFFER_SAMPLE)
            loss_vals = loss(sample)
            loss_vals["loss"].backward()
            optim.step()

            optim.zero_grad()
            # Update exploration factor
            exploration_module.step(data.numel())

            # Update target params
            updater.step()
            total_count += data.numel()
            total_episodes += data["next", "done"].sum()
    success_steps.append(max_length)

    if total_count > 0 and total_count % LOG_EVERY == 0:
        torchrl_logger.info(f"Successful steps in the last episode: {max_length}, rb length {len(rb)}, Number of episodes: {total_episodes}")

    if max_length > 475:
        print("TRAINING COMPLETE")
        breakसंचालित द्वारा

अंत में, प्रशिक्षण और मूल्यांकन के बाद, कुल प्रशिक्षण समय प्रिंट करें और प्रशिक्षण प्रगति को प्लॉट करें:

t1 = time.time()

torchrl_logger.info(
    f"solved after {total_count} steps, {total_episodes} episodes and in {t1-t0}s."
)

def plot_steps():
    plt.plot(success_steps)
    plt.title('Successful steps over training episodes')
    plt.xlabel('Training episodes')
    plt.ylabel('Steps')
    plt.show()

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

आप इस DataLab वर्कबुक में TorchRL का उपयोग कर DQN लागू करने का पूरा कोड पा सकते हैं और चला सकते हैं। 

इस सेक्शन में, हमने सरल DQN एल्गोरिदम से एक RL एजेंट बनाया और प्रशिक्षित किया। अगले सेक्शन में, हम देखते हैं कि TorchRL के पूर्व-निर्मित मॉड्यूल्स का उपयोग कर PPO जैसे अधिक जटिल एल्गोरिदम कैसे लागू करें। 

TorchRL में पूर्व-निर्मित एल्गोरिदम्स की पड़ताल

जैसा कि पिछले सेक्शनों में बताया गया, TorchRL कुछ पूर्व-निर्मित एल्गोरिदम्स के साथ आता है। आइए देखें कि वे क्या हैं और कैसे काम करते हैं।

समर्थित एल्गोरिदम्स

TorchRL में कई सामान्य डीप रिइनफोर्समेंट लर्निंग एल्गोरिदम्स के पूर्व-निर्मित मॉड्यूल्स शामिल हैं, जैसे: 

• डीप Q नेटवर्क्स (DQN)
• डीप डिटरमिनिस्टिक पॉलिसी ग्रेडिएंट (DDPG)
• सॉफ्ट एक्टर-क्रिटिक (SAC)
• रैंडमाइज़्ड एन्सेम्बल्ड डबल Q-लर्निंग (REDQ)
• CrossQ
• इम्प्लिसिट Q-लर्निंग (IQL)
• कंटीन्युअस Q-लर्निंग (CQL)
• जेनरेटिव एडवर्सेरियल इमिटेशन लर्निंग (GAIL)
• डिसीज़न ट्रांसफ़ॉर्मर (DT)
• ट्विन-डिलेड DDPG (TD3) 
• एक्टर-एडवांटेज क्रिटिक (A2C)
• प्रॉक्सिमल पॉलिसी ऑप्टिमाइज़ेशन (PPO)
• REINFORCE
• आदि 

यह किसी दिए गए समस्या को सुलझाने के लिए विभिन्न प्रकार के एल्गोरिदम्स पर प्रयोग करना और प्रत्येक के प्रदर्शन का अध्ययन करना कुशल बनाता है। 

उदाहरण: TorchRL में PPO

Proximal Policy Optimization क्लिप्ड सरोगेट ऑब्जेक्टिव फ़ंक्शन का उपयोग कर एक स्मूथ ट्रेनिंग प्रक्रिया प्राप्त करता है जो एक्सप्लोरेशन और एक्सप्लॉइटेशन के बीच संतुलन बनाती है। 

इस सेक्शन में, मैं TorchRL में पूर्व-निर्मित PPO मॉड्यूल का उपयोग करना दिखाऊंगा। पहले की इम्प्लीमेंटेशन की तरह, पूर्वापेक्षित मॉड्यूल्स इम्पोर्ट करें। पिछले इम्प्लीमेंटेशन (जैसे ReplayBuffer, SyncDataCollector, आदि) के लिए आवश्यक मॉड्यूल्स के अलावा, PPO के लिए आपको कुछ अतिरिक्त पैकेज चाहिए:

• ProbabilisticActor, कार्रवाई को स्टोकेस्टिक रूप से चुनने के लिए। कार्रवाई को स्टोकेस्टिक रूप से चुनना (हर बार पॉलिसी का अनुसरण कर रिवार्ड अधिकतम करने के बजाय) पर्यावरण की खोज को बढ़ावा देता है और प्रशिक्षण के दौरान अधिक इष्टतम पाथ खोजने में मदद करता है।
• OneHotCategorical, क्रियाओं की लॉग प्रॉबेबिलिटीज़ को दर्शाने वाले टेन्सर की वन-हॉट एन्कोडिंग जनरेट करने के लिए। 
• ValueOperator, वैल्यू फ़ंक्शन को लागू करने वाले न्यूरल नेटवर्क पर आधारित TorchRL मॉड्यूल बनाने के लिए।
• GAE, जेनेरलाइज़्ड एडवांटेज एस्टीमेट लागू करने के लिए। PPO वैल्यू फ़ंक्शन के प्रॉक्सी के रूप में एडवांटेज फ़ंक्शन का उपयोग करता है। ऊपर दिया गया वैल्यू मॉड्यूल GAE का इनपुट है। 
• ClipPPOLoss, PPO लागू करने के लिए क्लिप्ड ऑब्जेक्टिव फ़ंक्शन बनाने के लिए। 

import torch
from torch import nn

from torchrl.envs import Compose, ObservationNorm, DoubleToFloat, StepCounter, TransformedEnv
from torchrl.envs.libs.gym import GymEnv
from torchrl.envs.utils import check_env_specs
from torchrl.modules import ProbabilisticActor, OneHotCategorical, ValueOperator
from torchrl.collectors import SyncDataCollector
from torchrl.data.replay_buffers import ReplayBuffer
from torchrl.data.replay_buffers.storages import LazyTensorStorage
from torchrl.data.replay_buffers.samplers import SamplerWithoutReplacement
from torchrl.objectives.value import GAE
from torchrl.objectives import ClipPPOLoss
from tensordict.nn import TensorDictModuleसंचालित द्वारा

प्रशिक्षण के लिए पैरामीटर्स और हाइपरपैरामीटर्स घोषित करें:

• FRAMES_PER_BATCH: पर्यावरण के साथ एजेंट की इंटरैक्शन से प्राप्त डेटा के प्रत्येक बैच में फ्रेम्स (टाइमस्टेप्स) की संख्या। 
• SUB_BATCH_SIZE: प्रत्येक सब-बैच में टाइमस्टेप्स की संख्या। PPO प्रशिक्षण में, प्रत्येक बैच को सब-बैच में विभाजित किया जाता है। 
• TOTAL_FRAMES: कुल टाइमस्टेप्स जिनके लिए प्रशिक्षण चलाना है। 
• GAMMA: भविष्य के टाइमस्टेप्स से मिलने वाले रिवार्ड के मान को डिस्काउंट करने के लिए डिस्काउंट फ़ैक्टर।
• CLIP_EPSILON: यह ट्रस्ट रीजन परिभाषित करता है जिसके भीतर प्रत्येक क्रमिक प्रशिक्षण इटरेशन में पॉलिसी बदल सकती है। इसे इस प्रकार लागू किया जाता है कि अपडेटेड पॉलिसी को क्लिप कर नया/पुराना प्रॉबेबिलिटी रेशियो एक निश्चित सीमा के भीतर रहे। 
• ALPHA: लर्निंग रेट।
• ENTROPY_EPS: यह हाइपरपैरामीटर एक्सप्लोरेशन और एक्सप्लॉइटेशन के अनुपात को नियंत्रित करता है। 
• OPTIM_STEPS: प्रत्येक सब-बैच पर ऑप्टिमाइज़र चलाने की बारंबारता। 
• LOG_EVERY: जितने स्टेप्स के बाद पॉलिसी का मूल्यांकन कर रिवार्ड्स प्रिंट करने हैं। 

FRAMES_PER_BATCH = 1024
TOTAL_FRAMES = 1048576
GAMMA = 0.99
LAMBDA = 0.95
CLIP_EPSILON = 0.2
ALPHA = 1e-4
ENTROPY_EPS = 5e-4 
SUB_BATCH_SIZE = 64
OPTIM_STEPS = 8
LOG_EVERY = 16संचालित द्वारा

Gymnasium से बेस CartPole पर्यावरण इम्पोर्ट करें:

device="cpu"
base_env = GymEnv('CartPole-v1', device=device) संचालित द्वारा

बेस पर्यावरण इम्पोर्ट कर TorchRL पर्यावरण घोषित करें और ऑब्ज़र्वेशन टेन्सर्स को नॉर्मलाइज़ करने तथा स्टेप काउंट करने के मॉड्यूल जोड़ें:

env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        DoubleToFloat(), 
        StepCounter()
    )
)संचालित द्वारा

पर्यावरण को इनिशियलाइज़ करें और रैंडम नंबर जेनरेटर्स को सीड करें:

env.transform[0].init_stats(1024) 
torch.manual_seed(0)
env.set_seed(0)
check_env_specs(env) संचालित द्वारा

एक्टर्स को एक न्यूरल नेटवर्क के रूप में घोषित करें जिसमें 1 हिडन लेयर में 16 वेट्स हों। यह पर्यावरण से ऑब्ज़र्वेशन इनपुट लेता है और एक्शन स्पेस की प्रत्येक कार्रवाई की संभावना आउटपुट करता है। 

actor_net = nn.Sequential(
    nn.Linear(env.observation_spec["observation"].shape[-1], 32, device=device),
    nn.ReLU(),
    nn.Linear(32, 32, device=device),
    nn.ReLU(),
    nn.Linear(32, env.action_spec.shape[-1], device=device),
    nn.ReLU()
)संचालित द्वारा

उपरोक्त न्यूरल नेटवर्क के आधार पर एक टेन्सर डिक्शनरी बनाएँ जिसमें स्टेट्स को एक्शन प्रॉबेबिलिटीज़ से मैप करने वाली कीज़ और वैल्यूज़ हों। 

actor_module = TensorDictModule(actor_net, in_keys=["observation"], out_keys=["logits"])संचालित द्वारा

PPO (और कई अन्य RL एल्गोरिदम्स) को ट्रेन करने के लिए, आप हमेशा वह कार्रवाई नहीं चुनते जो अगले स्टेप में सर्वोच्च रिवार्ड देती हो। कार्रवाई चुनने में कुछ हद तक रैंडमनेस एजेंट को पर्यावरण की खोज करने और ऐसे बेहतर पाथ खोजने देती है जो दीर्घकालिक रिटर्न बढ़ा सकते हैं। ऐसा करने के लिए एक प्रॉबैबिलिस्टिक एक्टर बनाएँ:

actor = ProbabilisticActor(
    module = actor_module,
    spec = env.action_spec,
    in_keys = ["logits"],
    distribution_class = OneHotCategorical, 
    return_log_prob = True
)संचालित द्वारा

वैल्यू फ़ंक्शन लागू करने के लिए नेटवर्क बनाएँ। इस नेटवर्क में 16 वेट्स हैं। यह पर्यावरण की अवस्था (ऑब्ज़र्वेशन) को इनपुट लेता है और उस अवस्था के अपेक्षित मान को आउटपुट करता है। 

value_net = nn.Sequential(
    nn.Linear(env.observation_spec["observation"].shape[-1], 16, device=device),
    nn.ReLU(),
    nn.Linear(16, 1, device=device),
    nn.ReLU()
)संचालित द्वारा

ValueOperator() का उपयोग कर वैल्यू फ़ंक्शन (ऊपर लागू) को रैप करने वाला TorchRL मॉड्यूल बनाएँ। यह मॉड्यूल अन्य TorchRL घटकों के साथ इंटरफ़ेस करता है। 

value_module = ValueOperator(
    module = value_net,
    in_keys = ["observation"]
)संचालित द्वारा

पर्यावरण के साथ एजेंट की इंटरैक्शन के परिणामों को स्टोर करने के लिए रिप्ले बफ़र बनाएँ: 

replay_buffer = ReplayBuffer(
    storage = LazyTensorStorage(max_size=FRAMES_PER_BATCH),
    sampler = SamplerWithoutReplacement()
)संचालित द्वारा

एक डेटा कलेक्टर बनाएँ जो पर्यावरण पर पॉलिसी चलाए और प्रत्येक टाइमस्टेप (फ़्रेम) में एजेंट की इंटरैक्शन के परिणाम एकत्र करे:

collector = SyncDataCollector(
    env,
    actor,
    frames_per_batch = FRAMES_PER_BATCH,
    total_frames = TOTAL_FRAMES,
    split_trajs = True,
    reset_at_each_iter = True,
    device=device
)संचालित द्वारा

GAE मॉड्यूल का उपयोग कर PPO के लिए एडवांटेज फ़ंक्शन लागू करें। एडवांटेज फ़ंक्शन वैल्यू फ़ंक्शन पर आधारित होता है। 

advantage_module = GAE(
    gamma = GAMMA, 
    lmbda = GAMMA, 
    value_network = value_module,
    average_gae = True
) संचालित द्वारा

इन-बिल्ट ClipPPOLoss मॉड्यूल का उपयोग कर PPO एल्गोरिदम के अनुसार लॉस फ़ंक्शन लागू करें:

loss_module = ClipPPOLoss(
    actor_network = actor,
    critic_network = value_module,
    clip_epsilon = CLIP_EPSILON,
    entropy_bonus = bool(ENTROPY_EPS),
    entropy_coef = ENTROPY_EPS
)संचालित द्वारा

Adam ऑप्टिमाइज़र घोषित करें: 

optim = torch.optim.Adam(loss_module.parameters(), lr=ALPHA)संचालित द्वारा

ट्रेनिंग के साथ-साथ लर्निंग रेट को धीरे-धीरे घटाने के लिए एक शेड्यूलर बनाएँ: 

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, TOTAL_FRAMES // FRAMES_PER_BATCH)संचालित द्वारा

ऊपर बनाए गए घटकों का उपयोग कर प्रशिक्षण लूप बनाएं। प्रशिक्षण फ़ंक्शन में तीन for लूप होते हैं:

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

नीचे का कोड प्रशिक्षण लूप लागू करता है:

for i, tensordict_data in enumerate(collector): 
    for _ in range(OPTIM_STEPS): 
        advantage_module(tensordict_data)
        replay_buffer.extend(tensordict_data.reshape(-1).cpu())
        for _ in range(FRAMES_PER_BATCH // SUB_BATCH_SIZE): 
            data = replay_buffer.sample(SUB_BATCH_SIZE)
            loss = loss_module(data.to(device))
            loss_value = loss["loss_objective"] + loss["loss_critic"] + loss["loss_entropy"]
            loss_value.backward()
            optim.step()
            optim.zero_grad()
    scheduler.step()

    if i % LOG_EVERY == 0:
        with torch.no_grad():
            rollout = env.rollout(FRAMES_PER_BATCH, actor)
            reward_eval = rollout["next","reward"].sum()
            #print(rollout["next","reward"].sum())
            print(reward_eval)
            rewards.append(reward_eval)
            del rolloutसंचालित द्वारा

यह DataLab वर्कबुक TorchRL से PPO एल्गोरिदम का उपयोग कर RL एजेंट ट्रेन करने के लिए (ऊपर दिखाए गए) कोड देता है। इसे पैरामीटर्स फाइन-ट्यून करने और एजेंट के प्रदर्शन को सुधारने की शुरुआत के रूप में उपयोग करें। 

एल्गोरिदम्स को कस्टमाइज़ करना

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

• आप विभिन्न घटकों को बदले बिना प्रोग्राम के बड़े हिस्सों को फिर से लिखे बिना स्वैप कर सकते हैं। 
• व्यक्तिगत घटकों को स्वतंत्र रूप से संशोधित कर कस्टम समाधान भी बनाए जा सकते हैं। 

• आप विभिन्न मॉड्यूल्स पर प्रयोग कर एक अनुकूलित समाधान बना सकते हैं। 

TorchRL में कस्टमाइज़ेशन के कुछ उदाहरण:

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

RL प्रशिक्षण का विज़ुअलाइज़ेशन और डिबगिंग

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

प्रशिक्षण प्रगति मॉनिटर करना

प्रशिक्षण के दौरान विभिन्न मैट्रिक्स को लॉग करना प्रगति मॉनिटर करने में सहायक रहता है। TensorBoard जैसे पैकेज प्रशिक्षण प्रक्रिया के दौरान सीधे रिज़ल्ट्स लॉग करना आसान बनाते हैं। उदाहरण के लिए, TensorBoard का SummaryWriter आपको प्रशिक्षण लूप के भीतर कॉल करने देता है ताकि मैट्रिक्स लॉग हो सकें। निम्न स्यूडो-कोड दिखाता है कैसे:

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter(log_dir="training_logs")

for _ in training_data (): # training loop
    loss = … 
    loss.backprop() 
    writer.add_scalar(“Loss - “, loss.item(), step)
   … 

writer.close() संचालित द्वारा

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

tensorboard --logdir=”training_logs”संचालित द्वारा

TorchRL के साथ डिबगिंग

एजेंट की पर्यावरण के साथ इंटरैक्शन सत्यापित करने के लिए डिबगिंग आवश्यक है। पहले चरण में, आप एक्शन स्पेस और ऑब्ज़र्वेशन स्पेस की जाँच करना चाहेंगे। पर्यावरण के प्रलेखन में विनिर्देश शामिल होने चाहिए। उदाहरण के लिए, CartPole का प्रलेखन दिखाता है कि: 

• एक्शन स्पेस में दो डिस्क्रीट वैल्यूज़ हैं—0 (कार्ट को बाएँ धकेलना) और 1 (कार्ट को दाएँ धकेलना) 
• ऑब्ज़र्वेशन स्पेस में 4 वैल्यूज़ हैं: 
• कार्ट की पोज़िशन, जिसका मान 
• -4.8 और +4.8 के बीच। 
• कार्ट वेलोसिटी, जिसका मान कोई भी वास्तविक संख्या हो सकता है
• पोल एंगल, जिसका मान -24 ° और +24 ° के बीच
• पोल एंगुलर वेलोसिटी, जिसका मान कोई भी वास्तविक संख्या हो सकता है

यह जाँचने के लिए ऑब्ज़र्वेशन और एक्शन स्पेस का निरीक्षण करें कि वे अपेक्षित मानों से मेल खाते हैं। उदाहरण के लिए:

print("Observation space: ", env.observation_spec)
print("Action space: ", env.action_spec)संचालित द्वारा

अतिरिक्त रूप से, आप ऑब्ज़र्वेशन और एक्शन स्पेस से रैंडम सैंपल निकाल कर उनके मान जाँच सकते हैं: 

print("Sample Observation:", base_env.observation_spec.sample().get("observation"))
print("Sample Action:", base_env.action_spec.sample())संचालित द्वारा

आउटपुट नीचे दिए गए नमूने जैसा होगा:

Sample Observation: tensor([-4.5960e+00,  3.4028e+38,  2.2261e-02,  3.4028e+38])
Sample Action: tensor([1, 0])संचालित द्वारा

ध्यान दें कि 4 स्टेट वैल्यूज़ पहले बताए गए रेंज में आती हैं। ऊपर दिए गए कमांड्स को कुछ बार दोहराएँ और देखें कि अलग-अलग (रैंडम सैंपल) आउटपुट मान निर्दिष्ट रेंज के भीतर आते हैं। 

ऊपर के दोनों कमांड बेस पर्यावरण (सीधे Gymnasium से इम्पोर्ट) पर आधारित हैं। व्यवहार में, हम ट्रांसफ़ॉर्म्ड पर्यावरण का उपयोग करते हैं, जो मूल टेन्सर मानों पर नॉर्मलाइज़ेशन जैसी ट्रांसफ़ॉर्मेशंस लागू करता है। इसलिए, जब आप ट्रांसफ़ॉर्म्ड TorchRL पर्यावरण का उपयोग कर ऑब्ज़र्वेशंस के सैंपल निकालते हैं, तो उनके मान अब मूल Gymnasium पर्यावरण के समान रेंज में नहीं रह सकते। 

उदाहरण के लिए, ट्रांसफ़ॉर्म्ड पर्यावरण से एक सैंपल निकालें:  

print("Sample Observation:", env.observation_spec.sample().get("observation"))संचालित द्वारा

आउटपुट इस प्रकार होगा: 

Sample Observation: tensor([-57.5869,      nan,   4.5276,      nan])संचालित द्वारा

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

एजेंट के प्रदर्शन का विज़ुअलाइज़ेशन

प्रशिक्षण की प्रगति प्लॉट करने के अलावा, पर्यावरण को रेंडर करना और एजेंट की इंटरैक्शन को दृश्य रूप से देखना सहायक हो सकता है। इससे एजेंट के प्रदर्शन पर इनसाइट्स मिलती हैं। 

पर्यावरण को विज़ुअलाइज़ करने का सबसे व्यावहारिक तरीका वीडियो रेंडर करना है। आपको कुछ अतिरिक्त पैकेज चाहिए: 

• torchvision, मल्टीमीडिया फाइल्स के साथ काम करने के लिए
• av, ffmpeg पैकेज को रैप करने के लिए ताकि यह PyTorch के साथ इंटरफ़ेस कर सके। 

pip install torchvision
pip install av==12.0.0संचालित द्वारा

प्रशिक्षण समाप्त होने के बाद, वीडियो रेंडर करने के लिए निम्न तैयारी के स्टेप्स फॉलो करें:

• वीडियो स्टोर करने का (रिलेटिव) पथ घोषित करें।
• एजेंट की इंटरैक्शन के परिणामों को CSV फ़ॉर्मैट में स्टोर करने के लिए लॉगर इनिशियलाइज़ करें।
• CSV लॉग्स का उपयोग कर वीडियो जनरेट करने के लिए वीडियो रिकॉर्डर इनिशियलाइज़ करें।
• वीडियो रिकॉर्डर शामिल करने के लिए TorchRL पर्यावरण को ट्रांसफ़ॉर्म करें।

…
# training loop
# for _ in …
…
…

from torchrl.record import CSVLogger, VideoRecorder 

path = "./training_loop"
logger = CSVLogger(exp_name="dqn", log_dir=path, video_format="mp4")
video_recorder = VideoRecorder(logger, tag="video")
record_env = TransformedEnv(
    GymEnv("CartPole-v1", from_pixels=True, pixels_only=False), video_recorder
)संचालित द्वारा

पर्यावरण पर (ट्रेंड) पॉलिसी चलाएँ और रेंडरिंग को वीडियो फ़ाइल में डम्प करें:

record_env.rollout(max_steps=1000, policy=policy)
video_recorder.dump()संचालित द्वारा

प्रोग्राम चलाने के बाद, आपको वह वीडियो डायरेक्टरी पाथ (./training_loop ऊपर के स्निपेट में) में मिलेगा जो आपने पहले सेट किया था। ध्यान दें कि TorchRL का उपयोग कर DQN लागू करने के लिए DataLab वर्कबुक में वीडियो बनाने का कोड शामिल नहीं है क्योंकि ऑनलाइन नोटबुक के साथ वीडियो फाइल एक्सपोर्ट करना कठिन है। वीडियो रिकॉर्ड करने के लिए प्रोग्राम (और ऊपर के स्टेप्स जोड़कर) किसी लोकल कंप्यूटर या सर्वर पर चलाएँ।

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

अंत में, कुछ बेस्ट प्रैक्टिसेज़ पर बात करते हैं। मेरी सिफारिशें निम्नलिखित हैं।

सरल पर्यावरण से शुरुआत करें

TorchRL के कारण विकास में आसानी होने के बावजूद, जटिल पर्यावरणों में RL एजेंटों को अच्छा प्रदर्शन कराने के लिए ट्रेन करना चुनौतीपूर्ण बना रहता है। इसलिए, कठिन समस्याओं को सुलझाने से पहले CartPole जैसे सरल पर्यावरण सुलझाना आवश्यक है। 

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

हाइपरपैरामीटर्स के साथ प्रयोग करें

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

इसी प्रकार, बहुत अधिक एक्सप्लोरेशन रेट प्रशिक्षण को कन्वर्ज होने से रोकता है, जबकि बहुत कम एक्सप्लोरेशन रेट एजेंट को इष्टतम पाथ खोजने से रोक सकता है। 

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

Weights & Biases Sweeps या Optuna जैसी स्वचालित लाइब्रेरीज़ का उपयोग कर विभिन्न हाइपरपैरामीटर संयोजनों में प्रशिक्षण प्रदर्शन का परीक्षण करना भी संभव है। 

पूर्व-निर्मित एल्गोरिदम्स का लाभ उठाएँ

जैसा कि आपने पिछले उदाहरणों में देखा, TorchRL के पूर्व-निर्मित मॉड्यूल्स का उपयोग करने से काफी विकास समय बचता है। विकल्प यह है कि सारी कार्यक्षमता शून्य से बनाई जाए, जो विकसित और परीक्षण करने में कहीं अधिक समय और लागत लेगी। 

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

निष्कर्ष

इस लेख में, हमने TorchRL के बुनियादी कॉन्सेप्ट्स कवर किए—एक PyTorch-आधारित फ़्रेमवर्क जो RL एल्गोरिदम लागू करने के लिए है। हमने TorchRL का उपयोग कर Deep Q-Learning जैसे सरल समाधान और PPO जैसे अधिक जटिल एल्गोरिदम लागू करने के व्यावहारिक उदाहरण भी देखे। 

अगले चरण के रूप में, आप इन प्रोग्राम्स को आधार बनाकर अन्य पर्यावरणों और एल्गोरिदम्स पर प्रयोग कर सकते हैं। 

यदि आप RL की बुनियाद और व्यावहारिक अनुप्रयोगों की समझ को और गहरा करना चाहते हैं, तो Reinforcement Learning with Gymnasium in Python देखें और Gymnasium-आधारित पर्यावरणों के साथ अधिक हैंड्स-ऑन अनुभव पाएँ।