【学习强化学习】四、策略梯度方法及实现

参考资料

https://datawhalechina.github.io/easy-rl/#/chapter4/chapter4
https://zhuanlan.zhihu.com/p/141269134
https://zhuanlan.zhihu.com/p/106006748

1. Policy Gradient

• 在强化学习中有 3 个组成部分：演员(actor)、环境(environment) 和 奖励函数(reward function)。
• 在强化学习里面，环境跟奖励函数不是你可以控制的，环境跟奖励函数是在开始学习之前，就已经事先给定的。你唯一能做的事情是调整actor的策略(policy)，使得actor可以得到最大的奖励。
• RL目标: 找到可以让agent获得最优回报的最优行为策略${\pi }^{\ast }$ ，所以对策略直接进行建模并按照梯度提升就是一个很自然的想法了。

1.1 Policy of Actor

• 策略一般写成 $\pi$。假设用深度学习的技术来做强化学习的话，策略就是一个网络。网络里面就有一堆参数，我们用 $\theta$ 来代表 $\pi$ 的参数。

• 网络的输入就是现在机器看到的东西，如果让机器打电玩的话，机器看到的东西就是游戏的画面。

• 输出的就是机器要采取什么样的行为。

• 下图就是具体的例子，
  

  • 策略就是一个网络；
  • 输入 就是游戏的画面，它通常是由像素(pixels)所组成的；
  • 输出就是看看说有哪些选项是你可以去执行的，输出层就有几个神经元。
  • 假设现在可以做的行为有 3 个，输出层就是有 3 个神经元。每个神经元对应到一个可以采取的行为。
  • 输入一个东西后，网络就会给每一个可以采取的行为一个分数。你可以把这个分数当作是概率。actor就是看这个概率的分布，根据这个概率的分布来决定它要采取的行为。比如说 70% 会向左走，20% 向右走，10% 开火等等。概率分布不同，actor采取的行为就会不一样。

1.2 Actor, Environment, Reward

• 一场游戏叫做一个 回合(episode) 或者 试验(trial)。
• 把这场游戏里面所有得到的奖励都加起来，就是 总奖励(total reward)，我们称其为回报(return)，用 $R$ 来表示它。
• 演员要想办法去最大化它可以得到的奖励。

1.2.1 Actor, Environment

• 首先，环境 是一个函数，游戏的主机也可以把它看作是一个函数，虽然它不一定是神经网络，可能是基于规则的(rule-based)的规则，但你可以把它看作是一个函数。这个函数一开始就先得到一个状态，也就是游戏的画面，接下来actor看到这个游戏画面 $s_1$ 以后，它吐出 $a_1$​，然后环境把 $a_1$当作它的输入，然后它再吐出 $s_2$，吐出新的游戏画面。演员看到新的游戏画面，再采取新的行为 $a_2$​，然后 环境再看到 $a_2$​，再吐出 $s_3$​。这个过程会一直持续下去，达到终止条件。

• 在一场游戏里面，我们把环境输出的 $s$ 跟演员输出的行为$a$，把 $s$ 跟 $a$全部串起来， 叫做一个 Trajectory(轨迹)，如下式所示。
  $$\text{ Trajectory }\tau =\left\{s_1,a_1,s_2,a_2,\cdots ,s_t,a_t\right\}$$

• 我们可以计算每一个轨迹发生的概率。假设现在演员的参数$\theta$已经被给定了, 根据$\theta$，我们可以计算某一个轨迹发生的概率。
  $$\begin{array}{rl}{p}_{\theta }(\tau )& =p\left(s_1\right)p_{\theta }\left(a_1|s_1\right)p\left(s_2|s_1,a_1\right)p_{\theta }\left(a_2|s_2\right)p\left(s_3|s_2,a_2\right)\cdots \\ & =p\left(s_1\right)\prod _{t=1}^T{p}_{\theta }\left(a_t|s_t\right)p\left(s_{t+1}|s_t,a_t\right)\end{array}$$

