文章目錄

• Deriving the Simplest Policy Gradient
• • • 1.軌跡的概率 （Probability of a Trajectory）
    • 2.對數導數技巧
    • 3.軌跡的對數概率
    • 4.環境函數的梯度
    • 5.軌跡的梯度對數概率
    • 綜上所述，我們得出以下結論：
• Implementing the Simplest Policy Gradient
• • • 1.建立策略網絡
    • 2.構建損失函數
    • 3.運行訓練的一個Epoch
• Expected Grad-Log-Prob Lemma
• Don't Let the Past Distract You
• Implementing Reward-to-Go Policy Gradient
• Baselines in Policy Gradients
• Other Forms of the Policy Gradient
• Reference:

在本節中，我們將討論政策優化算法的數學基礎, 我們將介紹政策梯度理論中的三個關鍵結果：

• 關于策略參數的最簡單的等式描述策略表現的梯度，
• 一條規則，允許我們從該表達式中刪除無用的術語，
• 以及允許我們在該表達式中添加有用術語的規則。

最后，我們將這些結果結合在一起，并描述策略梯度的基于優勢的表達式，這是我們在Vanilla Policy Gradient實現中使用的版本。

Deriving the Simplest Policy Gradient

在這里，我們考慮一種隨機的，參數化的策略，${\pi }_{\theta }$. 我們的目標是最大化期望收益 $J({\pi }_{\theta })=E_{\tau ～{\pi }_{\theta }}R(\tau )$。 出于此推導的目的，我們將使用$R(\tau )$來給出有限步長的無折扣收益，此外無限步長的折現收益設置的推導幾乎是相同的。

我們想通過梯度上升來優化策略，例如：
$${\theta }_{k+1}={\theta }_k+\alpha {?}_{\theta }J({\pi }_{\theta }){|}_{{\theta }_k}.$$

策略的梯度${?}_{\theta }J({\pi }_{\theta })$稱為策略梯度，以這種方式優化策略的算法稱為策略梯度算法。 （示例包括Vanilla Policy Gradient和TRPO。PPO通常被稱為策略梯度算法，盡管這有點不準確。）

要實際使用此算法，我們需要一個可以通過數值計算的策略梯度表達式。 這涉及兩個步驟：1）得出策略表現的分析梯度，結果證明是期望值的形式，然后2）構建該期望值的樣本估計值，可以使用代理與環境相互作用有限數量的數據來計算 。

在本小節中，我們將找到該表達式的最簡單形式。 在后面的小節中，我們將展示如何以最簡單的形式進行改進，以獲取我們在標準策略梯度實現中實際使用的版本。

我們將從列出一些對得出分析梯度有用的事實開始。

1.軌跡的概率 （Probability of a Trajectory）

給定動作來自${\pi }_{\theta }$的軌跡$\tau =（s_0，a_0，...，s_{T+1}）$的概率為:
$$P(\tau |\theta )={\rho }_0(s_0)\prod _{t=0}^{T}P(s_{t+1}|s_t,a_t){\pi }_{\theta }(a_t|s_t).$$

2.對數導數技巧

對數導數技巧是基于微積分的簡單規則：$logx$相對于x的導數為1 ? x。 重新排列并與鏈式規則結合后，我們得到：

$${?}_{\theta }P(\tau |\theta )=P(\tau |\theta ){?}_{\theta }\log P(\tau |\theta ).$$

3.軌跡的對數概率

軌跡的對數概率就是:
$$\log P(\tau |\theta )=\log {\rho }_0(s_0)+\sum _{t=0}^T(\log P(s_{t+1}|s_t,a_t)+\log {\pi }_{\theta }(a_t|s_t)).$$

4.環境函數的梯度

環境不依賴于$\theta$，因此${\rho }_0(s_0),P(s_{t+1}|s_t，a_t)$和$R（\tau ）$的梯度為零。

5.軌跡的梯度對數概率

