Advantage Actor Critic

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

Actor Critic क्यों?

 

  • REINFORCE की सीमाएँ:

    • ऊँचा वैरिएंस
    • कम सैंपल एफिशिएंसी

  • Actor Critic तरीकों में एक critic नेटवर्क होता है, जिससे Temporal Difference लर्निंग संभव होती है

एक बड़ा आयत जिसका लेबल 'agent' है; अंदर दो छोटे आयत, क्रमशः 'actor' और 'critic'.

Python में Deep Reinforcement Learning

Actor Critic तरीकों के पीछे की समझ

मेज़ के चारों ओर बात करते स्टूडेंट्स, किताबें और पेन बिखरे हुए.

 

  • Actor नेटवर्क:

    • फैसले लेता है
    • उन्हें आँक नहीं सकता

  • Critic नेटवर्क:

    • हर स्टेप पर actor को फीडबैक देता है
Python में Deep Reinforcement Learning

Critic नेटवर्क

 

  • Critic, state value फंक्शन का अनुमापन करता है

critic नेटवर्क का चित्रण: इनपुट में state और आउटपुट में Value फंक्शन; इसलिए केवल एक आउटपुट नोड.

  • action $a_t$ को advantage या TD-error के आधार पर जज करता है

 

class Critic(nn.Module):
    def __init__(self, state_size):
        super(Critic, self).__init__()
        self.fc1 = nn.Linear(state_size, 64)
        self.fc2 = nn.Linear(64, 1)


    def forward(self, state):
        x = torch.relu(self.fc1(torch.tensor(state)))
        value = self.fc2(x)
        return value


critic_network = Critic(8)
Python में Deep Reinforcement Learning

Actor Critic गतिशीलता

 

  • हर स्टेप पर:
    • Actor action चुनता है (REINFORCE में policy नेटवर्क जैसा)

ऊपर: एक बड़ा आयत 'agent'; अंदर दो छोटे आयत 'actor' और 'critic'. नीचे: अलग आयत 'environment'.

Python में Deep Reinforcement Learning

Actor Critic गतिशीलता

 

  • हर स्टेप पर:
    • Actor action चुनता है (REINFORCE में policy नेटवर्क जैसा)
    • Critic reward और state देखता है

एक लाल तीर 'action' लेबल के साथ actor से environment की ओर जाता है.

Python में Deep Reinforcement Learning

Actor Critic गतिशीलता

 

  • हर स्टेप पर:
    • Actor action चुनता है (REINFORCE में policy नेटवर्क जैसा)
    • Critic reward और state देखता है
    • Critic TD Error निकालता है
    • Actor और Critic, TD Error से weights अपडेट करते हैं

दो लाल तीर, 'State' और 'Reward' लेबल के साथ, environment से Critic की ओर जाते हैं.

Python में Deep Reinforcement Learning

Actor Critic गतिशीलता

 

  • हर स्टेप पर:
    • Actor action चुनता है (REINFORCE में policy नेटवर्क जैसा)
    • Critic reward और state देखता है
    • Critic TD Error निकालता है
    • Actor और Critic, TD Error से weights अपडेट करते हैं
    • अपडेटेड Actor नई state देखता है

एक तीर 'TD error' लेबल के साथ Critic से Actor की ओर जाता है.

Python में Deep Reinforcement Learning

Actor Critic गतिशीलता

 

  • हर स्टेप पर:
    • Actor action चुनता है (REINFORCE में policy नेटवर्क जैसा)
    • Critic reward और state देखता है
    • Critic TD Error निकालता है
    • Actor और Critic, TD Error से weights अपडेट करते हैं
    • अपडेटेड Actor नई state देखता है
  • ... फिर से शुरू करें

अब 'State' तीर Actor तक भी जाता है.

Python में Deep Reinforcement Learning

A2C के losses

 

Critic

critic का लॉस फंक्शन. Critic के लिए squared TD error लें: Lc(theta c) = ((r_t + gamma * V theta c (s t + 1)) - V theta c) squared

  • Critic loss: squared TD error

 

Actor

actor का लॉस फंक्शन. दिखाया जा सकता है कि हर स्टेप t पर actor के लिए यह loss लें: L(theta) = माइनस action log probability × TD error या advantage.

  • TD error, critic की रेटिंग दर्शाता है
  • पॉजिटिव TD error वाली actions की probability बढ़ाएँ
Python में Deep Reinforcement Learning

Losses कैलकुलेट करना

 

def calculate_losses(critic_network, action_log_prob, 
                     reward, state, next_state, done):

    # Critic provides the state value estimates
    value = critic_network(state)

    next_value = critic_network(next_state)

    td_target = (reward + gamma * 
                      next_value * (1-done))

    td_error = td_target - value


    # Apply formulas for actor and critic losses
    actor_loss = -action_log_prob * td_error.detach()

    critic_loss = td_error ** 2


    return actor_loss, critic_loss

 

 

  • TD-Error कैलकुलेट करें
  • actor loss कैलकुलेट करें
    • .detach() का प्रयोग करें ताकि gradient critic के weights तक न जाए
  • critic loss कैलकुलेट करें
Python में Deep Reinforcement Learning

Actor Critic ट्रेनिंग लूप

for episode in range(10):
  state, info = env.reset()
  done = False
  while not done:

    # Select action
    action, action_log_prob = select_action(actor, state)

    next_state, reward, terminated, truncated, _ = env.step(action)
    done = terminated or truncated

    # Calculate losses
    actor_loss, critic_loss = calculate_losses(critic, action_log_prob, reward, state, next_state, done)

    # Update actor
    actor_optimizer.zero_grad(); actor_loss.backward(); actor_optimizer.step()

    # Update critic
    critic_optimizer.zero_grad(); critic_loss.backward(); critic_optimizer.step()

    state = next_state
Python में Deep Reinforcement Learning

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

Python में Deep Reinforcement Learning

Preparing Video For Download...