पॉलिसी ग्रेडिएंट और REINFORCE

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

DQN से अंतर

REINFORCE: Monte-Carlo, Temporal Difference नहीं
- हर स्टेप पर नहीं, एपिसोड के अंत में अपडेट
- चाहें तो कई एपिसोड बाद अपडेट करें
वैल्यू फंक्शन नहीं
टार्गेट नेटवर्क नहीं
एप्सिलॉन-ग्रीडीनेस नहीं
एक्सपीरियंस रिप्ले नहीं

कार्य-मान फंक्शन Q, एक्सपीरियंस रिप्ले, एप्सिलॉन-ग्रीडीनेस, और फिक्स्ड q-टार्गेट्स को एक-दूसरे पर स्टैक किया गया है और क्रॉस किया गया है

REINFORCE ट्रेनिंग लूप की संरचना

for episode in range(num_episodes):

  # 1. Initialize episode

  while not done:

    # 2. Select action

    # 3. Play action and obtain next state and reward

    # 4. Add (discounted) reward to return

    # 5. Update state

  # 6. Calculate loss

  # 7. Update policy network by gradient descent

एक्शन चयन

from torch.distributions import Categorical

def select_action(policy_network, state):
  action_probs = policy_network(state)

  action_dist = Categorical(action_probs)

  action = action_dist.sample()

  log_prob = action_dist.log_prob(action)

  return action.item(), log_prob.reshape(1)


action, log_prob = select_action(
                       policy_network, state)

नेटवर्क से probabilities निकालें
एक action सैंपल करें
action और उससे जुड़ी log probabilities लौटाएँ

Sampled action index: 1
Log probability of sampled action: -1.38

लॉस कैलकुलेशन

पॉलिसी ग्रेडिएंट थ्योरम याद करें:

पॉलिसी ग्रेडिएंट थ्योरम: J(pi_theta) का theta के सापेक्ष ग्रेडिएंट, pi_theta फॉलो करने वाली ट्रैजेक्टोरीज़ tau पर एक्सपेक्टेशन के बराबर है, जहाँ एपिसोड रिटर्न गुणा ट्रैजेक्टोरी की सभी क्रियाओं पर log action probabilities के ग्रेडिएंट का योग है।

एक एपिसोड के लिए REINFORCE लॉस फंक्शन: L(theta) = माइनस एपिसोड रिटर्न × एक्शन log probability का योग।

Python में:

$R_{\tau}$ को episode_return
$\log\pi_\theta(a_t|s_t)$ का vector episode_log_probs

loss = -episode_return * episode_log_probs.sum()

REINFORCE ट्रेनिंग लूप

for episode in range(50):
  state, info = env.reset(); done = False; step = 0;
  episode_log_probs = torch.tensor([])

  R = 0

  while not done:
    step += 1
    action, log_prob = select_action(policy_network, state)

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

    R += (gamma ** step) * reward

    episode_log_probs = torch.cat((episode_log_probs, log_prob))

    state = next_state

  loss = - R * episode_log_probs.sum()

  optimizer.zero_grad(); loss.backward(); optimizer.step()

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

Python में Deep Reinforcement Learning