因此，軌跡的對數概率的梯度為
$$\begin{array}{rl}{?}_{\theta }\log P(\tau |\theta )& ={?}_{\theta }\log {\rho }_0(s_0)+\sum _{t=0}^T({?}_{\theta }\log P(s_{t+1}|s_t,a_t)+{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t))\\ & =\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)\end{array}.$$

綜上所述，我們得出以下結論：

$$\begin{array}{rlr}{?}_{\theta }J({\pi }_{\theta })& ={?}_{\theta }{E}_{\tau ～{\pi }_{\theta }}R(\tau )& \\ & ={?}_{\theta }{\int }_{\tau }P(\tau |\theta )R(\tau )& \text{Expand?expectation}\\ & ={\int }_{\tau }{?}_{\theta }P(\tau |\theta )R(\tau )& \text{Bring?gradient?under?integral}\\ & ={\int }_{\tau }P(\tau |\theta ){?}_{\theta }\log P(\tau |\theta )R(\tau )& \text{Log-derivative?trick}\\ & =E_{\tau ～{\pi }_{\theta }}{?}_{\theta }\log P(\tau |\theta )R(\tau )& \text{Return?to?expectation?form}\\ \therefore {?}_{\theta }J({\pi }_{\theta })& =E_{\tau ～{\pi }_{\theta }}\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)R(\tau )& \text{Expression?for?grad-log-prob}\end{array}$$