• 在假设演员的参数就是 $\theta$ 的情况下，某一个轨迹 $\tau$ 的概率就是这样算的：先算环境输出$s_1$​ 的概率，再计算根据$s_1$​ 执行 $a_1$​ 的概率，这是由策略里面的网络参数$\theta$所决定的（它是一个概率的原因是因为策略的网络的输出是一个分布，演员是根据这个分布去做采样，决定现在实际上要采取的动作是哪一个）。接下来环境根据 $a_1$​ 跟 $s_1$​ 产生 $s_2$​，因为 $s_2$​ 跟 $s_1$​ 还是有关系的，下一个游戏画面跟前一个游戏画面通常还是有关系的，至少要是连续的， 所以给定前一个游戏画面$s_1$​ 和现在演员采取的行为 $a_1$​，就会产生 $s_2$​。

• 环境的行为 。环境的函数内部的参数或内部的规则长什么样子。 $p(s_{t+1}|s_t,a_t)$这一项代表的是环境，环境这一项通常是无法控制的。

• agent 的行为。你能控制的是 $p_{\theta }(a_t|s_t)$。给定一个 $s_t$​，演员要采取什么样的 $a_t$ 会取决于演员的参数 $\theta$， 所以这部分是演员可以自己控制的。随着演员的行为不同，每个同样的轨迹， 它就会有不同的出现的概率。

1.2.2 reward

• 在强化学习里面，除了环境跟演员以外， 还有奖励函数(reward function)。

• 奖励函数根据在某一个状态采取的某一个动作决定说现在这个行为可以得到多少的分数。 它是一个函数，给它 $s_1$​，$a_1$​，它告诉你得到 $r_1$​。给它 $s_2$​ ，$a_2$​，它告诉你得到 $r_2$。 把所有的 $r$ 都加起来，我们就得到了 $R(\tau )$ ，代表某一个轨迹 $\tau$ 的奖励。

• 在某一场游戏里面， 某一个回合里面，我们会得到 R。我们要做的事情就是调整演员内部的参数$\theta$， 使得 R 的值越大越好。 但实际上奖励并不只是一个标量，奖励其实是一个随机变量。R 其实是一个随机变量，因为演员在给定同样的状态会做什么样的行为，这件事情是有随机性的。环境在给定同样的观测要采取什么样的动作，要产生什么样的观测，本身也是有随机性的，所以 R 是一个随机变量。能够计算的是 R 的期望值。即在给定某一组参数 $\theta$ 的情况下，我们会得到的 $R_{\theta }$​ 的期望值是多少。
  $${\bar{R}}_{\theta }=\sum _{\tau }R(\tau )p_{\theta }(\tau )$$

• 我们可以根据 $\theta$ 算出某一个轨迹 $\tau$ 出现的概率，接下来计算这个 $\tau$ 的总奖励是多少。总奖励使用这个 $\tau$ 出现的概率进行加权，对所有的 $\tau$ 进行求和，就是期望值。
  $${\bar{R}}_{\theta }=\sum _{\tau }R(\tau )p_{\theta }(\tau )=E_{\tau \sim p_{\theta }(\tau )}[R(\tau )]$$

1.3 梯度上升(gradient ascent)

• Policy gradient输出不是 action 的 value, 而是具体的一个 action, 这样 policy gradient 就跳过了 value 评估这个阶段, 对策略本身进行评估。
• 我们要做的事情就是最大化期望奖励。我们用的是 梯度上升(gradient ascent)最大化期望奖励，因为要让它越大越好，所以是梯度上升。要进行梯度上升，我们先要计算期望的奖励(expected reward)$\bar{R}$ 的梯度。我们对 $\bar{R}$ 取一个梯度，这里面只有$p_{\theta }(\tau )$是跟$\theta$有关，所以梯度就放在$p_{\theta }(\tau )$这个地方。$R(\tau )$ 这个奖励函数不需要是可微分的(differentiable)，这个不影响我们接下来的问题。

取梯度之后，根据公式：
$$\nabla f(x)=f(x)\nabla \log f(x)$$

我们对 $\nabla p_{\theta }(\tau )$ 使用这个公式，然后会得到 $\nabla p_{\theta }(\tau )=p_{\theta }(\tau )\nabla \log p_{\theta }(\tau )$，进一步地，我们可以得到下式：
$$\frac{\nabla p_{\theta }(\tau )}{p_{\theta }(\tau )}=\nabla \log p_{\theta }(\tau )$$

