Advantage Actor Critic

Deep Reinforcement Learning în Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

De ce Actor Critic?

 

  • Limitări ale REINFORCE:

    • Varianță ridicată
    • Eficiență slabă a eșantioanelor

  • Metodele Actor Critic introduc o rețea critic, permițând învățarea Temporal Difference

Un dreptunghi mare etichetat „agent"; în interior, două dreptunghiuri mai mici etichetate „actor" și „critic".

Deep Reinforcement Learning în Python

Intuiția din spatele metodelor Actor Critic

Studenți discutând în jurul unei mese, cu cărți și pixuri împrăștiate.

 

  • Rețeaua actor:

    • Ia decizii
    • Nu le poate evalua

  • Rețeaua critic:

    • Oferă feedback actorului la fiecare pas
Deep Reinforcement Learning în Python

Rețeaua Critic

 

  • Criticul aproximează funcția de valoare a stării

Reprezentarea rețelei critic, cu starea ca intrare și funcția de valoare ca ieșire; are un singur nod de ieșire.

  • Evaluează acțiunea $a_t$ pe baza avantajului sau TD Error

 

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)
Deep Reinforcement Learning în Python

Dinamica Actor Critic

 

  • La fiecare pas:
    • Actorul alege acțiunea (similar cu rețeaua de politici din REINFORCE)

Sus: un dreptunghi mare etichetat „agent"; în interior, două dreptunghiuri mai mici etichetate „actor" și „critic". Jos: un dreptunghi separat etichetat „environment".

Deep Reinforcement Learning în Python

Dinamica Actor Critic

 

  • La fiecare pas:
    • Actorul alege acțiunea (similar cu rețeaua de politici din REINFORCE)
    • Criticul observă recompensa și starea

O săgeată roșie etichetată „action" merge de la actor la environment.

Deep Reinforcement Learning în Python

Dinamica Actor Critic

 

  • La fiecare pas:
    • Actorul alege acțiunea (similar cu rețeaua de politici din REINFORCE)
    • Criticul observă recompensa și starea
    • Criticul calculează TD Error
    • Actorul și criticul folosesc TD Error pentru actualizarea ponderilor

Două săgeți roșii, etichetate „State" și „Reward", merg de la environment la Critic.

Deep Reinforcement Learning în Python

Dinamica Actor Critic

 

  • La fiecare pas:
    • Actorul alege acțiunea (similar cu rețeaua de politici din REINFORCE)
    • Criticul observă recompensa și starea
    • Criticul calculează TD Error
    • Actorul și criticul folosesc TD Error pentru actualizarea ponderilor
    • Actorul actualizat observă noua stare

O săgeată etichetată „TD error" merge de la Critic la Actor.

Deep Reinforcement Learning în Python

Dinamica Actor Critic

 

  • La fiecare pas:
    • Actorul alege acțiunea (similar cu rețeaua de politici din REINFORCE)
    • Criticul observă recompensa și starea
    • Criticul calculează TD Error
    • Actorul și criticul folosesc TD Error pentru actualizarea ponderilor
    • Actorul actualizat observă noua stare
  • ... și se reia

Săgeata State ajunge acum și la Actor.

Deep Reinforcement Learning în Python

Pierderile A2C

 

Critic

Funcția de pierdere a criticului. Se folosește TD error pătratic pentru critic: Lc(theta c) = ((r_t + gamma * V theta c (s t + 1)) - V theta c) la pătrat

  • Pierdere critic: TD error pătratic

 

Actor

Funcția de pierdere a actorului. La fiecare pas t, se poate folosi următoarea funcție de pierdere: L(theta) egal minus probabilitatea logaritmică a acțiunii înmulțită cu TD error sau avantajul.

  • TD error captează evaluarea criticului
  • Crește probabilitatea acțiunilor cu TD error pozitiv
Deep Reinforcement Learning în Python

Calcularea pierderilor

 

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

 

 

  • Calcularea TD Error
  • Calcularea pierderii actorului
    • Folosiți .detach() pentru a opri propagarea gradientului spre ponderile criticului
  • Calcularea pierderii criticului
Deep Reinforcement Learning în Python

Bucla de antrenament Actor Critic

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
Deep Reinforcement Learning în Python

Să exersăm!

Deep Reinforcement Learning în Python

Preparing Video For Download...