Yakınsal politika optimizasyonu

Python ile Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

A2C

A2C politika güncellemeleri:
- Oynak tahminlere dayalı
- Büyük ve dengesiz olabilir
Performansa zarar verebilir

Bir Mars gezgini engebeli arazide kaza geçirip bozulmuş halde yatıyor

PPO

PPO, her politika güncellemesinin boyutuna sınır koyar
Kararlılığı artırır

Bir Mars gezgini Mars yüzeyinde keyifle ilerliyor

Olasılık oranı

PPO’nun ana yeniliği: yeni bir amaç fonksiyonu
Özünde:

Olasılık oranı: yeni politika altındaki bir eylemin olasılığı ile eski politika altındaki olasılığın oranı, r_t ile gösterilir

$\theta$ ile eylem $a_t$, $\theta_{old}$’a kıyasla ne kadar daha olası?

  ratio = action_log_prob.exp() / 
          old_action_log_prob.exp().detach()

  # Veya eşdeğeri
  ratio = torch.exp(action_log_prob - 
          old_action_log_prob.detach())

Gradyan yayılımını önlemek için paydada detach kullanın

Olasılık oranını kırpmak

Clip işlevi:

clip(x, 0.8, 1.2) fonksiyonunun x=0.6 ile x=1.4 arasındaki grafiği; x<0.8’de .8’e eşit; 0.8-1.2 arasında x; 1.2’nin üstünde 1.2.

Kırpılmış olasılık oranı: clip(r_t, 1-epsilon, 1+epsilon)

clipped_ratio = torch.clamp(ratio,
                            1-epsilon, 
                            1+epsilon)

calculate_ratios işlevi

def calculate_ratios(action_log_prob, action_log_prob_old, epsilon):

    prob = action_log_prob.exp()
    prob_old = action_log_prob_old.exp()
    prob_old_detached = prob_old.detach()
    ratio = prob / prob_old_detached
    clipped_ratio = torch.clamp(ratio, 1-epsilon, 1+epsilon)

    return (ratio, clipped_ratio)

Epsilon = .2 örneği:

        Oran: tensor(1.25)

Kırpılmış oran: tensor(1.20)

PPO amaç fonksiyonu

J surr = E_t(r_t * advantage)

surr1 = ratio * td_error.detach()

surr2 = clipped_ratio * td_error.detach()

objective = torch.min(surr1, surr2)

Kırpılmış oranla vekil:

$$\mathrm{clip}(r_t(\theta),1-\varepsilon,1+\varepsilon)\hat{A}$$

PPO kırpılmış vekil amaç fonksiyonu:

Kırpılmış vekil amaç: oran * avantaj ile kırpılmış oran * avantajın min değerinin beklenen değeri.

A2C’den daha kararlı

PPO kayıp hesaplama

def calculate_losses(critic_network, 
                     action_log_prob,                                        
                     action_log_prob_old,
                     reward, state, next_state,
                     done
                     ):

    # TD hatası hesapla (A2C ile aynı)
    value = critic_network(state)
    next_value = critic_network(next_state)
    td_target = (reward + 
                 gamma * next_value * (1-done))
    td_error = td_target - value
    ...

    ...
    ratio, clipped_ratio = 
            calculate_ratios(action_log_prob, 
                             action_log_prob_old,
                             epsilon)

    surr1 = ratio * td_error.detach()

    surr2 = clipped_ratio * td_error.detach()

    objective = torch.min(surr1, surr2)

    actor_loss = -objective

    critic_loss = td_error ** 2

    return actor_loss, critic_loss

Hadi pratik yapalım!

Python ile Deep Reinforcement Learning