如下式所示，对 $\tau$ 进行求和，把 $R(\tau )$ 和$\log p_{\theta }(\tau )$ 这两项使用 $p_{\theta }(\tau )$ 进行加权， 既然使用 $p_{\theta }(\tau )$进行加权 ，它们就可以被写成期望的形式。也就是你从 $p_{\theta }(\tau )$ 这个分布里面采样 $\tau$ 出来， 去计算 $R(\tau )$ 乘上 $\nabla \log p_{\theta }(\tau )$)，然后把它对所有可能的 $\tau$ 进行求和，就是这个期望的值(expected value)。
$$\begin{array}{rl}\nabla {\bar{R}}_{\theta }& =\sum _{\tau }R(\tau )\nabla p_{\theta }(\tau )\\ & =\sum _{\tau }R(\tau )p_{\theta }(\tau )\frac{\nabla p_{\theta }(\tau )}{p_{\theta }(\tau )}\\ & =\sum _{\tau }R(\tau )p_{\theta }(\tau )\nabla \log p_{\theta }(\tau )\\ & =E_{\tau \sim p_{\theta }(\tau )}\left[R(\tau )\nabla \log p_{\theta }(\tau )\right]\end{array}$$

实际上这个期望值没有办法算，所以用采样的方式来采样一大堆的 $\tau$。采样 $N$ 笔 $\tau$， 然后去计算每一笔的这些值，再把它全部加起来，就可以得到梯度，如下式所示：
$$\begin{array}{rl}{E}_{\tau \sim p_{\theta }(\tau )}\left[R(\tau )\nabla \log p_{\theta }(\tau )\right]& \approx \frac{1}{N}\sum _{n=1}^{N}R\left({\tau }^n\right)\nabla \log p_{\theta }\left({\tau }^n\right)\\ & =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R\left({\tau }^n\right)\nabla \log p_{\theta }\left(a_t^n\mid s_t^n\right)\end{array}$$

下面给出 $\nabla \log p_{\theta }(\tau )$的具体计算过程，如下式所示。
$$\begin{array}{rl}\nabla \log p_{\theta }(\tau )& =\nabla \left(\log p(s_1)+\sum _{t=1}^T\log p_{\theta }(a_t|s_t)+\sum _{t=1}^T\log p(s_{t+1}|s_t,a_t)\right)\\ & =\nabla \log p(s_1)+\nabla \sum _{t=1}^T\log p_{\theta }(a_t|s_t)+\nabla \sum _{t=1}^T\log p(s_{t+1}|s_t,a_t)\\ & =\nabla \sum _{t=1}^T\log p_{\theta }(a_t|s_t)\\ & =\sum _{t=1}^T\nabla \log p_{\theta }(a_t|s_t)\end{array}$$

注意， $p(s_1)$和$p(s_{t+1}|s_t,a_t)$ 来自于环境，$p_{\theta }(a_t|s_t)$是来自于 agent。$p(s_1)$ 和 $p(s_{t+1}|s_t,a_t)$ 由环境决定，所以与 $\theta$ 无关，因此
$$\nabla \log p(s_1)=0，\nabla \sum _{t=1}^T\log p(s_{t+1}|s_t,a_t)=0$$
$$\begin{array}{rl}\nabla {\bar{R}}_{\theta }& =\sum _{\tau }R(\tau )\nabla p_{\theta }(\tau )\\ & =\sum _{\tau }R(\tau )p_{\theta }(\tau )\frac{\nabla p_{\theta }(\tau )}{p_{\theta }(\tau )}\\ & =\sum _{\tau }R(\tau )p_{\theta }(\tau )\nabla \log p_{\theta }(\tau )\\ & =E_{\tau \sim p_{\theta }(\tau )}\left[R(\tau )\nabla \log p_{\theta }(\tau )\right]\\ & \approx \frac{1}{N}\sum _{n=1}^{N}R\left({\tau }^n\right)\nabla \log p_{\theta }\left({\tau }^n\right)\\ & =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R\left({\tau }^n\right)\nabla \log p_{\theta }\left(a_t^n\mid s_t^n\right)\end{array}$$
我们可以直观地来理解上面这个式子，也就是在采样到的数据里面， 你采样到在某一个状态 $s_t$要执行某一个动作$a_t$， 这个 $s_t$ 跟 $a_t$ 是在整个轨迹$\tau$ 的里面的某一个状态和动作的对。

