RL算法总结归纳

RL算法总结

直接从md拷过来的，有些图片有问题，后续我会继续更新

RL算法的前期基础

什么是马尔可夫性？

Q-learning and Sarsa

Q-learning:（off-policy）

$$Q(s,a)\leftarrow Q(s,a)+\alpha \left[r+\gamma \underset{a^{\prime }}{\max }Q\left(s^{\prime },a^{\prime }\right)-Q(s,a)\right]$$

碎碎念：这个loss就相当于是她不断趋近于0，让Q完全拟合r+$\gamma$ maxQ‘ 吧

Sarsa: （on-policy）

$$Q(s,a)\leftarrow Q(s,a)+\alpha \left[r+\gamma Q\left(s^{\prime },a^{\prime }\right)-Q(s,a)\right]$$

碎碎念：这个Sarsa的不同就是 取得不是最大的Q值

所以在代码中一个取Q_max，另一个取任意一个Q。介于之前$$Q(s^{\prime },a^{\prime })$$不知道值的原因，代码中在提取下一个Q的时候，是先提前赋值了的。

on-policy and off-policy的区别：

On-policy 的目标策略和行为策略是同一个策略，其好处就是简单粗暴，直接利用数据就可以优化其策略，但这样的处理会导致策略其实是在学习一个局部最优。

Off-policy将目标策略和行为策略分开，可以在保持探索的同时，更能求到全局最优值。

Sarsa Lambda

$$\begin{array}{rl}& \delta \leftarrow R+\gamma Q\left(S^{\prime },A^{\prime }\right)-Q(S,A)\\ & Q(s,a)\leftarrow Q(s,a)+\alpha \delta E(s,a)\\ & E(s,a)\leftarrow \gamma \lambda E(s,a)\end{array}$$
代码在建立Q表的时候，还会建立一个E表。可以看到，上面的更新是乘了E表的值。对于具体如何处理E表，代码中写的很明白。$\lambda$ = lambda

DQN，double-DQN，dueling-DQN（涉及到构建网络）

DQN：（deep Q network）

DQN的出现是为了解决在复杂的情况下，更新Q表的方法不太现实的问题。对于DQN为什么要有两个网络，我想是因为需要一个现实Q，一个估计Q来计算差值。从而达到两个现实个估计网络几乎相同。

两个网络，一个eval来预测Q表，一个target来计算现实的Q表（Q现实就是根据这个更新的）。两个网络的结构是一样的，只是参数更新的速度不一样。

eval网络输出的是当前s的所有a的q值，eval网络的 loss：
$$\begin{gathered} y_i=r+\gamma \ast maxQ(s^{\prime },a^{\prime }) \\ {y}_i=Q(s,a) \\ loss={\left(y_j-Q\left({\varphi }_j,a_j;\theta \right)\right)}^2 \end{gathered}$$
这个Q(s’,a’)是由target网络预测得到的。而前面的Q-learning只是Q表的更新。

target网络的输出下一个s的所有a的q值，没有loss。在learn 中有一个值替换函数，是用tf.assign实现的。

下一步a根据最大的Q‘值来选择

DQN开始有了经验回放的方法。

double-DQN：

用当前Q网络计算最大Q值对应的动作，用目标Q网络计算这个最大动作对应的目标Q值，进而消除贪婪法带来的偏差。

以下是改进的公式：
$$Y_t^{\text{DoubleDQN }}=r+\gamma Q^{\prime }\left(s^{\prime },\underset{a}{\mathrm{argmax}}Q\left(s^{\prime },a;{\mathbf{\theta }}_t\right),{\mathbf{\theta }}_t^{\prime }\right)$$
double-DQN和DQN的网络结构并没有什么不同，只是q-target的计算方式不一样。

下面给出差别部分的代码：

if self.double_q:
	max_act_for_next = np.argmax(q_eval_for_next, axis=1)   #q_eval_for_next = q_eval 
    selected_q_next = q_next[batch_index, max_act4next]  # Double DQN
else:
	selected_q_next = np.max(q_next, axis=1)    # the natural DQN

q_target[batch_index, eval_act_index] = reward + self.gamma * selected_q_next

double-DQN的下一步的q值对应的a‘是根据eval网络来选择的。这样就不会有很大的过拟合。

Prioriized Experience Replay DQN

PER 优先经验回放，改进了DQN中的经验回放策略，值得一看！

dueling-DQN

只要稍稍修改 DQN 中神经网络的结构, 就能大幅提升学习效果, 加速收敛 。 用一句话来概括 Dueling DQN 就是. 它将每个动作的 Q 拆分成了 state 的 Value 加上 每个动作的 Advantage.

下面是它q值的公式：$$Q(s,a;\theta ,\alpha ,\beta )=V(s;\theta ,\beta )+A(s,a;\theta ,\alpha )$$

在网络中建立V与A两个输出

