पॉलिसी ग्रेडिएंट में बैच अपडेट्स

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

स्टेपवाइज़ बनाम बैच ग्रेडिएंट अपडेट्स

एक बड़ा बॉक्स जो एक एपिसोड दर्शाता है.

स्टेपवाइज़ बनाम बैच ग्रेडिएंट अपडेट्स

बड़े बॉक्स में, एक छोटा बॉक्स दिखता है: स्टेप 1. उसके भीतर 'select action' लिखा बॉक्स.

स्टेपवाइज़ बनाम बैच ग्रेडिएंट अपडेट्स

स्टेप 1 बॉक्स में एक और छोटा बॉक्स: 'iterate environment'

स्टेपवाइज़ बनाम बैच ग्रेडिएंट अपडेट्स

स्टेप 1 के नीचे 'calculate loss' और 'gradient descent' वाले बॉक्स.

স্টেপवाइज़ बनाम बैच ग्रেডिएंट अपडेट्स

दूसरे स्टेप के लिए भी वही जोड़ी बॉक्स.

स्टेपवाइज़ बनाम बैच ग्रेडिएंट अपडेट्स

स्टेप 3 और स्टेप 4 भी दिखते हैं.

A2C / PPO अपडेट्स को बैच करना

एक बड़ा एपिसोड बॉक्स; उसके आधे हिस्से में 'rollout 1' लेबल वाला बॉक्स; उसके भीतर 'step 1' और 'step 2' नाम के खाली बॉक्स.

A2C / PPO अपडेट्स को बैच करना

स्टेप 1 बॉक्स में 'select action' और 'iterate environment' लेबल दिखते हैं.

A2C / PPO अपडेट्स को बैच करना

स्टेप 2 के लिए भी वही.

A2C / PPO अपडेट्स को बैच करना

स्टेप 1 और स्टेप 2 के नीचे एक ही 'calculate loss' और एक ही 'gradient descent' लेबल.

A2C / PPO अपडेट्स को बैच करना

एपिसोड के बचे आधे हिस्से में वैसा ही दूसरा रोलआउट बॉक्स, दो स्टेप्स के साथ, 'rollout 2' लेबल वाला.

बैच अपडेट्स के साथ A2C ट्रेनिंग लूप

# Set rollout length
rollout_length = 10

# Initiate loss batches

actor_losses = torch.tensor([])
critic_losses = torch.tensor([])

लॉस बैच शुरू करें
एपिसोड्स और स्टेप्स पर सामान्य तरह से इटरेट करें

for episode in range(10):
  state, info = env.reset()
  done = False
  while not done:
    action, action_log_prob = select_action(actor, 
                                            state)                
    next_state, reward, terminated, truncated, _ = (
                                   env.step(action))
    done = terminated or truncated    
    actor_loss, critic_loss = calculate_losses(
        critic, action_log_prob, 
        reward, state, next_state, done)
    ...

बैच अपडेट्स के साथ A2C ट्रेनिंग लूप

  ...
  actor_losses = torch.cat((actor_losses, actor_loss))
  critic_losses = torch.cat((critic_losses, critic_loss))


  # If rollout is full, update the networks
  if len(actor_losses) >= rollout_length:

    actor_loss_batch = actor_losses.mean()
    critic_loss_batch = critic_losses.mean()

    actor_optimizer.zero_grad()
    actor_loss_batch.backward()
    actor_optimizer.step()
    critic_optimizer.zero_grad()
    critic_loss_batch.backward()
    critic_optimizer.step()

    actor_losses = torch.tensor([])
    critic_losses = torch.tensor([])


  state = next_state

स्टेप लॉस को लॉस बैच में जोड़ें
जब रोलआउट भर जाए:
- .mean() से बैच औसत लॉस लें
- ग्रेडिएंट डिसेंट चलाएँ
- बैच लॉस रीइनिशलाइज़ करें

मल्टीपल एजेंट्स के साथ A2C / PPO

दो क्षैतिज स्ट्रिप्स एजेंट 1 और एजेंट 2 को दर्शाती हैं. हर एजेंट को अलग लंबाई के क्रमशः 4 और 3 एपिसोड मिलते हैं. हर एपिसोड में, पिछले स्लाइड्स जैसे स्टेप बॉक्स दिखते हैं. नीचे, तीन रोलआउट बॉक्स दिखते हैं, हर एक 8 स्टेप्स के अंतराल को कवर करता है. हर रोलआउट बॉक्स में 'calculate loss' और 'gradient descent' लेबल हैं. ऊपर लीजन में लिखा है: "rollout length: 8 steps; number of agents: 2".

रोलआउट्स और मिनीबैचेस

पिछले स्लाइड जैसी दो एजेंट स्ट्रिप्स. नीचे फिर 3 रोलआउट बॉक्स हैं, पर सामग्री बदली है: ऊपर लंबा 'shuffle' बॉक्स; उसके नीचे हर रोलआउट को लंबाई में 4 'minibatch' में बाँटा गया है; हर मिनीबैच में 'calculate loss' और 'gradient descent' बॉक्स. ऊपर लीजन: 'Rollout length: 8 steps; minibatch size: 4 (2x2); number of agents: 2'.

मल्टीपल epochs के साथ PPO

पिछली ड्राइंग जैसी, पर अब रोलआउट बैच भी ऊर्ध्वाधर 4 हिस्सों में बँटे: सबसे ऊपर 'shuffle'; फिर बड़ा 'epoch 1' बॉक्स जिसमें 4 मिनीबैच; फिर 'reshuffle'; अंत में बड़ा 'epoch 2' बॉक्स, उसमें भी 4 मिनीबैच. लीजन: 'Rollout length: 8 steps; minibatch size: 4 (2x2); number of agents: 2; number of epochs: 2'.

अभ्यास करते हैं!

Python में Deep Reinforcement Learning