• 假设你在 $s_t$ 执行 $a_t$​，最后发现$\tau$ 的奖励是正的， 那你就要增加这一项的概率，你就要增加在 $s_t$ 执行 $a_t$​ 的概率。
• 反之，在 $s_t$执行 $a_t$ 会导致$\tau$的奖励变成负的， 所以要减少这一项的概率。

我们可以套下面这个公式来把梯度计算出来:
$$\nabla {\bar{R}}_{\theta }=\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R\left({\tau }^n\right)\nabla \log p_{\theta }\left(a_t^n|s_t^n\right)$$
也就是把每一个 s 跟 a 的对拿进来，算一下它的对数概率(log probability)，然后对它取梯度，然后这个梯度前面会乘一个权重，权重就是这场游戏的奖励。 有了这些以后，就可以更新模型。更新完模型以后，要重新去收集数据，再更新模型。注意，一般 policy gradient(PG) 采样的数据就只会用一次。把这些数据采样起来，然后拿去更新参数，这些数据就丢掉了。接着再重新采样数据，才能够去更新参数。

1.4 梯度上升实现细节

• 如图所示，我们可以把它想成一个分类的问题，在分类里面就是输入一个图像，然后输出决定说是 10 个类里面的哪一个。在做分类时，我们要收集一堆训练数据，要有输入跟输出的对。

• 在实现的时候，把状态当作是分类器的输入。 当作在做图像分类的问题，只是现在的类不是说图像里面有什么东西，而是说看到这张图像我们要采取什么样的行为，每一个行为就是一个类。比如说第一个类叫做向左，第二个类叫做向右，第三个类叫做开火。

• 在一般的分类问题里面，其实在实现分类的时候，目标函数都会写成最小化交叉熵(cross entropy)，其实最小化交叉熵就是最大化对数似然(log likelihood)。
  

• 做分类的时候，目标函数就是最大化或最小化对象， 因为我们现在是最大化似然(likelihood)，所以其实是最大化，如下式所示:
  $$\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}\log p_{\theta }\left(a_t^n\mid s_t^n\right)$$

• 这是一般的分类问题，RL 唯一不同的地方是 loss 前面乘上一个权重：整场游戏得到的总奖励 R，它并不是在状态 s 采取动作 a 的时候得到的奖励，如下式所示：
  $$\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R\left({\tau }^n\right)\log p_{\theta }\left(a_t^n\mid s_t^n\right)$$

• 每一笔训练数据，都使用这个 R 进行加权。然后用 TensorFlow 或 PyTorch 算梯度就结束了，跟一般分类差不多。

1.5 Vanilla Policy Gradient算法

• 标准的策略梯度算法(Vanilla Policy Gradient, VPG)属于on-policy算法

• VPG算法可以被用到离散和连续动作空间中

伪代码

2. 策略梯度tips

2.1 添加基线

• 第一个 tip 是添加基线（baseline）。 如果给定状态 s 采取动作 a 会给你整场游戏正的奖励，就要增加它的概率。如果状态 s 执行动作 a，整场游戏得到负的奖励，就要减少这一项的概率。
  

• 假设你在某一个状态有 3 个动作 a/b/c可以执行。根据下式，
  $$\nabla {\bar{R}}_{\theta }\approx \frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R\left({\tau }^n\right)\nabla \log p_{\theta }\left(a_t^n\mid s_t^n\right)$$

• 你要把这 3 项的概率，对数概率都拉高。 但是它们前面权重的 R 是不一样的。 R 是有大有小的，权重小的，它上升的就少，权重多的，它上升的就大一点。 因为这个对数概率是一个概率，所以动作 a、b、c 的对数概率的和要是 0。 所以上升少的，在做完归一化(normalize)以后， 它其实就是下降的，上升的多的，才会上升。

• 这是一个理想上的状况，但是实际上，做采样本来应该是对所有可能的 s 跟 a 的对进行求和后的一个期望(expectation)。 但真正在learning的时候不可能是这么做的，我们只是采样了少量的 s 跟 a 的对而已。 **因为我们做的是采样，有一些动作可能从来都没有采样到。**在某一个状态，虽然可以执行的动作有 a/b/c，但可能只采样到动作 b，可能只采样到动作 c，没有采样到动作 a。但现在所有动作的奖励都是正的，所以根据这个式子，它的每一项的概率都应该要上升。**这会遇到的问题是，因为 a 没有被采样到，其它动作的概率如果都要上升，a 的概率就要下降。 但是 a 不一定是一个不好的动作， 它只是没被采样到。**只是因为a没被采样到， 它的概率就会下降，这个显然是有问题的，要怎么解决这个问题呢？你会希望你的奖励不要总是正的。
  