我们发现当可用动作越高, 学习难度就越大, 不过 Dueling DQN 还是会比 Natural DQN 学习得更快. 收敛效果更好.

value-based and policy-based 的区别：

value-based 的典型算法是DQN，policy-based是policy gradient，结合这两种具体算法可能会更好的理解。

1. 处理的action space不同：value-based适合处理action space低维离散的，policy-based适合处理连续的action space。

2. 针对action的价值输出不同：value-based计算出每个action的价值,policy-based一般情况下只给出较价值较高的actions。

3. 更新频率不同：value-based每个action执行都可以更新，policy-based 每个episode完成之后才能更新一次。这里可以理解成下棋的时候，value-based每下一步就学习一次，而policy-based要在一盘棋下完之后再学习。

像DDPG，AC算法就是将两者都结合了起来。

单步更新（TD算法）和回合更新（蒙特卡洛算法）的区别：

这个就是字面的区别，主要是理解为什么单步是TD算法，回合是蒙特卡洛算法。

MC算法：蒙特卡罗方法又叫做统计模拟方法，它使用随机数(或伪随机数)来解决计算问题。在强化学习中，在为了能够从环境中学习，我们需要让agent与environment交互，得到一些经历（样本）。然后通过这些经历来进行策略评估与策略迭代。从而最终得到最优策略。这种做法的理论是从蒙特卡罗方法中来的。

TD算法：就是单步更新算法

有一个公式可以体现两者的差别：
$$\begin{gathered} MC:V(S_t)\leftarrow V(S_t)+\alpha (G_t-V(S_t)) \\ TD:V(S_t)\leftarrow V(S_t)+\alpha (R_{t+1}+\gamma V(S_{t+1})-V(S_t)) \end{gathered}$$
DP（动态规划）算法：上面两个算法可以和DP算法相比较，因为这三种学习方法都是用来计算状态价值的。它们的区别在于，前两种是在不知道模型的情况下常用的方法，而MC方法又需要一个完整的episode来更新状态价值，TD则不需要完整的episode。DP方法则是基于Model(知道模型的运作方式)的计算状态价值的方法
$$DP:V(S_t)\leftarrow E_{\pi }[R_{t+1}+\gamma V(S_{t+1})$$

我发现TD算法还是有一个大的种类，包括很多的东西，这个有时间可以一起总结一下。而且TD和MC是可以结合起来的，比如说A3C中的n-steps就是一个很好的结合的例子。还有一个统一的方法Eligibility traces（资格迹）。

eligibility traces 优于n-step的主要地方在于计算非常有效率，其只需要一个trace向量，而不需要储存n个特征向量。另外，eligibility trace的学习是逐步的，而不需要等到n-steps之后。

PG

从这里开始就与上面的value-based方法不一样了，value-based方法最后输出的action的一个Q表，policy-based方法输出的直接是一个动作，而且还可以在连续的分布上选取动作。PG是回合更新的。采取随机性策略：$$a_t\sim {\pi }_{\theta }\left(s_t|{\theta }^{\pi }\right)$$其中${\theta }^{\pi }$是产生随机性动作的策略网络的参数 .
$$\begin{gathered} \theta \leftarrow \theta +\alpha {\nabla }_{\theta }\log {\pi }_{\theta }\left(s_t,a_t\right)v_t \\ \theta 就是GD网络的参数 \end{gathered}$$
这样可能看的懂一些：$$\begin{gathered} \theta \leftarrow \theta +\alpha {\nabla }_{\theta }\log p_{\theta }\left(s_t,a_t\right)r_t \\ p就是概率，r_t就是reward \\ loss=\frac{1}{N}\sum r\ast \log p \end{gathered}$$

下一步a根据最后的概率来选择

关于代码中的一些问题：

1. PG算法中间有一个预测动作的神经网络，最后输出的张量的shape:[None，n_actions]，然后再求这个预测值与现实中的动作的cross-entropy误差

   公式：$$H_{y^{\prime }}(y)=-\sum _i{y}_i^{\prime }\log \left(y_i\right)y_i是预测值，y_i^{\prime }是真实值$$ （最大化r*logp就是最小化—r*logp）。因为强化学习中现实的动作并不一定都是正确的，所以后面还要乘以每一回合reward用来更正预测。如果不用cross-entropy来计算误差，能否不用log？

   这里的loss函数是为了配合policy gradient ，因为输出是概率，所以 需要一个概率之间进行比较的函数，选择了cross entropy。莫烦老师代码中的实现是用的tf.nn.sparse_softmax_cross_entropy_with_logits，这个函数包含了“-” 号。

   这里也可以从优化的角度思考，loss =-log§*r, p和r都是向量，如果如果p小，则-log§ 大，r大则loss 更大。r的值和p的值没有关系，所以为了让loss小，只能让r最大的位置的p最大，即收益最大的位置的概率最大

   这个地方看了台大李宏毅老师的讲解之后，我发现这个地方的log是直接算出来的：这个地方就和莫烦老师的想法不是很一样。
   $$\begin{gathered} {\bar{R}}_{\theta }=\sum _{\tau }R(\tau )p_{\theta }(\tau ) \\ \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 ) \\ \#依据是：\nabla f(x)=f(x)\nabla logf(x) \\ =E_{\tau \sim p_{\theta }(\tau )}\left[R(\tau )\nabla \log p_{\theta }(\tau )\right]\approx \frac{1}{N}\sum _{n=1}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|s_t^n\right) \end{gathered}$$

