强化学习-李(二)-Policy-Based：Policy Gradient算法【“直接”训练出一个最优Actor/Policy π】【On：要训练的Actor=与环境互动生成训练数据的Actor】

$$\begin{array}{r}\text{强化学习算法}\{\begin{array}{l}\text{Value-Based Approach：Critic}\{\begin{array}{l}\text{State value function Vπ(s)}\\ \text{State-Action value function Qπ(s,a) ⟹ Q-Learning算法【训练Critic/值函数的参数：基于值函数结果来“间接”挑选最优 π】}\end{array}\\ \text{Policy-Based Approach：Policy Gradient算法【“直接”训练 Actor/Policy π 的参数】}\text{⟹ PPO算法}\\ \text{Actor+Critic}【\text{使用Critic（比如Q-Learning）作为Policy Gradient算法（包括PPO）中评估策略好坏（Advantage）的手段}】\end{array}\end{array}$$

一、什么是Policy

首先大致说明一下强化学习的基本结构：

如上图，一个由Agent/Actor（相当于我们的模型）和Environment（所处状态）组成的结构。

• Agent/Actor通过观察当前环境的状态 $s_t$ ，得出当前应当执行的动作 $a_t$ 。
• Agent/Actor执行完动作之后环境对应发生了改变，并且环境会给予Agent/Actor一个反馈reward $r_t$。此时又会是一个新的环境状态 $s^{\prime }$，
• 基于本次的环境状态，Agent/Actor又会执行对应的动作…以此类推持续进行下去，直到无法继续。

如下图所示，Env表示环境，Actor即为Agent/Actor：

上面实际上就是对一系列操作进行了抽象描述。如果以玩游戏为例说明，我们（Agent/Actor）通过观察游戏（Environment）的运行情况（State），选择接下来要执行的操作（Action），游戏往往还会反馈给我们我们的得分（Rewards）。

Actor 在不同的状态（State）采取的动作 Action 也就是我们所说的策略 Policy 。常用符号 $\pi$ 来表示策略。
$$\text{Action=π(Observation)}$$
其中：

1. $\text{Observation}$ 是函数 $\pi$ 的输入；
2. $\text{Action}$ 是函数 $\pi$ 的输出；
3. 策略(Policy)函数 $\pi$ 可以是一个 Neural Network 或者其他函数。如果函数 $\pi$ 是一个 Neural Network，则该 Reinforcemen Learning 就是 Deep Reinforcemen Learning。

二、怎样进行Policy Gradient

现在，我们大概能够猜测到了，Policy Gradient就是基于我们的策略Policy来做梯度下降从而优化我们的模型。

我们会希望Agent/Actor能够尽量能够执行较好的动作。那么我们会使用执行了该动作后得到的反馈reward来判定本次的策略优劣。

• 如上图所示的超级马里奥，在这个游戏运行状态下（state），假设我们可以选择的操作（policy）有“继续向前走”和“跳起”两种。
• 假设我们执行的操作为继续向前走，然后会碰到敌人，此时马里奥让自己变小或死亡，这个时候系统会得到比较不好的结果，返回的reward值会较小甚至是负的。
• 而假如我们选择起跳，那么我们会获得金币，并且还会将敌人踩死或是跳过，此时得到的结果则是较好的，返回的reward值会是较大的正数。

我们会希望Agent/Actor所做的Policy所做出来的反馈reward一直都会比较高。也就是说我们想要训练我们的Agent/Actor倾向于做出那些reward较高的动作。

三、用监督学习的角度看策略梯度下降

在监督学习中，我们会使用交叉熵来比较两个分布的差异。进而使用梯度下降法来逼近我们想要的梯度。
$$H(p,q)=-\sum _{x}p(x)log[q(x)]$$

• $p(x)$ 为对应的标签，
• $q(x)$ 为输出的概率。

然而，在强化学习中，是没有对应的 Label 的。那么我们怎么进行优化呢？这种情况，我们会把 Reward 来充当我们的Label。

具体怎么做呢，我们会在游戏中，多次运行我们的Agent/Actor，Agent/Actor会基于概率而采样选择不同的策略。假设一次状态行为序列为 $\tau (s_1,a_1,r_1,s_2,a_2,r_2,...,s_t,a_t)$ ，其中 $s_t$ 表示位于 $t$ 时刻的状态， $a_t$ 代表位于时刻 $t$ 时候所作出的动作。

基于不同的动作策略，我们会得到不同reward $R(\tau )$ 。假设运行得到比较好的分数得到了+3分，一般的分数得到了+1分，比较差的结果则得到了-1分。那么这个时候我们将会希望得到尽可能往+3分的结果，而-1分的则要尽量去避免。我们会使用如下的式子做为损失函数进行计算：
$$L(\theta )=-\frac{1}{N}\sum _{\tau }R(\tau )log{P}_{\theta }(\tau )$$

• 其中 $P_{\theta }(\tau )$ 表示采取 $\tau$ 策略的发生概率，
• N为采样 $\tau$ 的数目。

我们将其展开为假设情况有：

$$\begin{array}{rl}L(\theta )& =-\frac{1}{N}\sum _{\tau }R(\tau )log{P}_{\theta }(\tau )=-\frac{1}{3}[3\times log{P}_{\theta }({\tau }_1)+1\times log{P}_{\theta }({\tau }_2)+(-1)\times log{P}_{\theta }({\tau }_3)]\\ & =-\frac{1}{3}[(+3)\times 1\times log{P}_{\theta }({\tau }_1)+(+1)\times 1\times log{P}_{\theta }({\tau }_2)+(-1)\times 1\times log{P}_{\theta }({\tau }_3)]\end{array}$$

相比交叉熵的梯度下降，这里实际上就相当于在出现的概率上加了一个reward系数。什么意思呢?

• 直观上来讲，可以看做reward系数大的策略 $\tau$ 就多训练几下。
• 比如说，在超级玛丽这个游戏中，一次游戏中通过跳跃吃到了金币，那么在返回的reward如果为正的，那么会倾向于多训练几次这个过程，也可以视为向这个梯度方向多走几步。
• 而如果reward结果为负的，那么则可视为向原本这个梯度方向的反方向走几步，以后也就尽量减少这种策略出现的概率。
• 如下图采样执行了三种策略，反馈（打勾的）较好会训练更经常出现，而反馈较差的（打叉）的，则会训练让其较少出现。
  

四、关于每次动作的反馈

每次Episode的反馈来自于一次完整的动作叠加得到，即经历了一次完整的状态-行为序列后得到的

$$R(\tau )=\sum _{t=1}^{T}r(s_t,a_t)$$

• 之所以这么做，是因为在中间状态时候，我们往往无法获得反馈。只有当本次Episode结束才能得到本次Episode整体的反馈。
• 比如说在围棋比赛中，我们下的棋，一般情况下是得不到反馈的，只有在棋局结束的时候，通过输赢我们才能够知道我们这些子下的好不好。

那么这样就造成了一个问题：假如一盘游戏输了，那么我们就会全盘否定掉本次游戏中所做的所有操作。那么如果本次游戏中的一些好的操作，是不是也会相应地被否定掉了？答案是肯定的，这些操作同样会被限制出现，如下假设反馈为-1时。
$$\begin{array}{rl}{L}_{\tau }(\theta )& =R_{\theta }(\tau )log{P}_{\theta }(\tau )=-[-1\times log{P}_{\theta }({\tau }_1)]\end{array}$$
但是我们也会发现，好的操作普遍存在于好的反馈游戏结局中。当我们采样足够多的时候，这些操作就会较多地被肯定了，那么最终还是会被较好地训练到的。

假设说在一次游戏中，采样了以下 ${\tau }_1,{\tau }_2,{\tau }_3$ 三种过程并得到了三种过程所对应的reward。

τ 1 = { s 1 , j u m p , s 2 , l e f t , s 3 , l e f t } , R ( τ 1 ) = − 1 τ_1=\{s_1,jump,s_2,left,s_3,left\},\quad R(τ_1)=-1 τ1​={s1​,jump,s2​,left,s3​,left},R(τ1​)=−1
τ 2 = { s 1 , r i g h t , s 2 , r i g h t , s 3 , r i g h t } , R ( τ 1 ) = 1 τ_2=\{s_1,right,s_2,right,s_3,right\},\quad R(τ_1)=1 τ2​={s1​,right,s2​,right,s3​,right},R(τ1​)=1
τ 3 = { s 1 , j u m p , s 2 , r i g h t , s 3 , r i g h t } , R ( τ 1 ) = 3 τ_3=\{s_1,jump,s_2,right,s_3,right\},\quad R(τ_1)=3 τ3​={s1​,jump,s2​,right,s3​,right},R(τ1​)=3

我们可以看到 ${\tau }_1$ 在 $s_1$ 状态下选择动作为 $jump$ 时最终得到的 reward 为 $-1$ ，而 ${\tau }_3$ 在 $s_1$ 状态相比 ${\tau }_1$ 选择了 $jump$ 最终得到的结果却是 $3$ 。基于上面的样本可以看到在 $s_1$ 状态下使用 $jump$ 是有可能得到更多的正向反馈的。(假定这里的 ${\tau }_1,{\tau }_2,{\tau }_3$ 的 $s_1,s_2,s_3$ 分别都为相同状态，即：$s_1^1=s_1^2=s_1^3=s_1,s_2^1=s_2^2=s_2^3=s_2,s_3^1=s_3^2=s_3^3=s_3$)

我们带入损失函数并求其梯度得到：

∇ θ L ( θ ) = − 1 N ∇ θ ∑ τ = 1 T R ( τ ) l o g P θ ( τ ) = − 1 N ∑ τ = 1 T R ( τ ) ∇ θ l o g P θ ( τ ) = − 1 3 [ R ( τ 1 ) ∇ θ l o g P θ ( τ 1 ) + R ( τ 2 ) ∇ θ l o g P θ ( τ 2 ) + R ( τ 3 ) ∇ θ l o g P θ ( τ 3 ) ] = − 1 3 [ ( − 1 ) × ∇ θ l o g P θ ( τ 1 ) + 1 × ∇ θ l o g P θ ( τ 2 ) + 3 × ∇ θ l o g P θ ( τ 3 ) ] = − 1 3 { ( − 1 ) × ∇ θ [ l o g P θ ( a 1 1 ∣ s 1 1 ) + l o g P θ ( a 2 1 ∣ s 2 1 ) + l o g P θ ( a 3 1 ∣ s 3 1 ) ] + 1 × ∇ θ [ l o g P θ ( a 1 2 ∣ s 1 2 ) + l o g P θ ( a 2 2 ∣ s 2 2 ) + l o g P θ ( a 3 2 ∣ s 3 2 ) ] + 3 × ∇ θ [ l o g P θ ( a 1 3 ∣ s 1 3 ) + l o g P θ ( a 2 3 ∣ s 2 3 ) + l o g P θ ( a 3 3 ∣ s 3 3 ) ] } = − 1 3 { ( − 1 ) × ∇ θ [ l o g P θ ( j u m p ∣ s 1 1 ) + l o g P θ ( l e f t ∣ s 2 1 ) + l o g P θ ( l e f t ∣ s 3 1 ) ] + 1 × ∇ θ [ l o g P θ ( r i g h t ∣ s 1 2 ) + l o g P θ ( r i g h t ∣ s 2 2 ) + l o g P θ ( r i g h t ∣ s 3 2 ) ] + 3 × ∇ θ [ l o g P θ ( j u m p ∣ s 1 3 ) + l o g P θ ( r i g h t ∣ s 2 3 ) + l o g P θ ( r i g h t ∣ s 3 3 ) ] } = − 1 3 { 2 × ∇ θ l o g P θ ( j u m p ∣ s 1 ) + ∇ θ l o g P θ ( r i g h t ∣ s 1 ) ( − 1 ) × ∇ θ l o g P θ ( l e f t ∣ s 2 ) + 4 × ∇ θ l o g P θ ( r i g h t ∣ s 2 ) + ( − 1 ) × ∇ θ l o g P θ ( l e f t ∣ s 3 ) + 4 × ∇ θ l o g P θ ( r i g h t ∣ s 3 ) } \begin{aligned} \nabla_θ L(θ)&=-\cfrac1N \nabla_θ \sum^{Τ}_{τ=1}R(τ)logP_θ(τ)\\ &=-\cfrac1N \sum^{Τ}_{τ=1}R(τ)\nabla_θ logP_θ(τ)\\ &=-\cfrac13 [R(τ_1)\nabla_θ logP_θ(τ_1)+R(τ_2)\nabla_θ logP_θ(τ_2)+R(τ_3)\nabla_θ logP_θ(τ_3)]\\ &=-\cfrac13 [(-1)×\color{red}{\nabla_θ logP_θ(τ_1)}+1×\color{blue}{\nabla_θ logP_θ(τ_2)}+3×\color{violet}{\nabla_θ logP_θ(τ_3)}]\\ &=-\cfrac13 \{\\ &\qquad \quad (-1)×\color{red}{\nabla_θ [logP_θ(a^1_1|s^1_1)+logP_θ(a^1_2|s^1_2)+logP_θ(a^1_3|s^1_3)]}\\ &\qquad \quad +1×\color{blue}{\nabla_θ [logP_θ(a^2_1|s^2_1)+logP_θ(a^2_2|s^2_2)+logP_θ(a^2_3|s^2_3)]}\\ &\qquad \quad +3×\color{violet}{\nabla_θ [logP_θ(a^3_1|s^3_1)+logP_θ(a^3_2|s^3_2)+logP_θ(a^3_3|s^3_3)]}\\ &\qquad \quad \}\\ &=-\cfrac13 \{\\ &\qquad \quad (-1)×\color{red}{\nabla_θ [logP_θ(jump|s^1_1)+logP_θ(left|s^1_2)+logP_θ(left|s^1_3)]}\\ &\qquad \quad +1×\color{blue}{\nabla_θ [logP_θ(right|s^2_1)+logP_θ(right|s^2_2)+logP_θ(right|s^2_3)]}\\ &\qquad \quad +3×\color{violet}{\nabla_θ [logP_θ(jump|s^3_1)+logP_θ(right|s^3_2)+logP_θ(right|s^3_3)]}\\ &\qquad \quad \}\\ &=-\cfrac13 \{\\ &\qquad \quad 2×\nabla_θ logP_θ(jump|s_1)+\nabla_θ logP_θ(right|s_1)\\ &\qquad \quad (-1)×\nabla_θ logP_θ(left|s_2)+4×\nabla_θ logP_θ(right|s_2)\\ &\qquad \quad +(-1)×\nabla_θ logP_θ(left|s_3)+4×\nabla_θ logP_θ(right|s_3)\\ &\qquad \quad \} \end{aligned} ∇θ​L(θ)​=−N1​∇θ​τ=1∑T​R(τ)logPθ​(τ)=−N1​τ=1∑T​R(τ)∇θ​logPθ​(τ)=−31​[R(τ1​)∇θ​logPθ​(τ1​)+R(τ2​)∇θ​logPθ​(τ2​)+R(τ3​)∇θ​logPθ​(τ3​)]=−31​[(−1)×∇θ​logPθ​(τ1​)+1×∇θ​logPθ​(τ2​)+3×∇θ​logPθ​(τ3​)]=−31​{(−1)×∇θ​[logPθ​(a11​∣s11​)+logPθ​(a21​∣s21​)+logPθ​(a31​∣s31​)]+1×∇θ​[logPθ​(a12​∣s12​)+logPθ​(a22​∣s22​)+logPθ​(a32​∣s32​)]+3×∇θ​[logPθ​(a13​∣s13​)+logPθ​(a23​∣s23​)+logPθ​(a33​∣s33​)]}=−31​{(−1)×∇θ​[logPθ​(jump∣s11​)+logPθ​(left∣s21​)+logPθ​(left∣s31​)]+1×∇θ​[logPθ​(right∣s12​)+logPθ​(right∣s22​)+logPθ​(right∣s32​)]+3×∇θ​[logPθ​(jump∣s13​)+logPθ​(right∣s23​)+logPθ​(right∣s33​)]}=−31​{2×∇θ​logPθ​(jump∣s1​)+∇θ​logPθ​(right∣s1​)(−1)×∇θ​logPθ​(left∣s2​)+4×∇θ​logPθ​(right∣s2​)+(−1)×∇θ​logPθ​(left∣s3​)+4×∇θ​logPθ​(right∣s3​)}​

这样一波计算下来，可以看到，对于 $s_1$ 状态下的 $jump$ 最终还是得到的是正反馈。由此可见，只要采样充分，我们并不需要担心在不良反馈结局下的某些好的操作会被消除。

五、Policy Gradient详细推导

• Policy Gradient is used in Policy-Based Approach to learn an Actor/Policy π。
• 每一次的 episode 都被认为是一个轨迹(trajectory) $\tau$
  τ = { s 1 , a 1 , r 1 , s 2 , a 2 , r 2 , . . . , s T , a T , r T } τ=\{s_1,a_1,r_1,s_2,a_2,r_2,...,s_T,a_T,r_T\} τ={s1​,a1​,r1​,s2​,a2​,r2​,...,sT​,aT​,rT​}
• Actor每次Episode的反馈来自于一次完整的动作叠加得到，即经历了一次完整的状态-行为序列后得到的
  $$R(\tau )=\sum _{t=1}^{T}r(s_t,a_t)$$
• 理论上，Actor要重复无数次Episode，但实践中只能重复 $N$次，得到 $N$ 个 $\tau$，每一个 ${\tau }^i$ 都有 一定几率 $P(\tau |\theta )$ 被取样，则这 $N$次 Episode 的所有的 $R({\tau }^i)$ 的期望值(均值) ${\overline{R}}_{\theta }$ 为：

$${\overline{R}}_{\theta }=\sum _{i=1}^{\infty }R({\tau }^i)P({\tau }^i|\theta )\approx \frac{1}{N}\sum _{i=1}^{N}R({\tau }^i)$$

• 上式中的 $\approx$ 表示：利用Actor ${\pi }_{\theta }$ 重复 $N$次Episode $⟺$ 从 $\tau$ 的分布 $P(\tau |\theta )$ 中取样 $N$ 次。
  ∇ R ‾ θ = ∇ θ ∑ i = 1 ∞ R ( τ i ) ⋅ P ( τ i ∣ θ ) = R ( τ i ) 与 θ 无关 ∑ i = 1 ∞ R ( τ i ) ⋅ ∇ θ P ( τ i ∣ θ ) = ∑ i = 1 ∞ R ( τ i ) ⋅ P ( τ i ∣ θ ) ⋅ ∇ θ P ( τ i ∣ θ ) P ( τ i ∣ θ ) = ∑ i = 1 ∞ R ( τ i ) ⋅ P ( τ i ∣ θ ) ⋅ ∇ θ l o g [ P ( τ i ∣ θ ) ] ≈ 1 N ∑ i = 1 N R ( τ i ) ⋅ ∇ θ l o g [ P ( τ i ∣ θ ) ] = 1 N ∑ i = 1 N R ( τ i ) ⋅ ∇ θ l o g [ p ( s 1 i ) p ( a 1 i ∣ s 1 i , θ ) p ( r 1 i , s 2 i ∣ s 1 i , a 1 i ) p ( a 2 i ∣ s 2 i , θ ) p ( r 2 i , s 3 i ∣ s 2 i , a 2 i ) ⋅ ⋅ ⋅ p ( a t i ∣ s t i , θ ) p ( r t i , s t + 1 i ∣ s t i , a t i ) ] = 1 N ∑ i = 1 N R ( τ i ) ⋅ ∇ θ l o g [ p ( s 1 i ) ⋅ ∏ t = 1 T p ( a t i ∣ s t i , θ ) ⋅ p ( r t i , s t + 1 i ∣ s t i , a t i ) ] = 1 N ∑ i = 1 N R ( τ i ) ⋅ ∇ θ { l o g [ p ( s 1 i ) ] + ∑ t = 1 T l o g [ p ( a t i ∣ s t i , θ ) ] + ∑ t = 1 T l o g [ p ( r t i , s t + 1 i ∣ s t i , a t i ) ] } = 1 N ∑ i = 1 N R ( τ i ) ⋅ { ∇ θ l o g [ p ( s 1 i ) ] + ∑ t = 1 T ∇ θ l o g [ p ( a t i ∣ s t i , θ ) ] + ∑ t = 1 T ∇ θ l o g [ p ( r t i , s t + 1 i ∣ s t i , a t i ) ] } = 1 N ∑ i = 1 N R ( τ i ) ⋅ [ 0 + ∑ t = 1 T ∇ θ l o g [ p ( a t i ∣ s t i , θ ) ] + 0 ] = 1 N ∑ i = 1 N R ( τ i ) ⋅ ∑ t = 1 T ∇ θ l o g [ p ( a t i ∣ s t i , θ ) ] = 1 N ∑ i = 1 N ∑ t = 1 T R ( τ i ) ⋅ ∇ θ l o g [ p ( a t i ∣ s t i , θ ) ] \begin{aligned} \nabla\overline{R}_θ&=\nabla_θ\sum^∞_{i=1}R(τ^i)·P(τ^i|θ)\\ &\xlongequal{R(τ^i)与θ无关}\sum^∞_{i=1}R(τ^i)·\nabla_θP(τ^i|θ)\\ &=\sum^∞_{i=1}R(τ^i)·P(τ^i|θ)·\cfrac{\nabla_θP(τ^i|θ)}{P(τ^i|θ)}\\ &=\sum^∞_{i=1}R(τ^i)·P(τ^i|θ)·\nabla_θlog[P(τ^i|θ)]\\ &≈\cfrac1N\sum^N_{i=1}R(τ^i)·\nabla_θlog[P(τ^i|θ)]\\ &=\cfrac1N\sum^N_{i=1}R(τ^i)·\nabla_θlog[p(s^i_1)p(a^i_1|s^i_1,θ)p(r^i_1,s^i_2|s^i_1,a^i_1)p(a^i_2|s^i_2,θ)p(r^i_2,s^i_3|s^i_2,a^i_2)···p(a^i_t|s^i_t,θ)p(r^i_t,s^i_{t+1}|s^i_t,a^i_t)]\\ &=\cfrac1N\sum^N_{i=1}R(τ^i)·\nabla_θlog[\color{violet}{p(s^i_1)}·\color{black}{\prod^T_{t=1} p(a^i_t|s^i_t,θ)}·\color{violet}{p(r^i_t,s^i_{t+1}|s^i_t,a^i_t)}\color{black}{]}\\ &=\cfrac1N\sum^N_{i=1}R(τ^i)·\nabla_θ\{\color{violet}{log[p(s^i_1)]}+\color{black}{\sum^T_{t=1} log[p(a^i_t|s^i_t,θ)]}+\color{violet}{\sum^T_{t=1}log[p(r^i_t,s^i_{t+1}|s^i_t,a^i_t)}]\color{black}{\}}\\ &=\cfrac1N\sum^N_{i=1}R(τ^i)·\{\color{violet}{\nabla_θlog[p(s^i_1)]}+\color{black}{\sum^T_{t=1} \nabla_θlog[p(a^i_t|s^i_t,θ)]}+\color{violet}{\sum^T_{t=1}\nabla_θlog[p(r^i_t,s^i_{t+1}|s^i_t,a^i_t)]}\color{black}{\}}\\ &=\cfrac1N\sum^N_{i=1}R(τ^i)·[\color{violet}{0}+\color{black}{\sum^T_{t=1} \nabla_θlog[p(a^i_t|s^i_t,θ)]}+\color{violet}{0}\color{black}{]}\\ &=\cfrac1N\sum^N_{i=1}R(τ^i)·\sum^T_{t=1} \nabla_θlog[p(a^i_t|s^i_t,θ)]\\ &=\cfrac1N\sum^N_{i=1}\sum^T_{t=1} R(τ^i)·\nabla_θlog[p(a^i_t|s^i_t,θ)]\\ \end{aligned} ∇Rθ​​=∇θ​i=1∑∞​R(τi)⋅P(τi∣θ)R(τi)与θ无关 i=1∑∞​R(τi)⋅∇θ​P(τi∣θ)=i=1∑∞​R(τi)⋅P(τi∣θ)⋅P(τi∣θ)∇θ​P(τi∣θ)​=i=1∑∞​R(τi)⋅P(τi∣θ)⋅∇θ​log[P(τi∣θ)]≈N1​i=1∑N​R(τi)⋅∇θ​log[P(τi∣θ)]=N1​i=1∑N​R(τi)⋅∇θ​log[p(s1i​)p(a1i​∣s1i​,θ)p(r1i​,s2i​∣s1i​,a1i​)p(a2i​∣s2i​,θ)p(r2i​,s3i​∣s2i​,a2i​)⋅⋅⋅p(ati​∣sti​,θ)p(rti​,st+1i​∣sti​,ati​)]=N1​i=1∑N​R(τi)⋅∇θ​log[p(s1i​)⋅t=1∏T​p(ati​∣sti​,θ)⋅p(rti​,st+1i​∣sti​,ati​)]=N1​i=1∑N​R(τi)⋅∇θ​{log[p(s1i​)]+t=1∑T​log[p(ati​∣sti​,θ)]+t=1∑T​log[p(rti​,st+1i​∣sti​,ati​)]}=N1​i=1∑N​R(τi)⋅{∇θ​log[p(s1i​)]+t=1∑T​∇θ​log[p(ati​∣sti​,θ)]+t=1∑T​∇θ​log[p(rti​,st+1i​∣sti​,ati​)]}=N1​i=1∑N​R(τi)⋅[0+t=1∑T​∇θ​log[p(ati​∣sti​,θ)]+0]=N1​i=1∑N​R(τi)⋅t=1∑T​∇θ​log[p(ati​∣sti​,θ)]=N1​i=1∑N​t=1∑T​R(τi)⋅∇θ​log[p(ati​∣sti​,θ)]​

六、利用Policy Gradient迭代Actor

1、迭代过程

首先你要先随机初始化你的 Actor
你就给你的 Actor 一个随机初始化的参数，叫做 θ0
然后接下来你进入你的 Training Iteration
假设你要跑 T 个 Training Iteration 好 那你就拿你的这个
现在手上有的 Actor 一开始是这个 θ0 一开始很笨 它什么都不会 它采取的行为都是随机的
但它会越来越好 你拿你的 Actor 去跟环境做互动 那你就得到一大堆的 s 跟 a
你就得到一大堆的 s 跟 a 就把它互动的过程记录下来 得到这些 s 跟 a
那接下来你就要进行评价 你用 A1 到 AN 来决定说 这些 Action 到底是好还是不好
你先拿你的 Actor 去跟环境做互动 搜集到这些观察 接下来你要进行评价 看这些 Action 是好的还是不好的
设完这个 A 以后
就结束了 你就把 Loss 定义出来 然后 Update 你的 Model
这个 Update 的过程 就跟 Gradient Descent 一模一样的 会去计算 L 的 Gradient
前面乘上 Learning Rate 然后拿这个 Gradient 去 Update 你的 Model
就把 ${\theta }_{i-1}$ Update 成 ${\theta }_i$
但是这边有一个神奇的地方是：一般的 training 在我们到目前为止的 Training Data Collection 都是在 For 循环之外，比如说我有一堆资料，然后把这堆资料拿来做 Training 拿来 Update Model 很多次 然后最后得到一个收敛的参数，然后拿这个参数来做 Testing。
但在 RL 里面不是这样，你发现搜集资料这一段代码 Obtain data { s 1 , a 1 } , { s 2 , a 2 } , … , { s N , a N } \left\{s_{1}, a_{1}\right\},\left\{s_{2}, a_{2}\right\}, \ldots,\left\{s_{N}, a_{N}\right\} {s1​,a1​},{s2​,a2​},…,{sN​,aN​} 居然是在 For 循环里面，假设这个 For 循环你打算跑 400 次，那你就得搜集资料 400 次。

我们用一个图像化的方式来表示：

这个 Training Data 是你搜集到的资料， { s 1 , a 1 } \left\{s_{1}, a_{1}\right\} {s1​,a1​} 就是你观察了某一个 Actor在每一个 State 执行的 Action 。

然后接下来你给予一个评价 ${\mathrm{A}}_1,{\mathrm{A}}_2,{\mathrm{A}}_3,...,{\mathrm{A}}_N$。（但要用什么评价，要用哪一个版本，这个是你自己决定的，你给予一个评价，说每一个 Action 是好或不好。）

你有了这些资料 { s 1 , a 1 } , { s 2 , a 2 } , { s 3 , a 3 } , . . . { s N , a N } \left\{s_{1}, a_{1}\right\} , \left\{s_{2}, a_{2}\right\} , \left\{s_{3}, a_{3}\right\} , ... \left\{s_{N}, a_{N}\right\} {s1​,a1​},{s2​,a2​},{s3​,a3​},...{sN​,aN​} 以及对应的评价 ${\mathrm{A}}_1,{\mathrm{A}}_2,{\mathrm{A}}_3,...,{\mathrm{A}}_N$ 以后，拿去训练你的 Actor，你拿这些评价可以定义出一个 Loss。

然后你可以更新你的参数一次 ${\theta }^i\leftarrow {\theta }^{i-1}-\eta \nabla L$，但是有趣的地方是，你只能更新一次而已，一旦更新完一次参数以后，接下来你就要重新去搜集资料了。

更新一次参数以后，你就要重新搜集资料，才能更新下一次参数。所以这就是为什么 RL 的训练过程非常花时间：搜集资料这件事情居然是在 For 循环里面的，每次 Update 完一次参数以后，你的资料就要重新再搜集一次，再去 Update 参数，然后 Update 完一次以后又要再重新搜集资料。如果你参数要 Update 400 次，那你资料就要搜集 400 次，那这个过程显然非常地花时间。

那你接下来就会问说，那为什么会这样呢，为什么我们不能够一组资料，就拿来 Update 模型 Update 400 次，然后就结束了呢？

为什么每次 Update 完我们的模型参数以后，Update Network 参数以后就要重新再搜集资料呢？

一个比较简单的比喻是：

一个人的食物可能是另外一个人的毒药。这些资料是由 ${\theta }_{i-1}$ 所搜集出来的，这是 ${\theta }_{i-1}$ 跟环境互动的结果，这个是 ${\theta }_{i-1}$ 的经验，这些经验可以拿来更新 ${\theta }_{i-1}$ 的参数，但 ${\theta }_{i-1}$ 所搜集的资料不一定适合拿来 Update ${\theta }_i$ 的参数。

所以同一个 Action 对于不同的 Actor 而言， 它的好是不一样的。所以今天假设我们用 ${\theta }_{i-1}$ 搜集了一堆的资料，这个是 ${\theta }_{i-1}$ 的 Trajectory，这些资料只能拿来训练 ${\theta }_{i-1}$，你不能拿这些资料来训练 ${\theta }_i$。为什么不能拿这些资料来训练 ${\theta }_i$ 呢？

因为假设就算是从 ${\theta }_{i-1}$ 跟${\theta }_i$ 它们在 $s_1$ 都会采取 $a_1$，但之后到了 $s_2$ 以后它们可能采取的行为就不一样了。所以假设 ${\theta }_i$ 按照 ${\theta }_{i-1}$ 的 Trajectory，但是 ${\theta }_{i-1}$ 会执行的这个 Trajectory 跟 ${\theta }_i$ 它会采取的行为根本就不一样。所以你拿著 ${\theta }_{i-1}$ 接下来会得到的 Reward 来评估 ${\theta }_i$ 接下来会得到的 Reward 其实是不合适的。

所以今天我们在搜集资料来训练你的 Actor 的时候，你要注意就是搜集资料的那个 Actor要跟被训练的那个 Actor 最好就是同一个。

那当你的 Actor 更新以后，你就最好要重新去搜集资料，这就是为什么 Gradient Descent 它非常花时间的原因。

1. 初始化强化学习参数 ${\theta }_0$
2. 利用强化学习的Actor进行第1次Episode的游戏，得 τ 1 = { s 1 1 , a 1 1 , r 1 1 , s 2 1 , a 2 1 , r 2 1 , . . . , s T 1 , a T 1 , r T 1 } τ^1=\{s^1_1,a^1_1,r^1_1,s^1_2,a^1_2,r^1_2,...,s^1_T,a^1_T,r^1_T\} τ1={s11​,a11​,r11​,s21​,a21​,r21​,...,sT1​,aT1​,rT1​}
3. 根据 ${\tau }^1$ 计算 $\nabla {\overline{R}}_{\theta }$，得 $\nabla {\overline{R}}_{\theta }^1$
4. 根据 $\nabla {\overline{R}}_{\theta }^1$ 计算 ${\theta }_1={\theta }_0+\eta \nabla {\overline{R}}_{\theta }^1$
5. 利用强化学习的Actor进行第2次Episode的游戏，得 τ 2 = { s 1 2 , a 1 2 , r 1 2 , s 2 2 , a 2 2 , r 2 2 , . . . , s T 2 , a T 2 , r T 2 } τ^2=\{s^2_1,a^2_1,r^2_1,s^2_2,a^2_2,r^2_2,...,s^2_T,a^2_T,r^2_T\} τ2={s12​,a12​,r12​,s22​,a22​,r22​,...,sT2​,aT2​,rT2​}
6. 根据 ${\tau }^2$ 计算 $\nabla {\overline{R}}_{\theta }$，得 $\nabla {\overline{R}}_{\theta }^2$
7. 根据 $\nabla {\overline{R}}_{\theta }^2$ 计算 ${\theta }_2={\theta }_1+\eta \nabla {\overline{R}}_{\theta }^2$
8. …
9. ${\theta }_{new}={\theta }_{old}+\eta \nabla {\overline{R}}_{\theta }^{old}$

2、On-Policy、Off-Policy

On-Policy Algorithm：“要训练的Agent/Actor” 跟 “和环境互动的Agent/Actor” 是同一个的话，这个叫做 on-policy。即：要训练的Agent/Actor，它是一边跟环境互动，一边做学习这个叫 on-policy。Policy Gradient属于“On-Policy”算法。

1. sample的data只用一次。 即利用 ${\tau }^i$ 更新参数 $\theta$ 后就将 ${\tau }^i$ 丢弃掉，不再使用。
2. Policy Gradient 是一个会花很多时间来取样的算法。Policy Gradient 算法的大多数时间都在取样，Agent/Actor/Actor跟环境做互动取样后update参数一次(只能 update 参数一次)，接下来就要重新再去环境里取样，然后才能再次 update 参数一次，这非常花时间。

Off-Policy Algorithm：“要训练的Agent/Actor” 跟 “和环境互动的Agent/Actor” 不是同一个的话，这个叫做 off-policy。如果它是在旁边看别人玩，透过看别人玩来学习。

• 那 Off-policy 有什么好处呢？
  • 有一个非常显而易见的好处，我们刚才说 ${\theta }_{i-1}$ 搜集到的这些资料不能拿来训练 ${\theta }_i$。如果你是 On-policy 的 Learning 的话，但是有一些比较特别的方法，它是 Off-policy 的 Learning，它可以想办法让 ${\theta }_i$ 去根据 ${\theta }_{i-1}$ 所搜集的资料来进行学习。虽然 ${\theta }_i$ 跟 ${\theta }_{i-1}$ 它们是不一样的，它们能力是不一样的，但是我们可以用一些方法来让 ${\theta }_i$ 可以根据 ${\theta }_{i-1}$ 所搜集到的互动的结果进行学习。那这样的好处就是，你就不用一直搜集资料了。刚才说 Reinforcement Learning一个很卡的地方就是，每次更新一次参数就要搜集一次资料。那如果我们可以搜集一次资料就 Update 参数很多次，这样不是很好吗？所以 Off-policy 它有不错的优势。但是 Off-policy 要怎么做呢？有一个非常经典的 Off-policy 的方法 叫做 Proximal Policy Optimization。缩写是 PPO。是今天蛮常使用的一个方法，它也是一个蛮强的方法，蛮常使用的方法。
• Off-policy 的重点是什么呢？
  • Off-policy 的重点就是你在训练的那个 Network 要知道自己跟别人之间的差距。它要有意识的知道说，它跟环境互动的那个 Actor 是不一样的。那如果要举个比喻的话，就好像是你去问克里斯伊凡（美国队长） 怎么追一个女生，然后克里斯伊凡就告诉你说 他就示范给你看，他就是 Actor To Interact 的那个Actor（Behavier Actor），他就是负责去示范的那个 Actor。他说他只要去告白从来没有失败过，但是你要知道说，你跟克里斯伊凡其实还是不一样，所以克里斯伊凡可以采取的招数你不一定能够采取，你可能要打一个折扣。那这个就是 Off-policy 的精神：你的 Actor To Train 要知道 Actor To Interact 跟它是不一样的，所以 Actor To Interact 示范的那些经验有些可以采纳，有些不一定可以采纳。

3、迭代过程中调整参数

如果在第$i$ 次 Episode，当 Actor 处于 $s_t^i$ 时，采取 action/policy $a_t^i$ 后，

• $R({\tau }^i)>0$，则调整 $\theta$，使得 $p(a_t^i|s_t^i)$ 增加；
• $R({\tau }^i)<0$，则调整 $\theta$，使得 $p(a_t^i|s_t^i)$ 减小；

It is very important to consider the cumulative reward $R({\tau }^i)$ of the whole trajectory ${\tau }^i$ instead of immediate reward $r_t^i$

七、实操 Policy Gradient

1、假设为分类问题

• 实际上在用这个 deep learning 的 framework implement 的时候，要把它想成你就是在做一个分类的问题
• 分类问题用 TensorFlow implement MNIST classification，理论上每个人都会做 classification
• 那在 classification 里面就是 input 一个 image，就是做 MNIST input 一个 image，然后 output 就是要决定说，是 10 个 class 里面的哪一个
• 所以那要怎么做 classification，当然要收集一堆 training data，你要有 input 跟 output 的 pair
• 在 reinforcement learning 里面，在实作的时候，你就把 state 当作是 classifier 的 input，你就当作你是要做 image classification 的 problem，只是现在的 class 不是说 image 里面有什么 objects，现在的 class 是说，看到这张 image 我们要采取什么样的行为，每一个行为就叫做一个 class
• 比如说第一个 class 叫做向左，第二个 class 叫做向右，第三个 class 叫做开火
• 那这些训练的资料是从哪里来的呢？我们要做分类的问题，你要有 classified 的 input，跟它正确的 output，这些训练数据，就是从 sampling 的 process 来的
• 假设在 sampling 的 process 里面，在某一个 state，你 sample 到你要采取 action a，你就把这个 action a 当作是你的 ground truth。你在这个 state，你 sample 到要向左，本来向左这件事机率不一定是最高，因为你是 sample，它不一定机率最高。
• 假设你 sample 到向左，那接下来在 training 的时候，你叫告诉 machine 说，调整 network 的参数，如果看到这个 state，你就向左
• 在一般的 classification 的 problem 里面，其实你在 implement classification 的时候，你的 objective function都会写成 cross entropy
• 那其实 minimize cross entropy 就是 maximize log likelihood
• 所以你今天在做 classification 的时候，你的 objective function，你要去 maximize 或是 minimize 的对象，
• 因为我们现在是 maximize likelihood，所以其实是 maximize，你要 maximize 的对象，其实就长这样子
  
• 像这种 lost function，你在 TensorFlow 里面，你 even 不用手刻，它都会有现成的 function，你就 call 个 function，它就会自动帮你算
• 然后接下来呢，你就 apply 计算 gradient 这件事，那你就可以把 gradient 计算出来，这是一般的分类问题

2、实际为RL问题

• 那如果今天是 RL 的话，唯一不同的地方只是，你要记得在你原来的 loss 前面乘上一个 weight，这个 weight 是什么？这个weight 是，今天在这个 state，采取这个 action 的时候，你会得到的 reward，这个 reward 不是当场得到的 reward，而是整场(Episode)游戏的时候得到的 reward，它并不是在 state s 采取 action a 的时候得到的 reward，而是在 state s 采取 action a 的这整场游戏里面，你最后得到的 total reward 这个大 Return。
• 要把每一笔 training data，都 weighted by 这个大 Return，然后接下来，你就交给 TensorFlow 或 pyTorch 去帮你算 gradient，然后就结束了
  跟一般 classification 其实也没太大的差别
  

八、实操技巧/Tips

1、Add a Baseline

$\begin{array}{r}\nabla {\overline{R}}_{\theta }\approx \frac{1}{N}\sum _{i=1}^N\sum _{t=1}^{T}R({\tau }^i)\cdot {\nabla }_{\theta }log[p(a_t^i|s_t^i,\theta )]\end{array}$ 的含义是：

• 如果在 $s_t^i$ 状态下采取策略 $a_t^i$ 后，该整场Episode ${\tau }^i$ 最后的 Reward 为正值，则增加该 ${\tau }^i$ 的发生几率
• 如果在 $s_t^i$ 状态下采取策略 $a_t^i$ 后，该整场Episode ${\tau }^i$ 最后的 Reward 为负值，则减小该 ${\tau }^i$ 的发生几率

在实际应用中遇到的问题是：计算出来的Reward $R({\tau }^i)$ 总是正值，不会得到负值的Reward。这就会导致一个问题：一些因为抽样误差导致没被取样到的Sample的几率相对下降。

所以，我们希望你的 reward 不要总是正的，为了实现 reward 不要总是正的这个问题，可以做的一个非常简单的改变就是，把你的 reward 减掉一项叫做 b，这项 b 叫做 Baseline

你减掉这项 b 以后，就可以让 R-b 小括号这一项，有正有负

• 所以今天如果你得到的 reward 这个 $R({\tau }^i)$ 大于 b 的话，就让他的机率上升，如果这个 $R({\tau }^i)$ 小于 b，就算它是负的，因为游戏里面不可能有负的，所以如果正的很小，也是不好的，所以你就要让这个 state 采取这个 action 的几率下降。
• $b$ 的设定随意，一般设定 $b\approx E[R(\tau )]$，
• 所以在实作上，你就是在 implement/training 的时候，会不断的把 $[R(\tau )$ 记录下来，不断的去计算 $[R(\tau )$ 的平均值 $E[R(\tau )]$，然后你会把你的这个平均值$E[R(\tau )]$ 当作你的 $b$ 来用。

2、Assign Suitable Credit（discount rate $\gamma$）

在Policy Gradient标准算法中，只要在同一个 Episode 里面，在同一场游戏里面，所有的 state 跟 a 的 pair，它都会 weighted by 同样的 reward/term。这件事情显然是不公平的，因为在同一场游戏里面，也许有些 action 是好的，也许有些 action 是不好的，那假设最终的结果，整场游戏的结果是好的，并不代表这个游戏里面每一个行为都是对的，若是整场游戏结果不好，但不代表游戏里面的所有行为都是错的

所以我们其实希望，可以给每一个不同的 action，前面都乘上不同的 weight，那这个每一个 action 的不同 weight，它真正的反应了每一个 action，它到底是好还是不好。

如上述 《四、关于每次动作的反馈》 所讨论的，假如一盘游戏输了，那么我们就会全盘否定掉本次游戏中所做的所有操作。即使本次游戏中的一些好的操作，也会相应地被否定掉。只要采样充分，我们并不需要担心在不良反馈结局下的某些好的操作会被消除。但是，实践中，可能并不能实现充分采样，这样的话就会有误差。

在 sample 的次数不够多的情况下，就需要想办法给每一个 state 跟 action pair 合理的 credit，要让整体模型知道它对Reward合理的 contribution，它实际上对Reward这些分数的贡献到底有多大。

每个 $(a_t^i|s_t^i)$ 的 reward 为从观察到 $(a_t^i|s_t^i)$ 的时刻 $t$ 直到该轮episode结束所能得到的累计Reward，如下图：

更进一步，把离时刻 $t$ 比较远的未来的 reward，做一个 discount，因为虽然某一个时间点执行某一个 action会影响接下来所有的结果，有可能在某一个时间点执行的 action，接下来得到的 reward 都是这个 action 的功劳，但是在比较真实的情况下，如果时间拖得越长，影响力就越小。

所以我们实际上在做的时候，你会在你的 $r_{t^{\prime }}^i$ 前面乘上一个系数 $\gamma$， $\gamma <1$，一般设 $\gamma =0.9$ 或 设 $\gamma =0.99$。它是越之后的 $r_{t^{\prime }}^i$，它前面就乘上越多次的 $\gamma$。就代表说现在在某一个 state $s_t$，执行某一个 action $a_t$ 的时候，它真正的 credit 其实是它在执行这个 action 之后所有 reward 的总和，而且还要乘上 $\gamma$ 来表明离 $(a_t^i,s_t^i)$ 越远受其影响越小。

$$\begin{array}{rl}{\nabla }_{\theta }{\overline{R}}_{\theta }& \approx \frac{1}{N}\sum _{i=1}^N\sum _{t=1}^{T_i}\left[\left(\sum _{t^{\prime }=t}^{T_i}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}^i-b\right){\nabla }_{\theta }log{p}_{\theta }(a_t^i|s_t^i)\right]\\ & =\frac{1}{N}\sum _{i=1}^N\sum _{t=1}^{T_i}[A^{\theta }(s_t,a_t){\nabla }_{\theta }log{p}_{\theta }(a_t^i|s_t^i)]\end{array}$$

---

---

---

浅谈Policy Gradient