Öncelikli deneyim tekrar yürütme

Python ile Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

Tüm deneyimler eşit değildir

Deneyim Tekrarı:
- Üniform örnekleme önemli anıları gözden kaçırabilir
Öncelikli Deneyim Tekrarı:
- TD hatalarına göre her deneyime öncelik ver
- Yüksek öğrenme potansiyelli deneyimlere odaklan

Öğrenciler kütüphanede çalışıyor

Öncelikli Deneyim Tekrarı (PER)

for step = 1 to T do:
    # Değer fonksiyonuna göre en iyi aksiyonu al
    # Sonraki durumu ve ödülü gözlemle
    # Geçişi tekrar yürütme arabelleğine ekle

      # En yüksek öncelik (1) ver

    # Geçmiş geçişlerden bir grup örnekle

      # Önceliğe göre (2)

    # Grup için TD hatalarını hesapla

    # Kaybı hesapla ve Q Ağı’nı güncelle

      # Önem örnekleme ağırlıklarını kullan (4)

    # Örneklenen geçişlerin önceliğini güncelle (3)

# Önem örneklemeyi zamanla artır (5)

(1) Yeni geçişler en yüksek öncelikle eklenir: $p_i = \max_k(p_k)$

(2) Geçiş $i$ olasılıkla örneklenir: $$P(i) = p_i^{\alpha} / \sum_k p_k^{\alpha}\ \ \ \ \ \ \ \ (0<\alpha<1)$$

(3) Örneklenen geçişlerin önceliği TD hatasına güncellenir: $p_i = |\delta_i| + \varepsilon$

(4) Önem örnekleme ağırlıkları: $$w_i = \left( \frac{1}{N} \cdot \frac{1}{P(i)} \right)^\beta\ \ \ \ \ \ \ \ (0<\beta<1)$$

(5) $\beta$’yı kademeli olarak 1’e yaklaştırın

PER’ı uygulama

def __init__(self, capacity, alpha=0.6, beta=0.4, beta_increment=0.001, epsilon=0.001):
    # Bellek arabelleğini başlat
    self.memory = deque(maxlen=capacity)

    # Parametreleri sakla ve öncelikleri başlat
    self.alpha, self.beta, self.beta_increment, self.epsilon = (alpha, beta, beta_increment, epsilon)
    self.priorities = deque(maxlen=capacity)


...

PER’ı uygulama

...

def push(self, state, action, reward, next_state, done):
    # Deneyimi belleğe ekle
    experience_tuple = (state, action, reward, next_state, done)
    self.memory.append(experience_tuple)

    # Yeni geçişin önceliğini en yüksek değere ayarla
    max_priority = max(self.priorities) if self.memory else 1.0
    self.priorities.append(max_priority)


...

PER’ı uygulama

def sample(self, batch_size):
    priorities = np.array(self.priorities)
    # Örnekleme olasılıklarını hesapla
    probabilities = priorities**self.alpha / np.sum(priorities**self.alpha)

    # Örneklenen indeksleri rastgele seç
    indices = np.random.choice(len(self.memory), batch_size, p=probabilities)

    # Ağırlıkları hesapla
    weights = (1 / (len(self.memory) * probabilities)) ** self.beta
    weights /= np.max(weights)
    states, actions, rewards, next_states, dones = zip(*[self.memory[idx] for idx in indices])
    weights = [weights[idx] for idx in indices]
    states, actions, rewards, next_states, dones = (zip(*[self.memory[idx] for idx in indices]))

    # Tensörleri döndür
    states = torch.tensor(states, dtype=torch.float32)
    ... # rewards, next_states, dones, weights için tekrarla
    actions = torch.tensor(actions, dtype=torch.long).unsqueeze(1)    
    return (states, actions, rewards, next_states, dones, indices, weights)

PER’ı uygulama

...

def update_priorities(self, indices, td_errors: torch.Tensor):
    # Örneklenen geçişlerin önceliklerini güncelle
    for idx, td_error in zip(indices, td_errors.abs()):
        self.priorities[idx] = abs(td_error.item()) + self.epsilon


def increase_beta(self):
    # Beta’yı 1’e doğru artır
    self.beta = min(1.0, self.beta + self.beta_increment)

DQN eğitim döngüsünde PER

Döngü öncesi kodda:

buffer = PrioritizedReplayBuffer(capacity)

Her bölümün başında:
```
buffer.increase_beta()
```

3. Her adımda:

# Aksiyon seçildikten sonra
buffer.push(state, action, reward, 
            next_state, done)
...

# TD hatalarını hesaplamadan önce:
replay_buffer.sample(batch_size)
...

# TD hatalarını hesapladıktan sonra
buffer.update_priorities(indices, td_errors)

loss = torch.sum(weights * (td_errors ** 2))

PER’in uygulaması: Cartpole

Cartpole ortamında 100 eğitim çalışması:

Öncelikli Deneyim Tekrarı ile
Üniform Deneyim Tekrarı ile

PER ile öğrenme daha hızlı ve performans daha iyi; üniform tekrar yürütmeden üstün

Öğrenme eğrileri PER’in daha hızlı öğrendiğini gösteriyor

100 epoch sonra: Cartpole, 100 epoch sonra kararsız

400 epoch sonra: Cartpole, 400 epoch sonra kararlı

PER’in uygulaması: Atari ortamları

Atari ortamlarında PER ile belirgin performans artışı

İnsanlar, DQN, DDQN, Dueling DDQN, Öncelikli DDQN ve Öncelikli Dueling DQN performanslarını karşılaştıran çubuk grafik. İlk dördü önceki dersteki grafikle aynı. Sonuncusu, Öncelikli Deneyim Tekrarının DDQN performansını artırdığını gösterir.

¹ https://arxiv.org/abs/2303.11634

Hadi pratik yapalım!

Python ile Deep Reinforcement Learning