2. 关于每一回合的reward，最后的reward是一个list，通过归一化，我们可以看到每一回合的reward使如何变化的。对于CartPole-v0的第一回合，图如下：

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5dYUvmyX-1615342857060)(RL的问题与总结.assets/5-2-2.png)]

这只是第一回合的reward，不是全部回合的reward，可以看到前面的reward很大，说明前面的行为要重视，后面的reward很小（杆子要掉下来了），所以后面的行为要惩罚。

对于MountainCar-v0的第30回合的图如下：

这是第30回合的reward，不是整个回合的reward，可以看到通过前29轮的训练，在第30轮，小车已经可以到达终点了，所以后面的行为要重视。

这里有一个问题，每一回合所有的reward都经过了衰减的处理，而且是倒序的衰减处理，第一个reward反而衰减越小，这个的意思是每一回合的reward都与最后一个reward关系最大，同时考虑之前reward的影响吗？

reward的衰减是与游戏本身有关系的：

如果是目标到达类的游戏，比如到达某个点才有最大的收益，我们会用这种在最终才有较大收益的曲线

如果是保持状态类的，在保持状态的初期有较大的收益，但是偏离了状态，则收益大幅下降。

当然在李宏毅教授的课件当中还提到了一个叫做baseline的东西，用于对reward都为正数的游戏，在这种情况下，我们将简单的$r(\tau )$变成$r(\tau )-b$,$b$可以用$E(r(\tau ))$来代替。让reward也有负的时候，这样的好处我在这个地方不知道如何描述，具体可看李宏毅教授课件中的讲解（ https://www.bilibili.com/video/BV1iE411e7KQ?p=1 ），这样有正有负的reward对训练也很有帮助！在莫烦老师代码中我还看到一种方法就是对reward归一化，我觉得这样也可以！

还有一个地方就是在上面的$r(\tau )$也可以变化为${\sum }_{t^{\prime }=t}^{T_n}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}^n$的样子，前面的$\gamma$就是一个小于1的衰减系数，$r_{t^{\prime }}^n$就是一个从当前开始到最后的一个reward。当然这个地方我也有点奇怪，啥从当前开始到最后的reward，后来我想了一下，n就是一回合中总的步数，$T_n$就是所有的回合数，这样就是指当前这个回合中所有的reward的和，这样就和莫烦老师代码中的含义一样了。

还有一个地方就是关于cross_entrop的地方，这个交叉熵到底做了什么，为什么里面会用到one-hot编码，最后的为什么只有logp，而不是qlogp这样的交叉熵的形式。

AC

AC算法也是一个很重要的算法，后面的ddpg，dppo，a3c等算法都与它有关。Actor就是PG算法，Critic就是评判函数。AC是单步更新的。（有人说：AC就是PG加Q-learning）

Actor中与PG不一样的地方就是，用现实和估计的差距（TD error）代替了原来的一回合的reward，Actor网络输出的是所有动作的概率值。

这里的td_error就是A 优势函数，那么什么是优势函数？

优势函数表达在状态s下，某动作a相对于平均而言的优势。
从数量关系来看，就是随机变量相对均值的偏差。
使用优势函数是深度强化学习极其重要的一种策略，尤其对于基于policy的学习。

TD error：$$td\_error=r+\gamma \ast v\_-v$$，v就是在s下得到的value（相当于q值吧），v和v_都由由Critic得到。

因为不是回合更新的，所以用
$$\begin{gathered} loss=\log p_{\theta }\left(s_t,a_t\right)td\_error \\ \theta \leftarrow \theta +\alpha \left(R_{t+1}+\gamma \hat{v}\left(S_{t+1}\right)-\hat{v}\left(S_t\right)\right){\nabla }_{\theta }\log \pi \left(A_t\mid S_t,\theta \right) \end{gathered}$$
的时候p概率只是针对单次的state做出的action的概率，action根据概率随机选择选择得到的。要求loss的最大值，就是求—loss的最小值。（actor的loss和PG算法的loss非常相似，可以看到，这里就是把PG中的V换成了td_error。负号也是和PG一模一样）

Critic的 $$loss=td\_erro{r}^2$$，Critic的作用就是计算v_和优化前面的loss。优化loss部分和之前的DQN类似哎。Critic网络输出的是s的v值。这个网络中状态s的价值和DQN中q值有什么不同？

AC的特点就是有两个网络分别学习，一般情况下，会要求A的学习率大于C的学习率，这里的目的是让A对于动作的更新更准确