• 为了解决奖励总是正的问题，可以把奖励减掉一项 b，这项 b 叫做基线。减掉这项 b 以后，就可以让 $R({\tau }^n)-b$这一项有正有负。 所以如果得到的总奖励 $R({\tau }^n)$大于 b 的话，就让它的概率上升。如果这个总奖励小于 b，就算它是正的，正的很小也是不好的，就要让这一项的概率下降。 如果$R({\tau }^n)<b$ ， 就要让这个状态采取这个动作的分数下降 。这个 b 怎么设呢？一个最简单的做法就是：你把 ${\tau }^n$ 的值取期望， 算一下${\tau }^n$ 的平均值，即：
  $$b\approx E[R(\tau )]$$

• 所以在实现训练的时候，通过不断地把$R(\tau )$的分数记录下来 然后不断地去计算 $R(\tau )$ 的平均值，当作 b 来用。 这样就可以在训练的时候， $\nabla \log p_{\theta }\left(a_t^n|s_t^n\right)$ 乘上前面这一项， 是有正有负的。

2.2 Assign Suitable Credit

第二个 tip：给每一个动作合适的分数(credit)。

如果我们看下面这个式子的话，
$$\nabla {\bar{R}}_{\theta }\approx \frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}\left(R\left({\tau }^n\right)-b\right)\nabla \log p_{\theta }\left(a_t^n\mid s_t^n\right)$$

我们原来会做的事情是，在某一个状态，假设你执行了某一个动作 a，它得到的奖励，它前面乘上的这一项 $R({\tau }^n)-b$。

只要在同一个回合里面，在同一场游戏里面， 所有的状态跟动作的对都会使用同样的奖励项(term)进行加权，这件事情显然是不公平的，因为在同一场游戏里面 也许有些动作是好的，有些动作是不好的。 假设整场游戏的结果是好的， 并不代表这个游戏里面每一个行为都是对的。若是整场游戏结果不好， 但不代表游戏里面的所有行为都是错的。所以我们希望可以给每一个不同的动作前面都乘上不同的权重。每一个动作的不同权重， 它反映了每一个动作到底是好还是不好。

• 在采样的次数不够多的情况下，你要给每一个状态跟动作对合理的分数，你要让大家知道它合理的贡献。怎么给它一个合理的贡献呢？
  一个做法是计算这个状态动作对的奖励的时候，**不把整场游戏得到的奖励全部加起来，只计算从这一个动作执行以后所得到的奖励。**如下式所示：
  

• 本来的权重是整场游戏的奖励的总和，现在改成从某个时间 $t$ 开始，假设这个动作是在$t$ 这个时间点所执行的，从 $t$ 这个时间点一直到游戏结束所有奖励的总和，才真的代表这个动作是好的还是不好的。
  

• 接下来再更进一步，我们把未来的奖励做一个折扣(discount)，由此得到的回报被称为 Discounted Return(折扣回报)。为什么要把未来的奖励做一个折扣呢？因为虽然在某一个时间点，执行某一个动作，会影响接下来所有的结果，有可能在某一个时间点执行的动作，接下来得到的奖励都是这个动作的功劳。但在比较真实的情况下， 如果时间拖得越长，影响力就越小。 所以我们实际上在做的时候，你会在 R 前面乘上一个 discount factor$\gamma$，$\gamma \in [0,1]$ ，一般会设个 0.9 或 0.99，$\gamma =0$ : 只关心即时奖励；$\gamma =1$: 未来奖励等同于即时奖励。

2.3 优势函数

• 把 $R-b$ 这一项与Assign Suitable Credit合起来，我们统称为 优势函数(advantage function)， 用 A 来代表优势函数。优势函数取决于 s 和 a，我们就是要计算的是在某一个状态 s 采取某一个动作 a 的时候，优势函数有多大。

