Advantage Actor Critic

Deep Reinforcement Learning dengan Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Mengapa actor-critic?

Keterbatasan REINFORCE:
- Varians tinggi
- Efisiensi sampel rendah
Metode Actor-Critic menambahkan jaringan critic, memungkinkan pembelajaran Temporal Difference

Sebuah persegi panjang besar berlabel 'agent'; dan dua persegi panjang kecil di dalamnya berlabel 'actor' dan 'critic'.

Intuisi di balik metode Actor-Critic

Mahasiswa berdiskusi di sekitar meja, dengan buku dan pena berserakan.

Jaringan actor:
- Membuat keputusan
- Tidak dapat menilainya
Jaringan critic:
- Memberi umpan balik ke actor tiap langkah

Jaringan Critic

Critic mengaproksimasi fungsi nilai state

Representasi jaringan critic, dengan state sebagai input dan fungsi Value sebagai output; hasilnya hanya satu node keluaran.

Menilai aksi $a_t$ berdasarkan advantage atau 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)

Dinamika Actor-Critic

Tiap langkah:
- Actor memilih aksi (sama seperti policy network di REINFORCE)

Di atas: sebuah persegi panjang besar berlabel 'agent'; di dalamnya dua persegi panjang kecil berlabel 'actor' dan 'critic'. Di bawah: persegi panjang terpisah berlabel 'environment'.

Dinamika Actor-Critic

Tiap langkah:
- Actor memilih aksi (sama seperti policy network di REINFORCE)
- Critic mengamati reward dan state

Sebuah panah merah berlabel 'action' dari actor ke environment.

Dinamika Actor-Critic

Tiap langkah:
- Actor memilih aksi (sama seperti policy network di REINFORCE)
- Critic mengamati reward dan state
- Critic menghitung TD error
- Actor dan Critic memakai TD error untuk memperbarui bobot

Dua panah merah, masing-masing berlabel 'State' dan 'Reward', dari environment ke Critic.

Dinamika Actor-Critic

Tiap langkah:
- Actor memilih aksi (sama seperti policy network di REINFORCE)
- Critic mengamati reward dan state
- Critic menghitung TD error
- Actor dan Critic memakai TD error untuk memperbarui bobot
- Actor yang telah diperbarui mengamati state baru

Sebuah panah berlabel 'TD error' dari Critic ke Actor.

Dinamika Actor-Critic

Tiap langkah:
- Actor memilih aksi (sama seperti policy network di REINFORCE)
- Critic mengamati reward dan state
- Critic menghitung TD error
- Actor dan Critic memakai TD error untuk memperbarui bobot
- Actor yang telah diperbarui mengamati state baru
... ulangi

Panah State kini menuju Actor juga.

Loss A2C

Critic

Fungsi loss critic. Gunakan kuadrat TD error untuk critic: Lc(theta c) = ((r_t + gamma * V theta c (s t + 1)) - V theta c) kuadrat

Loss critic: kuadrat TD error

Actor

Fungsi loss actor. Dapat ditunjukkan bahwa pada tiap langkah t, kita dapat memakai fungsi loss berikut untuk actor: L(theta) sama dengan minus log-probabilitas aksi dikali TD error atau advantage.

TD error mencerminkan penilaian critic
Naikkan probabilitas aksi dengan TD error positif

Menghitung loss

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

Hitung TD error
Hitung loss actor
- Gunakan .detach() untuk menghentikan propagasi gradien ke bobot critic
Hitung loss critic

Training loop 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

Ayo berlatih!

Deep Reinforcement Learning dengan Python