这里的V值和Q值，其实没什么区别，这里的critic网络就是直接对Q值的直接估计

前面的DQN，GD，AC网络最后的reward值是：_reward * 0.95 + ep_rs_sum * 0.05，想知道为什么是这个样子？

首先，这个曲线是一个指数衰减的曲线，比较平滑，一般这样做的目的是为了平滑曲线

另外这里的running reward 你是否指的是：

ep_rs_sum = sum(RL.ep_rs)

if 'running_reward' not in globals():
    running_reward = ep_rs_sum
else:
    running_reward = running_reward * 0.99 + ep_rs_sum * 0.01
    if running_reward > DISPLAY_REWARD_THRESHOLD: RENDER = True     # rendering
		print("episode:", i_episode, "  reward:", int(running_reward))
# 这段代码的目的是评估当前的学习器是否达到了一个比较好的水平，如果达到了，则可以进行render 渲染，就是把图像打印出来，因为打印图像一般比较耗时
# 使用running_reward是因为进行了平滑之前的曲线，可能有部分步达到了比较好的水平，但是是炸胡，平滑保证能持续达到比较好的水平才进行渲染和打印数值

Actor Critic优点：可以进行单步更新, 相较于传统的PG回合更新要快.
Actor Critic缺点：Actor的行为取决于 Critic 的Value，但是因为 Critic本身就很难收敛和actor一起更新的话就更难收敛了。（为了解决收敛问题， Deepmind 提出了 Actor Critic 升级版 Deep Deterministic Policy Gradient，后者融合了 DQN 的优势, 解决了收敛难的问题)。下面提到的A3C也是早期对AC算法的优化，也有很多值得我们学习的地方。

A3C

Asynchronous Advantage Actor-critic 异步优势 AC算法

相比Actor-Critic，A3C的优化主要有3点，分别是异步训练框架，网络结构优化，Critic评估点的优化。其中异步训练框架是最大的优化。

下面是A3C的框架，可见global network的下面有很多的小网络，这就是异步。公共部分的网络模型就是我们要学习的模型，而线程里的网络模型主要是用于和环境交互使用的

关于第二个优化，网络结构的优化。之前在 Actor-Critic中，我们使用了两个不同的网络Actor和Critic。在A3C这里，我们把两个网络放到了一起，即输入状态SS,可以输出状态价值VV,和对应的策略ππ, 当然，我们仍然可以把Actor和Critic看做独立的两块，分别处理

第三个优化是Critic评估点的优化。原来AC算法的优势函数（就是td_error）是
$$A(S,t)=R+\gamma V(S^{\prime })-V(S)$$
在A3C中，采用了N步采样来加速收敛，优势函数是：
$$A(S,t)=R_t+\gamma R_{t+1}+\dots {\gamma }^{n-1}{R}_{t+n-1}+{\gamma }^{n}V\left(S^{\prime }\right)-V(S)$$
于Actor和Critic的损失函数部分，和Actor-Critic基本相同。有一个小的优化点就是在Actor-Critic策略函数的损失函数中，加入了策略π的熵项（这不是和SAC想法一样了吗）,系数为c, 即策略参数的梯度更新和Actor-Critic相比变成了这样：
$$\theta \leftarrow \theta +\alpha {\nabla }_{\theta }\log {\pi }_{\theta }\left(s_t,a_t\right)A(S,t)+c{\nabla }_{\theta }H\left(\pi \left(S_t,\theta \right)\right)$$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1xK64iEL-1615342857075)(C:\Users\slaxes_g\Pictures\6-3-1.png)]

这个A3C论文里面还有涉及了很多的其他要点，我觉得很有意思，来说一下。

1. 我们所说的policy-based和value-based其实是有算法基础依据的。他们统统归纳与policy-gradient methods 和 action-value methods中。

   我们把去估计动作值函数(action-value)然后利用其进行决策的方法叫做action-value methods

   而把将策略参数化，并且每次依照当前策略参数和环境反馈，去更新参数的方法叫做policy-gradient methods，一种常见的更新方法就是策略梯度上升(gradient ascent)。