• 在算优势函数时，要计算 ${\sum }_{t^{\prime }=t}^{T_n}{r}_{t^{\prime }}^n$ ，需要有一个模型去跟环境做互动，才知道接下来得到的奖励会有多少。优势函数 $A^{\theta }\left(s_t,a_t\right)$的上标是$\theta$，代表用 $\theta$ 这个模型跟环境去做互动，然后才计算出这一项。从时间 t 开始到游戏结束为止，所有 r 的加和减掉 b，这个就叫优势函数。

• 优势函数的意义就是，假设我们在某一个状态$s_t$ 执行某一个动作 $a_t$​，相较于其他可能的动作，它有多好。它在意的不是一个绝对的好，而是相对的好，即相对优势(relative advantage)。$A^{\theta }\left(s_t,a_t\right)$ 通常可以是由一个网络估计出来的，这个网络叫做 critic。

3. REINFORCE: Monte Carlo Policy Gradient

3.1 蒙特卡洛与时序差分回顾

• MC 可以理解为算法完成一个回合之后，再拿这个回合的数据去 learn ，做一次更新。因为我们已经拿到了一整个回合的数据的话，也能够拿到每一个步骤的奖励，我们可以很方便地去计算每个步骤的未来总收益 $G_t$​ 。$G_t$​ 是我们的未来总收益，$G_t$代表从这个步骤后面，能拿到的收益之和是多少。$G_1$​是说我从第一步开始，往后能够拿到多少的收益。$G_2$ 是说从第二步开始，往后一共能够拿到多少的收益。
• 相比 MC 一个回合更新一次的方式，TD 就是每个步骤都更新一下。每走一步，就更新下，这样的更新频率会更高一点。它拿的是 Q-function 来去近似地表示我的未来总收益 $G_t$​。

3.2 REINFORCE算法

• REINFORCE 用的是回合更新的方式，属于Monte Carlo更新方式。它在代码上的处理是先拿到每个步骤的奖励，然后计算每个步骤的未来总收益 $G_t$是多少，然后拿每个 $G_t$代入公式，去优化每一个动作的输出。所以编写代码时会有这样一个函数：输入每个步骤拿到的奖励，把这些奖励转成每一个步骤的未来总收益。因为未来总收益是这样计算的：
  $$\begin{array}{rl}{G}_t& =\sum _{k=t+1}^T{\gamma }^{k-t-1}{r}_k\\ & =r_{t+1}+\gamma G_{t+1}\end{array}$$

• 上一个步骤和下一个步骤的未来总收益有这样一个关系，所以在代码的计算上，就是一步一步地从后往前推，先算 $G_t$​，一直算到 $G_1$。

• 算法伪代码
  

• REINFORCE 的伪代码主要看最后四行：先产生一个回合的数据，比如 $(s_1,a_1,G_1),(s_2,a_2,G_2),\cdots ,(s_T,a_T,G_T)$。然后针对每个动作来计算梯度。 在代码上计算时，我们要拿到神经网络的输出。神经网络会输出每个动作对应的概率值，然后我们还可以拿到实际的动作，把它转成 one-hot 向量乘一下，我们可以计算出 $\ln \pi (A_t|S_t,\theta )$。

独热编码(one-hot Encoding)通常用于处理类别间不具有大小关系的特征。例如血型，一共有4个取值（A型、B型、AB型、O型），独热编码会把血型变成一个4维稀疏向量，A型血表示为（1,0,0,0），B型血表示为（0,1,0,0），AB型会表示为（0,0,1,0），O型血表示为（0,0,0,1）。

3.2.1 算法中loss的计算

• policy gradient 预测每一个状态下面应该要输出的这个行动的概率，就是输入状态 $s_t$​，然后输出动作的概率，比如 0.02，0.08，0.9。实际上输出给环境的动作是随机选了一个动作，比如说我选了右这个动作，它的 one-hot 向量就是 0，0，1。

• 我们把神经网络的输出和实际动作带入交叉熵的公式就可以求出输出的概率和实际的动作之间的差距。

