Advantage Actor Critic

Djup förstärkningsinlärning i Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Varför Actor Critic?

Begränsningar med REINFORCE:
- Hög varians
- Låg sampeleffektivitet
Actor Critic-metoder introducerar ett kritiknätverk som möjliggör Temporal Difference-inlärning

En stor rektangel märkt 'agent'; och två mindre rektanglar inuti den, märkta 'actor' respektive 'critic'.

Intuitionen bakom Actor Critic-metoder

Studenter som diskuterar runt ett bord med böcker och pennor utspridda.

Actornätverk:
- Fattar beslut
- Kan inte utvärdera dem
Kritiknätverk:
- Ger återkoppling till actorn vid varje steg

Kritiknätverket

Kritiken approximerar tillståndsvärdefunktionen

En representation av kritiknätverket, med tillståndet som indata och värdefunktionen som utdata; det har därför bara en utdatanod.

Utvärderar åtgärd $a_t$ baserat på fördelen eller TD-felet

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)

Actor Critic-dynamiken

Vid varje steg:
- Actorn väljer åtgärd (precis som policynätverket i REINFORCE)

Överst: En stor rektangel märkt 'agent'; och två mindre rektanglar inuti den, märkta 'actor' respektive 'critic'. Nederst: en separat rektangel märkt 'environment'.

Actor Critic-dynamiken

Vid varje steg:
- Actorn väljer åtgärd (precis som policynätverket i REINFORCE)
- Kritiken observerar belöning och tillstånd

En röd pil märkt 'action' går från actorn till miljön.

Actor Critic-dynamiken

Vid varje steg:
- Actorn väljer åtgärd (precis som policynätverket i REINFORCE)
- Kritiken observerar belöning och tillstånd
- Kritiken beräknar TD-felet
- Actorn och kritiken använder TD-felet för att uppdatera vikterna

Två röda pilar, märkta 'State' respektive 'Reward', går från miljön till kritiken.

Actor Critic-dynamiken

Vid varje steg:
- Actorn väljer åtgärd (precis som policynätverket i REINFORCE)
- Kritiken observerar belöning och tillstånd
- Kritiken beräknar TD-felet
- Actorn och kritiken använder TD-felet för att uppdatera vikterna
- Den uppdaterade actorn observerar det nya tillståndet

En pil märkt 'TD error' går från kritiken till actorn.

Actor Critic-dynamiken

Vid varje steg:
- Actorn väljer åtgärd (precis som policynätverket i REINFORCE)
- Kritiken observerar belöning och tillstånd
- Kritiken beräknar TD-felet
- Actorn och kritiken använder TD-felet för att uppdatera vikterna
- Den uppdaterade actorn observerar det nya tillståndet
... börja om

State-pilen går nu även till actorn.

A2C-förlusterna

Kritiken

Kritikens förlustfunktion. Använd det kvadrerade TD-felet för kritiken: Lc(theta c) = ((r_t + gamma * V theta c (s t + 1)) - V theta c) i kvadrat

Kritikens förlust: kvadrerat TD-fel

Actorn

Actorns förlustfunktion. Det kan visas att vi vid varje tidssteg t kan använda följande förlustfunktion för actorn: L(theta) är lika med minus åtgärdens logsannolikhet gånger TD-felet eller fördelen.

TD-felet fångar kritikens betyg
Öka sannolikheten för åtgärder med positivt TD-fel

Beräkna förlusterna

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

Beräkna TD-felet
Beräkna actorns förlust
- Använd .detach() för att stoppa gradientflödet till kritikens vikter
Beräkna kritikens förlust

Actor Critic-träningsloopen

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

Nu kör vi en övning!

Djup förstärkningsinlärning i Python