2. 我们来说说policy-gradient methods的目标函数，policy-method就是根据目标函数对策略参数的导数进行优化的。

   通常我们定义的目标函数是：
   $$J(\theta )=v_{{\pi }_{\theta }}\left(S_{\text{start }}\right)$$
   它的导数就是：所有a和所有s的组合
   $$\begin{gathered} \nabla J(\theta )=\sum _s{\mu }_{\pi }(s)\sum _a{q}_{\pi }(s,a){\nabla }_{\theta }\pi (a\mid s,\theta ) \\ \text{ 其中 }{\mu }_{\pi }(s)\text{ 是值在策略 }\pi \text{ 下任意时间 }t\text{ 状态 }s\text{ 的出现的期望 } \end{gathered}$$
   然后我们就可以对上面的公式进行简化：
   $$\begin{gathered} 对于某一个episode：\nabla J(\theta )=E_{\pi }\left[\sum _a{q}_{\pi }\left(S_t,a\right){\nabla }_{\theta }\pi \left(a\mid S_t,\theta \right)\right] \\ \nabla \log (f(\theta ))\ast f(\theta )=\nabla f(\theta ) \\ \nabla J(\theta )=E_{\pi }\left[q_{\pi }\left(S_t,A_t\right){\nabla }_{\theta }\log \pi \left(A_t\mid S_t,\theta \right)\right] \\ \theta \leftarrow \theta +\alpha {\gamma }^t{q}_{\pi }\left(S_t,A_t\right){\nabla }_{\theta }\log \pi \left(A_t\mid S_t,\theta \right) \end{gathered}$$
   式子中的q_{\pi}(S_t,A_t)的不同改进形成了各种的算法

3. 对于REINFORCE算法就是policy-gradient methods下的一个具体的算法：

   每次取样一个回合（MC算法）对参数进行更新，q(s,a)函数变为：
   $$\begin{gathered} G_t=\sum _{k=t+1}^T{\gamma }^{k-t}{R}_k \\ \theta \leftarrow \theta +\alpha {\gamma }^t{G}_t{\nabla }_{\theta }\log \pi \left(A_t\mid S_t,\theta \right) \end{gathered}$$

   REINFORCE还有扩展方法：REINFORCE with baseline

   可以在q(s,a)后面减去任意的与动作a无关的项b(s)，这样可以减少算法的方差（variance）

$$\theta \leftarrow \theta +\alpha {\gamma }^t\left(G_t-b(s)\right){\nabla }_{\theta }\log \pi \left(A_t\mid S_t,\theta \right)$$
​

​ 利用了等式：
$$\sum _{a}b(s){\nabla }_{\theta }\pi (a\mid s,\theta )=b(s){\nabla }_{\theta }\sum _a\pi (a\mid s,\theta )=b(s){\nabla }_{\theta }1=0$$
​ 我们可以看到，这里用的都是回合的更新，所以REINFORCE用的是MC的思想，如果改用TD的思想的话，我们就得到了AC算 法。

​ 将REINFORCE中更新时使用的Gt 改为
$$\begin{gathered} R_{t+1}+\gamma \hat{v}\left(S_{t+1}\right)-b\left(S_t\right) \\ \text{ 其中 }\hat{v}(s)\text{ 是我们对状态值函数的估计，一般我们可以直接用 }\hat{v}\left(S_t\right)\text{ 来确定 }b\left(S_t\right) \\ \theta \leftarrow \theta +\alpha {\gamma }^t\left(R_{t+1}+\gamma \hat{v}\left(S_{t+1}\right)-\hat{v}\left(S_t\right)\right){\nabla }_{\theta }\log \pi \left(A_t\mid S_t,\theta \right) \end{gathered}$$

为什么减去一个b，就会减少方差呢？？

这里的差指的是估计的梯度的方差，反映了参数更新的稳定性。实际上，减去一个基线虽然不会改变更新值的期望值，但是它会影响更新的方差。赌博机问题中我们介绍了类似的技巧，通过减去平均回报（基准），梯度算法能够学习的更快。比如对于一些状态来说，他们都具有比较大的动作值函数。那么我们就需要有一个大的基线来区分更大的动作值和相对小的动作值。但是对于其他一些状态，所有状态的值函数都比较小，那么我们就需要一个小的基线值。

4. 强化学习的很多算法都是向前看的算法，即当前状态或动作的价值更新是依赖于未来状态或动作的，这样的算法称为forward view （前向视角）。前向视角实施起来多少有些不方便，毕竟未来的事，当前并知道。还有另外一种思路是所谓的backward view （后向视角），通过eligibility trace来考虑最近刚刚访问过的状态或动作。

5. 熵正则化？

   这到底是什么东西，我知道熵，交叉熵，相对熵，怎么不知道这个熵正则化？

   看名字就知道，这个就是熵作为后面的正则化项了。那什么又是正则化？那就要你自己去了解之间的基础知识了。

DDPG

DDPG算法是对前面AC，DQN，PG算法的综合，集合了各个算法的优点。最后有四个网络。Actor和Critic网络下分别有还有eval，target网络，eval与target网络的结构是一样的。DDPG采取确定性策略：$$a_t=\mu \left(s_t|{\theta }^{\mu }\right)$$，其中${\theta }^{\mu }$就是产生确定性动作的策略网络参数。

Actor：J（-Q）就是loss，至于这里为什么要将Q与a相乘，可能是因为莫烦文章中说的：前半部分的Q，从Critic得到，是Actor要考虑如何移动得到最大的Q，后半部分的$\mu$是Actor要如何修改自身的参数，使之更有可能做这个动作。两者合起来Actor要朝着可能获取大Q的的方向去修改参数。
$${{{\nabla }_{{\theta }^{\mu }}J\approx \frac{1}{N}\sum _i{\nabla }_{a}Q\left(s,a|{\theta }^Q\right)|}_{s=s_i,a=\mu \left(s_i\right)}{\nabla }_{{\theta }^{\mu }}\mu \left(s|{\theta }^{\mu }\right)|}_{s_i}$$