• 但这个实际的动作 $a_t$ 只是我们输出的真实的动作，它并不一定是正确的动作，它不能像手写数字识别一样作为一个正确的标签去指导神经网络朝着正确的方向去更新，所以我们需要乘以一个奖励回报 $G_t$​。这个奖励回报相当于是对这个真实动作 的评价。

  • 如果 $G_t$​ 越大，未来总收益越大，那就说明当前输出的这个真实的动作就越好，这个 loss 就越需要重视。
  • 如果 $G_t$ 越小，那就说明做这个动作 $a_t$​ 并没有那么的好，loss 的权重就要小一点，优化力度就小一点。

• 所以loss会构造成下面这个形式：
  

• 实际上我们在计算这个 loss 的时候，我们要取得 $\ln \pi (A_t|S_t,\theta )$。拿实际执行的动作，先取个 one-hot 向量，然后再跟神经网络预测的动作概率相乘，就可以计算出算法里面的$\ln \pi (A_t|S_t,\theta )$。因为我们会拿到整个回合的所有的轨迹，所以我们可以对这一整条轨迹里面的每个动作都去计算一个 loss。把所有的 loss 加起来之后，再扔给 adam 的优化器去自动更新参数。

3.2.2 REINFORCE 的流程图

• 首先我们需要一个 policy model 来输出每一个可能的动作概率，输出动作概率后，我们使用 sample() 函数去得到一个具体的动作与环境进行交互，同时环境就会给我们反馈一整个episode数据。。拿到回合数据之后，再去执行 learn() 函数，在 learn() 函数里面，就可以拿这些数据去构造损失函数，通过adam等优化器的优化，再来更新我们的policy model。。

4. 练习

4.1 Keywords

• policy（策略）： 每一个actor中会有对应的策略，这个策略决定了actor的行为。具体来说，Policy 就是给一个外界的输入，然后它会输出 actor 现在应该要执行的行为。一般地，我们将policy写成 $\pi$ 。
• Return（回报）： 一个回合（Episode）或者试验（Trial）所得到的所有的reward的总和，也被人们称为Total reward。一般地，我们用 RRR 来表示它。
• Trajectory： 一个试验中我们将environment 输出的 $s$ 跟 actor 输出的行为 $a$，把这个 $s$ 跟 $a$ 全部串起来形成的集合，我们称为Trajectory，即 $\text{ Trajectory }\tau =\left\{s_1,a_1,s_2,a_2,\cdots ,s_t,a_t\right\}$。
• Reward function： 根据在某一个 state 采取的某一个 action 决定说现在这个行为可以得到多少的分数，它是一个 function。也就是给一个 $s_1$​，$a_1$​，它告诉你得到 $r_1$​。给它 $s_2$​ ，$a_2$​，它告诉你得到 $r_2$​。 把所有的$r$都加起来，我们就得到了 $R(\tau )$ ，代表某一个 trajectory $\tau$ 的 reward。
• Expected reward： ${\bar{R}}_{\theta }={\sum }_{\tau }R(\tau )p_{\theta }(\tau )=E_{\tau \sim p_{\theta }(\tau )}[R(\tau )]$

4.2 问答

4.2.1 在一个process中，一个具体的trajectory $s_1$​,$a_1$​, $s_2$​ , $a_2$​ 出现的概率取决于什么？

答：

• 一部分是 environment 的行为， environment 的 function 它内部的参数或内部的规则长什么样子。 $p(s_{t+1}|s_t,a_t)$这一项代表的是 environment， environment 这一项通常你是无法控制它的，因为那个是人家写好的，或者已经客观存在的。
• 另一部分是 agent 的行为，你能控制的是$p_{\theta }(a_t|s_t)$。给定一个 $s_t$， actor 要采取什么样的 $a_t$​ 会取决于你 actor 的参数 $\theta$， 所以这部分是 actor 可以自己控制的。随着 actor 的行为不同，每个同样的 trajectory， 它就会有不同的出现的概率。

4.2.2 当我们在计算 maximize expected reward时，应该使用什么方法？

答： gradient ascent（梯度上升），因为要让它越大越好，所以是 gradient ascent。Gradient ascent 在 update 参数的时候要加。要进行 gradient ascent，我们先要计算 expected reward $\bar{R}$ 的 gradient 。我们对 $\bar{R}$ 取一个 gradient，这里面只有 $p_{\theta }(\tau )$是跟 $\theta$ 有关，所以 gradient 就放在 $p_{\theta }(\tau )$这个地方。

4.2.3 应该如何理解梯度策略的公式

