प्रॉक्सिमल पॉलिसी ऑप्टिमाइज़ेशन

Python में Deep Reinforcement Learning

Timothée Carayol

Principal Machine Learning Engineer, Komment

A2C

A2C पॉलिसी अपडेट्स:
- अस्थिर आकलनों पर आधारित
- बड़े और अस्थिर हो सकते हैं
परफॉर्मेंस को नुकसान हो सकता है

ऊबड़-खाबड़ इलाके में हादसे के बाद टूटा पड़ा एक मार्स रोवर

PPO

PPO हर पॉलिसी अपडेट के आकार पर सीमा लगाता है
स्थिरता बढ़ती है

मार्स की सतह पर आराम से चलता हुआ एक मार्स रोवर

प्रोबेबिलिटी रेशियो

PPO की मुख्य नवाचार: एक नया ऑब्जेक्टिव फंक्शन
मूल विचार:

प्रोबेबिलिटी रेशियो: नई पॉलिसी के तहत किसी ऐक्शन की प्रायिकता और पुरानी पॉलिसी के तहत प्रायिकता का अनुपात, जिसे r_t लिखते हैं

$\theta$ की तुलना में $\theta_{old}$ के साथ ऐक्शन $a_t$ कितना अधिक संभावित है?

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

  # Or equivalently
  ratio = torch.exp(action_log_prob - 
          old_action_log_prob.detach())

ग्रेडिएंट के प्रसार से बचाने के लिए हर में detach करें

प्रोबेबिलिटी रेशियो को क्लिप करना

क्लिप फंक्शन:

x=0.6 और x=1.4 के बीच clip(x, 0.8, 1.2) का ग्राफ; x<0.8 पर 0.8; 0.8–1.2 के बीच x; 1.2 से ऊपर 1.2.

क्लिप्ड प्रोबेबिलिटी रेशियो है clip(r_t, 1-epsilon, 1+epsilon)

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

calculate_ratios फंक्शन

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:

        Ratio: tensor(1.25)

Clipped ratio: tensor(1.20)

PPO का ऑब्जेक्टिव फंक्शन

J surr = E_t(r_t * advantage)

surr1 = ratio * td_error.detach()

surr2 = clipped_ratio * td_error.detach()

objective = torch.min(surr1, surr2)

क्लिप्ड रेशियो के साथ सरोगेट:

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

PPO क्लिप्ड सरोगेट ऑब्जेक्टिव फंक्शन:

क्लिप्ड सरोगेट ऑब्जेक्टिव फंक्शन: ratio * advantage और clipped ratio * advantage के न्यूनतम का अपेक्षित मान.

A2C से अधिक स्थिर

PPO लॉस कैलकुलेशन

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

    # calculate TD error (same as A2C)
    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

अभ्यास करते हैं!

Python में Deep Reinforcement Learning