Actor网络的loss是q，原因是：$$dq/d\theta =dq/da\ast da/d\theta$$，其中$\theta$就是Actor自身的参数。Actor网络最后输出的是一个动作，预测动作。a由Actor网络直接输出获得

Critic：L就是loss，借鉴了DQN和Q-learning
$$\begin{gathered} y_i=r_i+\gamma Q^{\prime }\left(s_{i+1},{\mu }^{\prime }\left(s_{i+1}|{\theta }^{{\mu }^{\prime }}\right)|{\theta }^{Q^{\prime }}\right) \\ L=\frac{1}{N}\sum _i{\left(y_i-Q\left(s_i,a_i|{\theta }^Q\right)\right)}^2 \end{gathered}$$
在Critic网络中，最后得到的$$Q=a\ast w1+s\ast w2+b$$，这个a就是从Actor网络中输出的a。DQN的target是得到所有动作的q值取max，而DDPG的Critic是得到一个确定的q值。

PPO

如果一句话概括 PPO: OpenAI 提出的一种解决 Policy Gradient 不好确定 Learning rate (或者 Step size) 的问题。PPO 利用 New Policy 和 Old Policy 的比例, 限制了 New Policy 的更新幅度, 让 Policy Gradient 对稍微大点的 Step size 不那么敏感。

限制的部分就在于actor的更新，A会乘一个新旧概率比，如果差距大优势大那么学习幅度就加大 。

下面是理解后面复杂公式的前提基础：
$$E_{x\sim p}[f(x)]=\int f(x)p(x)dx=\int f(x)\frac{p(x)}{q(x)}q(x)dx=E_{x\sim q}\left[f(x)\frac{p(x)}{q(x)}\right]$$
下面的新旧概率的比值要理解on-policy ,off-policy的问题，正是因为在PG算法中的每轮的更新需要采取一回合的数据来训练，这个取样所花的时间就很多，所以这个地方改进了算法，让一个${\theta }^{\prime }$策略来取样，取样数据拿来在训练$\theta$策略
$$\begin{gathered} Gradientforupdate \\ =E_{\left(s_t,a_t\right)\sim {\pi }_{\theta }}\left[A^{\theta }\left(s_t,a_t\right)\nabla \log p_{\theta }\left(a_t^n|s_t^n\right)\right] \\ =E_{\left(s_t,a_t\right)\sim {\pi }_{{\theta }^{\prime }}}\left[\frac{P_{\theta }\left(s_t,a_t\right)}{P_{{\theta }^{\prime }}\left(s_t,a_t\right)}{A}^{{\theta }^{\prime }}(s_t,a_t)\nabla \log p_{\theta }\left(a_t^n|s_t^n\right)\right] \\ =E_{\left(s_t,a_t\right)\sim {\pi }_{{\theta }^{\prime }}}\left[\frac{p_{\theta }\left(a_t|s_t\right)}{p_{{\theta }^{\prime }}\left(a_t|s_t\right)}\frac{p_{\theta }\left(s_t\right)}{p_{{\theta }^{\prime }}\left({\mathbf{s}}_t\right)}{A}^{{\theta }^{\prime }}\left(s_t,a_t\right)\nabla \log p_{\theta }\left(a_t^n|s_t^n\right)\right] \\ \#令\frac{p_{\theta }(s_t)}{p_{{\theta }^{\prime }}(s_t)}=1，人为使得，因为这个式子不好算 \\ \#\nabla f(x)=f(x)\nabla \log f(x)上面的式子是\nabla ,下面的是原来的式子 \\ {J}^{{\theta }^{\prime }}(\theta )=E_{\left(s_t,a_t\right)\sim {\pi }_{{\theta }^{\prime }}}\left[\frac{p_{\theta }\left(a_t|s_t\right)}{p_{{\theta }^{\prime }}\left(a_t|s_t\right)}{A}^{{\theta }^{\prime }}\left(s_t,a_t\right)\right] \end{gathered}$$

后面加入的KL惩罚项是想让$$\frac{p_{\theta }}{p_{{\theta }^{\prime }}}$$不要相差太多，所以给出了一个惩罚项，相差太多之后，这样的计算方式就会出现问题。

Actor更新有两种方式：(最大化L)