答：
$$\begin{array}{rl}{E}_{\tau \sim p_{\theta }(\tau )}\left[R(\tau )\nabla \log p_{\theta }(\tau )\right]& \approx \frac{1}{N}\sum _{n=1}^{N}R\left({\tau }^n\right)\nabla \log p_{\theta }\left({\tau }^n\right)\\ & =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R\left({\tau }^n\right)\nabla \log p_{\theta }\left(a_t^n\mid s_t^n\right)\end{array}$$
$p_{\theta }(\tau )$ 里面有两项，$p(s_{t+1}|s_t,a_t)$ 来自于 environment，$p_{\theta }(a_t|s_t)$ 是来自于 agent。 $p(s_{t+1}|s_t,a_t)$由环境决定从而与 $\theta$ 无关，因此 $\nabla \log p(s_{t+1}|s_t,a_t)=0$。因此 $\nabla p_{\theta }(\tau )=\nabla \log p_{\theta }\left(a_t^n|s_t^n\right)$。

具体来说：

• 假设你在$s_t$ 执行 $a_t$，最后发现 $\tau$ 的 reward 是正的， 那你就要增加这一项的概率，即增加在 $s_t$ 执行$a_t$ 的概率。
• 反之，在 $s_t$ 执行 $a_t$ 会导致$\tau$ 的 reward 变成负的， 你就要减少这一项的概率。

4.2.4 推导策略梯度公式的计算过程。

答：首先我们目的是最大化reward函数，即调整 $\theta$ ，使得期望回报最大，可以用公式表示如下
$$J(\theta )=E_{\tau \sim p_{\theta (\mathcal{T})}}[\sum _{t}r(s_t,a_t)]$$

对于上面的式子， $\tau$ 表示从从开始到结束的一条完整路径。通常，对于最大化问题，我们可以使用梯度上升算法来找到最大值，即
${\theta }^{\ast }=\theta +\alpha \nabla J(\theta )$

所以我们仅仅需要计算（更新）$\nabla J(\theta )$ ，也就是计算回报函数 $J(\theta )$ 关于 $\theta$ 的梯度，也就是策略梯度，计算方法如下：
$$\begin{array}{rl}{\nabla }_{\theta }J(\theta )& =\int {\nabla }_{\theta }{p}_{\theta }(\tau )r(\tau )d_{\tau }\\ & =\int p_{\theta }{\nabla }_{\theta }log{p}_{\theta }(\tau )r(\tau )d_{\tau }\\ & =E_{\tau \sim p_{\theta }(\tau )}[{\nabla }_{\theta }log{p}_{\theta }(\tau )r(\tau )]\end{array}$$

接着我们继续讲上式展开，对于 $p_{\theta }(\tau )$，即 $p_{\theta }(\tau |\theta )$ :
$$p_{\theta }(\tau |\theta )=p(s_1)\prod _{t=1}^T{\pi }_{\theta }(a_t|s_t)p(s_{t+1}|s_t,a_t)$$

取对数后为：
$$log{p}_{\theta }(\tau |\theta )=logp(s_1)+\sum _{t=1}^{T}log{\pi }_{\theta }(a_t|s_t)p(s_{t+1}|s_t,a_t)$$

继续求导：
$$\nabla log{p}_{\theta }(\tau |\theta )=\sum _{t=1}^T{\nabla }_{\theta }log{\pi }_{\theta }(a_t|s_t)$$

带入第三个式子，可以将其化简为：
$$\begin{array}{rl}{\nabla }_{\theta }J(\theta )& =E_{\tau \sim p_{\theta }(\tau )}[{\nabla }_{\theta }log{p}_{\theta }(\tau )r(\tau )]\\ & =E_{\tau \sim p_{\theta }}[({\nabla }_{\theta }log{\pi }_{\theta }(a_t|s_t))(\sum _{t=1}^{T}r(s_t,a_t))]\\ & =\frac{1}{N}\sum _{i=1}^N[(\sum _{t=1}^T{\nabla }_{\theta }log{\pi }_{\theta }(a_{i,t}|s_{i,t}))(\sum _{t=1}^{N}r(s_{i,t},a_{i,t}))]\end{array}$$

4.3 编程题–实现REINFORCE算法

实现REINFORCE的离散形式，连续形式，以及REINFORCE with Baseline。代码详见github仓库。