Policygradients en REINFORCE

Deep Reinforcement Learning in Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Verschillen met DQN

REINFORCE: Monte Carlo, geen Temporal Difference
- Update aan het einde van de episode, niet bij elke stap
- Of na meerdere episodes
Geen waardefunctie
Geen targetnetwerk
Geen epsilon-greediness
Geen experience replay

Afbeeldingen van: de actie-waardefunctie Q, experience replay, epsilon-greediness en vaste q-doelen, op elkaar gestapeld en doorgestreept

Structuur van de REINFORCE-trainingslus

for episode in range(num_episodes):

  # 1. Episode initialiseren

  while not done:

    # 2. Actie kiezen

    # 3. Actie uitvoeren; volgende state en beloning ophalen

    # 4. (Gedisconteerde) beloning bij return optellen

    # 5. State updaten

  # 6. Verlies berekenen

  # 7. Policynetwerk updaten met gradient descent

Actieselectie

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)

Haal kansen uit het netwerk
Sample één actie
Geef actie en bijbehorende logkans terug

Bemonsterde actie-index: 1
Logkans van bemonsterde actie: -1.38

Verlies berekenen

Herinner de policy gradient-stelling:

De policy gradient-stelling: de gradiënt van J(pi_theta) naar theta is de verwachting over trajecten tau volgens pi_theta van de episodische return vermenigvuldigd met de som van de gradiënten van log-actieprobabilities, gesommeerd over alle acties in het traject.

De REINFORCE-verliesfunctie voor een episode: L(theta) is min de episodische return maal de som van actie-logkansen.

In Python:

$R_{\tau}$ als episode_return
Vector van $\log\pi_\theta(a_t|s_t)$ als episode_log_probs

loss = -episode_return * episode_log_probs.sum()

De REINFORCE-trainingslus

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()

Laten we oefenen!

Deep Reinforcement Learning in Python