Batch-updates bij policy gradient

Deep Reinforcement Learning in Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Stapsgewijze vs. batch-gradientupdates

Een grote box die een episode voorstelt.

Stapsgewijze vs. batch-gradientupdates

In de grote box verschijnt een kleinere box voor stap 1. Daarin een vak met ‘actie kiezen’.

Stapsgewijze vs. batch-gradientupdates

In de box ‘stap 1’ verschijnt nog een klein vak met ‘omgeving itereren’.

Stapsgewijze vs. batch-gradientupdates

Onder de box ‘stap 1’ een vak met de labels ‘verlies berekenen’ en ‘gradient descent’.

Stapsgewijze vs. batch-gradientupdates

Een identiek paar vakken verschijnt voor de tweede stap, met dezelfde inhoud.

Stapsgewijze vs. batch-gradientupdates

Stap 3 en stap 4 verschijnen ook.

Batchen van A2C-/PPO-updates

Een grote episode-box; daarin een box ‘rollout 1’ die de helft beslaat; binnenin twee lege vakken ‘stap 1’ en ‘stap 2’.

Batchen van A2C-/PPO-updates

In de box ‘stap 1’ verschijnen de labels ‘actie kiezen’ en ‘omgeving itereren’.

Batchen van A2C-/PPO-updates

Hetzelfde voor stap 2.

Batchen van A2C-/PPO-updates

Onder de vakken ‘stap 1’ en ‘stap 2’ verschijnen één label ‘verlies berekenen’ en één ‘gradient descent’.

Batchen van A2C-/PPO-updates

De resterende helft van de episode is nu ingenomen door een identieke rollout-box met twee stappen, ‘rollout 2’.

De A2C-trainingslus met batch-updates

# Set rollout length
rollout_length = 10

# Initiate loss batches

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

Initialiseer verlies-batches
Loop door episodes en stappen zoals gewoonlijk

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

De A2C-trainingslus met batch-updates

  ...
  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

Voeg stapverlies toe aan de batches
Als de rollout vol is:
- Neem het batchgemiddelde met .mean()
- Voer gradient descent uit
- Reset de verlies-batches

A2C/PPO met meerdere agents

Twee horizontale stroken voor agent 1 en agent 2. Elke agent doorloopt respectievelijk 4 en 3 episodes met wisselende lengte. Binnen elke episode zijn stapvakken zichtbaar zoals eerder. Onder de stroken staan drie rollout-boxen, elk over 8 stappen. In elke rollout staan ‘verlies berekenen’ en ‘gradient descent’. Bovenaan: "rollout-lengte: 8 stappen; aantal agents: 2".

Rollouts en minibatches

Twee agent-stroken zoals op de vorige slide. Onderin weer 3 rollout-boxen, maar nu met bovenaan een lange ‘shuffle’-box. Daaronder zijn ze in de lengte in 4 vakken gedeeld, ‘minibatch’. In elke minibatch staan ‘verlies berekenen’ en ‘gradient descent’. Bovenaan: ‘Rollout-lengte: 8 stappen; minibatch-grootte: 4 (2x2); aantal agents: 2’.

PPO met meerdere epochs

Vergelijkbare tekening, maar de rollout-batches zijn nu ook verticaal in 4 delen gesplitst: boven ‘shuffle’; daarna een groot vak ‘epoch 1’ met 4 minibatches in de lengte; dan ‘reshuffle’; en een groot vak ‘epoch 2’ met 4 minibatches. Legenda: ‘Rollout-lengte: 8 stappen; minibatch-grootte: 4 (2x2); aantal agents: 2; aantal epochs: 2’.

Laten we oefenen!

Deep Reinforcement Learning in Python