第一个是用KL pernaty：
$$L^{KLPEN}(\theta )=E_{\left(s_t,a_t\right)\sim {\pi }_{{\theta }^{\prime }}}\left[\frac{{\pi }_{\theta }\left(a_t|s_t\right)}{{\pi }_{{\theta }_{\mathrm{o}\mathrm{l}\mathrm{d}}}\left(a_t|s_t\right)}{\hat{A}}_t-\beta \mathrm{K}\mathrm{L}\left[{\pi }_{{\theta }_{\mathrm{o}\mathrm{l}\mathrm{d}}}\left(\cdot |s_t\right),{\pi }_{\theta }\left(\cdot |s_t\right)\right]\right]$$
第二个是用clipped surrogate objective：
$$L^{CLIP}(\theta )=E_{\left(s_t,a_t\right)\sim {\pi }_{{\theta }^{\prime }}}\left[\min \left(\left[\frac{{\pi }_{\theta }\left(a_t|s_t\right)}{{\pi }_{{\theta }_{\text{old }}}\left(a_t|s_t\right)}{\hat{A}}_t\right]{\hat{A}}_t,\mathrm{clip}\left(\frac{{\pi }_{\theta }\left(a_t|s_t\right)}{{\pi }_{{\theta }_{\text{old }}}\left(a_t|s_t\right)},1-ϵ,1+ϵ\right){\hat{A}}_t\right)\right]$$
Critic的更新方式：（最小化loss，这里就和AC算法一模一样）
$$loss=(r+\gamma \ast v\_-v{)}^2$$

之所以有新旧参数，是因为$${\hat{\mathbf{E}}}_t\left[\frac{{\pi }_{\theta }\left(a_t|s_t\right)}{{\pi }_{{\theta }_{\text{old }}}\left(a_t|s_t\right)}{\hat{A}}_t\right]$$，要更新啊。（感觉这里又和DQN有点像）

SAC

soft actor critic 慢AC 算法

这个部分是自己从看论文到实现一整个SAC都实现了，关于论文网上也有很多的内容，也是各有各的讲法，所以也是需要好好的总结一下的。

基于最大熵的强化学习，熵最高的策略具有更高的随机性。在策略中允许高度随机的动作，更能够顺利的适应预期之外的干扰。是off-policy的。增加熵也就说明策略的随机性增强，所以会增加更多的探索，从而可以加快后续的学习速度。

总结归纳

1. RL的四个要素：

   策略

   1）确定策略：$$a=\pi (s)$$

   2）随机策略：$$\pi (a|s)=p[a_t=a|s_t=s]$$

   奖励函数：

   r 这个不用多说

   累计奖励函数：（需补充）

   V 一个策略的优劣取决于长期执行这一策略后的累积奖励，常见的长期累积奖励：

   1）$$V^{\pi }(s)=E_{\pi }\left[\sum _{i=1}^h{r}_i|s_0=s\right]$$

   2）$$V^{\pi }(s)=\underset{h\to \infty }{\lim }{E}_{\pi }\left[\frac{1}{h}\sum _{i=1}^h{r}_i|s_0=s\right]$$

   3）$$V^{\pi }(s)=E_{\pi }\left[\sum _{i=1}^{\infty }{\gamma }^{i-1}{r}_i|s_0=s\right]$$，如：Sarsa-lambda，GD等

   4）…

   上面这些大多用在后面的加入了神经网络的RL算法中间。作为placeholder输入进行训练的。

   模型：

   所有强化学习都是马尔科夫决策的过程：（需补充）

附录一

PG算法使用的是交叉熵，SAC算法使用的是相对熵（KL散度），那么为什么在强化学习中会用到熵呢？

熵（信息熵）

熵用来衡量一个系统的混乱程度，代表系统中信息量的总和；熵值越大，表明这个系统的不确定性就越大。 信息量是衡量某个事件的不确定性，而熵是衡 量一个系统的不确定性。

一般我们使用：
$$信息熵=\sum _{x=1}^n（信息x发生的概率\ast 验证信息x需要的信息）$$

信息熵就是所有信息的期望：
$$H(p)=-\sum _{i=1}^{n}p(x_i)log(p(x_i))$$
其中$$I(x)=-log(p(x))$$ 表示的就是信息量，负号是为了保证信息量为非负数。

那为什么信息量这样表示呢？

假设我们有两个不相关的x和y时间，两个事件同时发生的获得的信息量就是各个事件信息量的和，即为

I(x,y)=I(x)+I(y) 。因为两个事件独立不相关，所以p(x,y)=p(x)p(y) 。我们取对数就可以得到log p(x,y)=log p(x)+log q(x) . 我们想要让信息熵最小（消除不确定性），那么就是为0嘛！所以就是I(x)= - log p(x) . 这个负号有意思，又保证了信息量为非负数，又与p(x)成了反比。

交叉熵

表示使用分布q(x)表示目标分布p(x)的困难程度。

交叉熵的公式：
$$H(p,q)=-\sum _{i=1}^{n}p(x_i)log(q(x_i))$$
一般p(x)表示真实分布，q(x)表示模型的预测分布

相对熵（KL散度）

表示同一个随机变量的两个不同分布间的距离。

