Advantage Actor Critic

Deep Reinforcement Learning in Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Waarom actor-critic?

Beperkingen van REINFORCE:
- Hoge variantie
- Lage sample-efficiëntie
Actor-Critic voegt een critic-netwerk toe, waardoor Temporal Difference-learning mogelijk is

Een groot rechthoek met 'agent'; binnenin twee kleinere rechthoeken: 'actor' en 'critic'.

De intuïtie achter Actor-Critic-methoden

Studenten praten rond een tafel, met boeken en pennen verspreid.

Actor-netwerk:
- Neemt beslissingen
- Kan ze niet beoordelen
Critic-netwerk:
- Geeft elke stap feedback aan de actor

Het Critic-netwerk

Critic benadert de state value-functie

Een weergave van het critic-netwerk, met de toestand als input en de Value-functie als output; dus één outputnode.

Beoordeelt actie $a_t$ via de advantage of TD-fout

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)

De Actor-Critic-dynamiek

Elke stap:
- Actor kiest actie (zoals het policy-netwerk in REINFORCE)

Bovenaan: een groot rechthoek met 'agent'; binnenin twee kleinere rechthoeken: 'actor' en 'critic'. Onderaan: een aparte rechthoek 'environment'.

De Actor-Critic-dynamiek

Elke stap:
- Actor kiest actie (zoals het policy-netwerk in REINFORCE)
- Critic observeert beloning en toestand

Een rode pijl met label 'action' gaat van de actor naar de environment.

De Actor-Critic-dynamiek

Elke stap:
- Actor kiest actie (zoals het policy-netwerk in REINFORCE)
- Critic observeert beloning en toestand
- Critic berekent TD-fout
- Actor en Critic updaten gewichten met TD-fout

Twee rode pijlen, gelabeld 'State' en 'Reward', gaan van de environment naar de Critic.

De Actor-Critic-dynamiek

Elke stap:
- Actor kiest actie (zoals het policy-netwerk in REINFORCE)
- Critic observeert beloning en toestand
- Critic berekent TD-fout
- Actor en Critic updaten gewichten met TD-fout
- Geüpdatete Actor observeert nieuwe toestand

Een pijl met label 'TD error' gaat van Critic naar Actor.

De Actor-Critic-dynamiek

Elke stap:
- Actor kiest actie (zoals het policy-netwerk in REINFORCE)
- Critic observeert beloning en toestand
- Critic berekent TD-fout
- Actor en Critic updaten gewichten met TD-fout
- Geüpdatete Actor observeert nieuwe toestand
... en herhaal

De State-pijl gaat nu ook naar de Actor.

De A2C-verliesfuncties

Critic

De verliesfunctie van de critic. Gebruik de kwadratische TD-fout voor de critic: Lc(theta c) = ((r_t + gamma * V theta c (s t + 1)) - V theta c) in het kwadraat

Verlies critic: kwadratische TD-fout

Actor

De verliesfunctie van de actor. Je kunt per stap t de volgende verliesfunctie gebruiken: L(theta) is min de logkans van de actie maal de TD-fout of advantage.

TD-fout vat oordeel van critic samen
Verhoog kans op acties met positieve TD-fout

Verliezen berekenen

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

Bereken TD-fout
Bereken actor-verlies
- Gebruik .detach() om gradiënten naar critic niet door te geven
Bereken critic-verlies

De Actor-Critic-trainingslus

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

Laten we oefenen!

Deep Reinforcement Learning in Python