這是一個期望，這意味著我們可以使用樣本均值對其進行估計。 如果我們收集一組軌跡：$\mathcal{D}=\{{\tau }_i{\}}_{i=1,...,N}$`，其中通過使代理${\pi }_{\theta }$在環境中作用獲得每個軌跡 ，策略梯度可以使用以下作為估計：
$$\hat{g}=\frac{1}{|\mathcal{D}|}\sum _{\tau \in \mathcal{D}}\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)R(\tau ),$$

其中$|\mathcal{D}|$ 是 $\mathcal{D}$ 中軌跡$\tau$的個數(here, $N$).

最后一個表達式是我們想要的可計算表達式的最簡單版本。 假設我們以可計算出 ${?}_{\theta }\log {\pi }_{\theta }(a|s)$ 的方式表示我們的策略，并且如果是在能夠收集軌跡數據集的環境中，我們可以計算策略梯度并采取更新步驟。

Implementing the Simplest Policy Gradient

我們在spinup / examples / pg_math / 1_simple_pg.py中給出了這個簡單版本的策略梯度算法的簡短Tensorflow實現。 （也可以在github https://github.com/openai/spinningup/blob/master/spinup/examples/pg_math/1_simple_pg.py __上查看）。它只有122行，因此我們高度重視 建議您深入閱讀。 盡管我們不會在此處介紹全部代碼，但我們將重點介紹一些重要的部分。

1.建立策略網絡

# make core of policy networkobs_ph = tf.placeholder(shape=(None, obs_dim), dtype=tf.float32)logits = mlp(obs_ph, sizes=hidden_sizes+[n_acts]) # make action selection op (outputs int actions, sampled from policy)actions =tf.squeeze(tf.multinomial(logits=logits,num_samples=1), axis=1)

此塊構建了前饋神經網絡分類策略。 （有關更新，請參閱第1部分中的隨機策略部分。）logits張量可用于構造對數概率和操作的概率，而action張量基于logit隱含的概率對操作進行采樣。

2.構建損失函數

# make loss function whose gradient, for the right data, is policy gradientweights_ph = tf.placeholder(shape=(None,), dtype=tf.float32)act_ph = tf.placeholder(shape=(None,), dtype=tf.int32)action_masks = tf.one_hot(act_ph, n_acts)log_probs = tf.reduce_sum(action_masks * tf.nn.log_softmax(logits), axis=1)loss = -tf.reduce_mean(weights_ph * log_probs)

在此塊中，我們為策略梯度算法構建“損失”函數。 當插入合適的數據時，策略梯度等于這個損失的梯度。 合適的數據表示根據當前策略執行操作時收集的一組（狀態，動作，權重）元組，其中狀態-動作對的權重是從其所屬回合返回的。 （盡管我們將在后面的小節中顯示，但是您可以插入其他值來也可以正常工作的重量。）

即使我們將其描述為損失函數，但從監督學習的角度來看，它并不是典型的損失函數。與標準損失函數有兩個主要區別。
1.數據分布取決于參數。損失函數通常在固定的數據分布上定義，該分布與我們要優化的參數無關。這里不是，必須在最新策略上對數據進行采樣。
2.它無法衡量效果。損失函數通常會評估我們關注的性能指標。在這里，我們關心期望收益$J({\pi }_{\theta })$，但即使在期望中，我們的“損失”函數也根本不近似。此“損失”功能僅對我們有用，因為當在當前參數下進行評估時，使用當前參數生成的數據時，其性能會呈現負梯度。
但是，在梯度下降的第一步之后，就不再與性能相關。這意味著，對于給定的一批數據，最小化此“損失”功能無法保證提高預期收益。可以將這一損失放到$?\infty$，而策略表現能可能會下降；實際上，通常會這樣。有時，資深RL研究人員可能會將此結果描述為對大量數據“過度擬合”的策略。這是描述性的，但不應從字面上理解，因為它沒有涉及泛化錯誤。
我們提出這一點是因為，ML練習者通常會在訓練過程中將損失函數解釋為有用的信號-“如果損失減少了，一切都會好起來的。”在政策梯度中，這種直覺是錯誤的，您應該只在乎平均回報率。損失函數沒有任何意義。

此處用于制作log_probs張量的方法（創建操作掩碼，并使用它來選擇特定的對數概率）僅適用于分類策略。 通常它不起作用。

3.運行訓練的一個Epoch

# for training policy def train_one_epoch():# make some empty lists for logging.batch_obs = [] # for observationsbatch_acts = [] # for actionsbatch_weights = [] # for R(tau) weighting in policy gradientbatch_rets = [] # for measuring episode returnsbatch_lens = [] # for measuring episode lengths# reset episode-specific variablesobs = env.reset() # first obs comes from starting distributiondone = False # signal from environment that episode is overep_rews = [] # list for rewards accrued throughout ep# render first episode of each epochfinished_rendering_this_epoch = False# collect experience by acting in the environment with current policywhile True:# renderingif not(finished_rendering_this_epoch):env.render()# save obsbatch_obs.append(obs.copy())# act in the environmentact = sess.run(actions, {obs_ph: obs.reshape(1,-1)})[0]obs, rew, done, _ = env.step(act)# save action, rewardbatch_acts.append(act)ep_rews.append(rew)if done:# if episode is over, record info about episodeep_ret, ep_len = sum(ep_rews), len(ep_rews)batch_rets.append(ep_ret)batch_lens.append(ep_len)# the weight for each logprob(a|s) is R(tau)batch_weights += [ep_ret] * ep_len# reset episode-specific variablesobs, done, ep_rews = env.reset(), False, []# won't render again this epochfinished_rendering_this_epoch = True# end experience loop if we have enough of itif len(batch_obs) > batch_size:break# take a single policy gradient update stepbatch_loss, _ = sess.run([loss, train_op],feed_dict={obs_ph: np.array(batch_obs),act_ph: np.array(batch_acts),weights_ph: np.array(batch_weights)})return batch_loss, batch_rets, batch_lens

train_one_epoch（）函數運行策略梯度的一個“epoch”，我們定義為

• 1.經驗收集步驟（L62-97），其中代理使用最新策略在環境中互動一定數量的回合，其后是
• 2.一個策略梯度的更新 (L99-105).

Expected Grad-Log-Prob Lemma

在本小節中，我們將得出一個中間結果，該結果在整個政策梯度理論中得到了廣泛使用。 我們將其稱為“梯度對數概率期望（EGLP）”引理 [1]。

EGLP引理。 假設$P_{\theta }$是隨機變量x上的參數化概率分布。 然后：

$$E_{x～P_{\theta }}{?}_{\theta }\log P_{\theta }(x)=0.$$

回想一下，所有概率分布都是“歸一化”的：
$${\int }_x{P}_{\theta }(x)=1.$$

取兩側的梯度：
$${?}_{\theta }{\int }_x{P}_{\theta }(x)={?}_{\theta }1=0.$$

使用對數派生技巧可以獲取：
$$\begin{array}{rl}0& ={?}_{\theta }{\int }_x{P}_{\theta }(x)\\ & ={\int }_x{?}_{\theta }{P}_{\theta }(x)\\ & ={\int }_x{P}_{\theta }(x){?}_{\theta }\log P_{\theta }(x)\\ \therefore 0& =E_{x～P_{\theta }}{?}_{\theta }\log P_{\theta }(x).\end{array}$$

[1] 本文的作者沒有意識到在文獻中的任何地方都給該引理指定了標準名稱。 但是考慮到它出現的頻率，似乎很值得給它起一個名字以便于參考。

Don’t Let the Past Distract You

到現在的策略梯度的表達變成了：
$${?}_{\theta }J({\pi }_{\theta })=E_{\tau ～{\pi }_{\theta }}\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)R(\tau ).$$

在這個梯度上邁出一步，將每個動作的對數概率與$R(\tau )$（曾經獲得的所有獎勵之和）成比例。 但這沒有多大意義。

代理實際上僅應根據其“后果”加強行動。 采取行動之前獲得的獎勵與行動的好壞沒有關系：僅在“之后”獲得獎勵。

事實證明，這種直覺體現在數學上，我們可以證明策略梯度也可以表示為
$${?}_{\theta }J({\pi }_{\theta })=E_{\tau ～{\pi }_{\theta }}[\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)\sum _{t^{\prime }=t}^{T}R(s_{t^{\prime }},a_{t^{\prime }},s_{t^{\prime }+1})].$$

以這種形式，僅基于采取行動后獲得的獎勵來加強行動。

我們稱這種形式為“未來獎勵策略梯度”，因為軌跡上某點之后的獎勵總和，
$${\hat{R}}_t?\sum _{t^{\prime }=t}^{T}R(s_{t^{\prime }},a_{t^{\prime }},s_{t^{\prime }+1}),$$

這就是從 t 時刻起的“未來獎勵”，而這種策略梯度表述取決于狀態動作對的“未來獎勵”。

但是，這會更好嗎？ 策略梯度的關鍵問題是需要多少個樣本軌跡才能獲得它們的低方差樣本估計。 我們從公式開始就包括了與過去的報酬成比例的加強行動的條件，所有這些均值均值為零，但方差不為零：結果，它們只會給策略梯度的樣本估計值增加噪音。 通過刪除它們，我們減少了所需的樣本軌跡數量。

An (optional) proof of this claim can be found here, and it ultimately depends on the EGLP lemma.

Implementing Reward-to-Go Policy Gradient

We give a short Tensorflow implementation of the reward-to-go policy gradient in spinup/examples/pg_math/2_rtg_pg.py. (It can also be viewed on github <https://github.com/openai/spinningup/blob/master/spinup/examples/pg_math/2_rtg_pg.py>_.)

The only thing that has changed from 1_simple_pg.py is that we now use different weights in the loss function. The code modification is very slight: we add a new function, and change two other lines. The new function is:

def reward_to_go(rews):n = len(rews)rtgs = np.zeros_like(rews)for i in reversed(range(n)):rtgs[i] = rews[i] + (rtgs[i+1] if i+1 < n else 0)return rtgs

然后我們從以下方法調整舊的L86-87，從：

# the weight for each logprob(a|s) is R(tau) batch_weights += [ep_ret] * ep_len

到：

# the weight for each logprob(a_t|s_t) is reward-to-go from t batch_weights += list(reward_to_go(ep_rews))

Baselines in Policy Gradients

EGLP引理的直接后果是，對于僅依賴狀態的任何函數$b$:
$$E_{a_t～{\pi }_{\theta }}{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)b(s_t)=0.$$

這使我們能夠從我們的策略梯度表達式中添加或減去任何數量的這樣的術語，而在期望中無需更改它：

$${?}_{\theta }J({\pi }_{\theta })=E_{\tau ～{\pi }_{\theta }}[\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t)\left(\sum _{t^{\prime }=t}^{T}R(s_{t^{\prime }},a_{t^{\prime }},s_{t^{\prime }+1})?b(s_t)\right)].$$

Any function b used in this way is called a baseline.
基準的最常見選擇是策略價值函數$V^{\pi }(s_t)$. 這是從狀態$s_t$開始，然后遵循策略$\pi$的代理所得到的平均回報。

根據經驗，選擇$b(s_t)=V^{\pi }(s_t)$具有減少策略梯度樣本估計中方差的理想效果。這樣可以更快，更穩定地學習策略。 從概念的角度來看，它也很吸引人：它編碼了一種直覺，即如果一個代理達到了預期，它將“感覺”到中立。

實際上，$V^{\pi }(s_t)$不能夠準確計算，所以它需要被近似。這通常用一個神經網絡來近似,$V_{?}(s_t)$,它可以與策略同時被更新（這樣值網絡總是近似最近策略的值函數）。
學習$V_{?}$的最簡單的方法, 被用在在較多數策略優化算法中（包括VPG,TRPO,PPO,A2C）,是去最小化均方誤差項:
$${?}_k=\arg \underset{?}{\min }{E}_{s_t,{\hat{R}}_t～{\pi }_k}\left[{\left(V_{?}(s_t)?{\hat{R}}_t\right)}^2\right],$$
其中${\pi }_k$是在第k個epoch的策略。這是從前一個值函數的參數${?}_{k?1}$,通過梯度下降的一個或多個步驟完成的.

Other Forms of the Policy Gradient

到目前為止，我們看到的是策略梯度具有一般形式：
$${?}_{\theta }J({\pi }_{\theta })=E_{\tau ～{\pi }_{\theta }}\sum _{t=0}^T{?}_{\theta }\log {\pi }_{\theta }(a_t|s_t){\Phi }_t,$$

其中${\Phi }_t$可以任意的這些形式：
$${\Phi }_t=R(\tau )$$

or:
$${\Phi }_t=\sum _{t^{\prime }=t}^{T}R(s_{t^{\prime }},a_{t^{\prime }},s_{t^{\prime }+1}),$$

or:
$${\Phi }_t=\sum _{t^{\prime }=t}^{T}R(s_{t^{\prime }},a_{t^{\prime }},s_{t^{\prime }+1})?b(s_t).$$

盡管有不同的差異，所有這些選擇都會導致相同的策略梯度期望值。 事實證明，有兩個權重 ${\Phi }_t$ 很重要:

• 1.On-Policy Action-Value Function.
  $${\Phi }_t=Q^{{\pi }_{\theta }}(s_t,a_t)$$

• 2. The Advantage Function.
  回憶動作的優勢函數, 定義為 $A^{\pi }(s_t,a_t)=Q^{\pi }(s_t,a_t)?V^{\pi }(s_t)$, （對于當前的策略）描述平均地相對于其他動作而言好還是壞。 這個選擇:$${\Phi }_t=A^{{\pi }_{\theta }}(s_t,a_t)$$也是有效的, 證據是它相當于使用${\Phi }_t=Q^{{\pi }_{\theta }(s_t,a_t)}$然后再使用一個值函數的基準。

具有優勢函數的策略梯度的制定極為普遍，并且有許多不同的方法來估算不同算法所使用的優勢函數。
要對此主題進行更詳細的處理，您應該閱讀有關廣義優勢估計（GAE）的文章，該文章深入探討了背景部分中${\Phi }_t$的不同選擇。
然后，該論文繼續描述GAE，GAE是一種在策略優化算法中具有廣泛用途的近似優勢函數的方法。 例如，Spinning Up的VPG，TRPO和PPO的實現都利用了它。 因此，我們強烈建議您進行研究。

Reference:

https://github.com/openai/spinningup

總結

以上是生活随笔為你收集整理的Policy Optimization-强化学习业界手册的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。