对于一个随机变量x有两个单独的概率分布p(x)和q(x)，那么相对熵：
$$\begin{gathered} D_{KL}(p||q)=\sum _{i=1}^{n}p(x_i)log(p(x_i)/q(x_i)) \\ =\sum _{i=1}^{m}p(x_i)log(p(x_i))-\sum _{i=1}^{m}p(x_i)log(q(x_i)) \\ =-H(p)+H(p,q) \end{gathered}$$
总的来说，相对熵是用来衡量同一个随机变量的两个不同分布之间的距离。在实际应用中，假如p(x)p(x)是目标真实的分布，而q(x)q(x)是预测得来的分布，为了让这两个分布尽可能的相同的，就需要最小化KL散度。

所以为什么计算loss我们使用相对熵（SAC算法），因为我们可以得到：

相对熵=交叉熵 - 信息熵 $ D_{KL}(p,q)=H(p,q)-H§$

因为一般p(x)是目标（训练数据）的分布，是固定的，有时候最小化相对熵也等于最小化交叉熵。

所以经常看到把交叉熵当做loss，交叉熵损失函数：
$$Loss=-[ylog\hat{y}+(1-y)log(1-\hat{y})]$$

最大似然估计（ max linkehood estimate）

通过若干次试验，观察其结果，利用试验结果得到某个参数值能够使样本出现的概率为最大，则称为极大似然估计。

设有一组训练样本$X={x1,x2,⋯,xm} $,该样本的分布为$p(x)$ 。假设使用$\theta$ 参数化模型得到$q(x;\theta )$ ，现用这个模型来估计X 的概率分布，得到似然函数
$$L(\theta )=q(X;\theta )=\prod _i^{m}q(x_i;\theta )$$
最大似然估计就是求得$\theta$使得$L(\theta )$ 的值最大，也就是
$${\theta }_{ML}=\arg \underset{\theta }{\max }\prod _i^{m}q(x_i;\theta )$$
对上式的两边同时取log，乘积变成加法 ，等价优化log的最大似然估计即log-likelyhood ，最大对数似然估计
$${\theta }_{ML}=\arg \underset{\theta }{\max }\sum _i^m\log q(x_i;\theta )$$
对上式的右边进行缩放并不会改变argmax 的解，上式的右边除以样本的个数m
$${\theta }_{ML}=\arg \underset{\theta }{\max }\frac{1}{m}\sum _i^m\log q(x_i;\theta )$$
上式就是求随机变量X的函数$\log (X;\theta )$ 的均值，根据大数定理，随着样本容量的增加，样本的算术平均值将趋近与随机变量的期望
$$\frac{1}{m}\sum _i^m\log q(x_i;\theta )\to E_{x\sim P}(\log q(x;\theta ))$$
于是最大化似然估计变成了：(x是训练样本，所以才是x~p的分布)
$$\begin{gathered} {\theta }_{ML}=\arg \underset{\theta }{\max }{E}_{x\sim P}(\log q(x;\theta )) \\ =\arg \underset{\theta }{\min }{E}_{x\sim p}(-\log q(x;\theta )) \end{gathered}$$
然后我们在看看KL散度：
$$\begin{array}{rl}{D}_{KL}(p\Vert q)& =\sum _{i}p\left(x_i\right)\log \left(\frac{p\left(x_i\right)}{q\left(x_i\right)}\right)\\ & =E_{x\sim p}\left(\log \frac{p(x)}{q(x)}\right)\\ & =E_{x\sim p}(\log p(x)-\log q(x))\\ & =E_{x\sim p}(\log p(x))-E_{x\sim p}(\log q(x))\end{array}$$
前一个式子是固定的，所以最小化交叉熵就和最大化对数似然估计是等价的。

多分类交叉熵

样本容量的增加，样本的算术平均值将趋近与随机变量的期望**
$$\frac{1}{m}\sum _i^m\log q(x_i;\theta )\to E_{x\sim P}(\log q(x;\theta ))$$
于是最大化似然估计变成了：(x是训练样本，所以才是x~p的分布)
$$\begin{gathered} {\theta }_{ML}=\arg \underset{\theta }{\max }{E}_{x\sim P}(\log q(x;\theta )) \\ =\arg \underset{\theta }{\min }{E}_{x\sim p}(-\log q(x;\theta )) \end{gathered}$$
然后我们在看看KL散度：
$$\begin{array}{rl}{D}_{KL}(p\Vert q)& =\sum _{i}p\left(x_i\right)\log \left(\frac{p\left(x_i\right)}{q\left(x_i\right)}\right)\\ & =E_{x\sim p}\left(\log \frac{p(x)}{q(x)}\right)\\ & =E_{x\sim p}(\log p(x)-\log q(x))\\ & =E_{x\sim p}(\log p(x))-E_{x\sim p}(\log q(x))\end{array}$$
前一个式子是固定的，所以最小化交叉熵就和最大化对数似然估计是等价的。

多分类交叉熵

二分类交叉熵