DQN dengan experience replay

Deep Reinforcement Learning dengan Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Pengantar experience replay

DQN dasar belajar hanya dari pengalaman terbaru
- Pembaruan berurutan sangat berkorelasi
- Agen mudah lupa
Solusi: Experience Replay
- Simpan pengalaman dalam buffer
- Tiap langkah, belajar dari batch acak pengalaman lampau

Foto udara labirin pagar tanaman

Double-Ended Queue (Deque)

from collections import deque


# Instantiate with limited capacity
buffer = deque([1,2,3,4], maxlen=7)


# Extend to the right side
buffer.extend([5,6,7,8])

Melebihi kapasitas, item tertua akan dibuang

Sebuah deque berkapasitas tujuh, berisi empat elemen bernomor satu hingga empat.

Sebuah deque berkapasitas tujuh, berisi empat elemen bernomor satu hingga empat. Empat elemen tambahan bernomor lima hingga delapan terlihat di kanan.

Sebuah deque berkapasitas tujuh, berisi tujuh elemen bernomor satu hingga tujuh. Satu elemen tambahan bernomor 8 terlihat di kanan.

Sebuah deque berkapasitas tujuh, berisi tujuh elemen bernomor dua hingga delapan. Satu elemen tambahan bernomor 1 terlihat di kiri.

Mengimplementasikan Replay Buffer

import random


class ReplayBuffer:

    def __init__(self, capacity):

        self.memory = deque([], maxlen=capacity)


    def push(self, state, action, 
             reward, next_state, done):

        experience_tuple = (state, action, 
                            reward, next_state, done)

        self.memory.append(experience_tuple)


    def __len__(self):
        return len(self.memory)


...

Replay memory: deque berkapasitas terbatas
.push():
- Pengalaman sebagai tuple transisi
- Tambahkan pengalaman ke buffer
- Saat penuh: pengalaman tertua dibuang

Mengimplementasikan Replay Buffer

...
def sample(self, batch_size):

    batch = random.sample(self.memory, batch_size)

    states, actions, rewards, next_states, dones = (
      zip(*batch))


    states_tensor = torch.tensor(
      states, dtype=torch.float32)
    ... # repeat identically for 
        # rewards, next_states, dones

    actions_tensor = torch.tensor(
      actions, dtype=torch.long).unsqueeze(1)


    return states_tensor, actions_tensor, 
rewards_tensor, next_states_tensor, dones_tensor

Ambil acak dari pengalaman masa lalu
batch: dari daftar tuple transisi...
...menjadi tuple daftar...
...menjadi tuple tensor PyTorch

Mengintegrasikan Experience Replay dalam DQN

Sebelum loop pelatihan: replay_buffer = ReplayBuffer(10000)
Di dalam loop, setelah pemilihan aksi:

replay_buffer.push((state, action, 
                    reward, next_state, done))

if len(replay_buffer) >= batch_size:

    states, actions, rewards, next_states, dones = (
           replay_buffer.sample(batch_size))

    q_values = (
        q_network(states).gather(1, actions).squeeze(1))

    next_states_q_values = q_network(next_states).amax(1)

    target_q_values = (
                rewards + 
                gamma * next_states_q_values * (1-dones))

    loss = nn.MSELoss()(target_q_values, q_values)

Inisialisasi replay buffer
Tambahkan transisi terbaru ke buffer

Jika panjang buffer $\geq$ batch_size:

Ambil batch acak dari buffer dan lanjut ke perhitungan loss
Konsep perhitungan loss tidak berubah
Mean Squared Bellman Error pada batch replay memory
- Pembelajaran lebih stabil dan efisien

Ayo berlatih!

Deep Reinforcement Learning dengan Python