一文读懂 深度强化学习算法 A3C （Actor-Critic Algorithm）

 

一文读懂 深度强化学习算法 A3C （Actor-Critic Algorithm）

2017-12-25  16:29:19  

 

　　对于 A3C 算法感受本身老是只知其一;不知其二，现将其梳理一下，记录在此，也给想学习的小伙伴一个参考。

　　想要认识清楚这个算法，须要对 DRL 的算法有比较深入的了解，推荐你们先了解下 Deep Q-learning 和 Policy Gradient 算法。

　　咱们知道，DRL 算法大体能够分为以下这几个类别：Value Based and Policy Based，其经典算法分别为：Q-learning 和 Policy Gradient Method。

　　

　　而本文所涉及的 A3C 算法则是结合 Policy 和 Value Function 的产物，其中，基于 Policy 的方法，其优缺点总结以下：

　　Advantages:
　　　　1. Better convergence properties （更好的收敛属性）
　　　　2. Effective in high-dimensional or continuous action spaces（在高维度和连续动做空间更加有效）
　　　　3. Can learn stochastic policies（能够Stochastic 的策略）
　　Disadvantages:
　　　　1. Typically converge to a local rather than global optimum（一般获得的都是局部最优解）
　　　　2. Evaluating a policy is typically inefficient and high variance （评价策略一般不是很是高效，而且有很高的误差）

 

　　咱们首先简要介绍一些背景知识（Background）：

　　

　　在 RL 的基本设置当中，有 agent，environment, action, state, reward 等基本元素。agent 会与 environment 进行互动，而产生轨迹，经过执行动做 action，使得 environment 发生状态的变化，s -> s' ；而后 environment 会给 agent 当前 动做选择以 reward（positive or negative）。经过不断的进行这种交互，使得积累愈来愈多的 experience，而后更新 policy，构成这个封闭的循环。为了简单起见，咱们仅仅考虑 deterministic environment，即：在状态 s 下，选择 action a 老是会获得相同的 状态 s‘。

　　

　　为了清楚起见，咱们先定义一些符号：

　　1. stochastic policy $\pi(s)$ 决定了 agent's action, 这意味着，其输出并不是 single action，而是 distribution of probability over actions (动做的几率分布)，sum 起来为 1.

　　2. $\pi(a|s)$ 表示在状态 s 下，选择 action a 的几率；

　　而咱们所要学习的策略 $\pi$，就是关于 state s 的函数，返回全部 actions 的几率。

　　

　　咱们知道，agent 的目标是最大化所能获得的奖励（reward），咱们用 reward 的指望来表达这个。在几率分布 P 当中，value X 的指望是：

　　

　　其中 Xi 是 X 的全部可能的取值，Pi 是对应每个 value 出现的几率。指望就能够看做是 value Xi 与 权重 Pi 的加权平均。

　　这里有一个很重要的事情是： if we had a pool of values X, ratio of which was given by P, and we randomly picked a number of these, we would expect the mean of them to be . And the mean would get closer to as the number of samples rise. 

　　

　　咱们再来定义 policy $\pi$ 的 value function V(s)，将其看做是 指望的折扣回报 (expected discounted return)，能够看做是下面的迭代的定义：

　　

　　这个函数的意思是说：当前状态 s 所能得到的 return，是下一个状态 s‘ 所能得到 return 和 在状态转移过程当中所获得 reward r 的加和。

　　

　　此外，还有 action value function Q(s, a)，这个和 value function 是息息相关的，即：

　　

　　此时，咱们能够定义一个新的 function A(s, a) ，这个函数称为 优点函数（advantage function）:

　　

　　其表达了在状态 s 下，选择动做 a 有多好。若是 action a 比 average 要好，那么，advantage function 就是 positive 的，不然，就是 negative 的。

　　

　　Policy Gradient：

　　当咱们构建 DQN agent 的时候，咱们利用 NN 来估计的是 Q(s, a) 函数。这里，咱们采用不一样的方法来作，既然 policy $\pi$ 是 state $s$ 的函数，那么，咱们能够直接根据 state 的输入 来估计策略的选择嘛。

　　这里，咱们 NN 的输入是 state s，输出是 an action probability distribution $\pi_\theta$，其示意图为：

　　

　　实际的执行过程当中，咱们能够按照这个 distribution 来选择动做，或者 直接选择 几率最大的那个 action。

　　

　　可是，为了获得更好的 policy，咱们必须进行更新。那么，如何来优化这个问题呢？咱们须要某些度量（metric）来衡量 policy 的好坏。

　　咱们定一个函数 $J(\pi)$，表示 一个策略所能获得的折扣的奖赏，从初始状态 s0 出发获得的全部的平均：

　　

　　咱们发现这个函数的确很好的表达了，一个 policy 有多好。可是问题是很难估计，好消息是：we don't have to。

　　咱们须要关注的仅仅是如何改善其质量就好了。若是咱们知道这个 function 的 gradient，就变的很 trivial （专门查了词典，这个是：琐碎的，微不足道的，的意思，恩，不用谢）。

　　有一个很简便的方法来计算这个函数的梯度：

　　

　　这里其实从 目标函数 到这个梯度的变换，有点忽然，咱们先跳过这个过程，就假设已是这样子了。后面，我再给出比较详细的推导过程。

　　这里能够参考 Policy Gradient 的原始paper：Policy Gradient Methods for Reinforcement Learning with Function Approximation

　　或者是 David Silver 的 YouTube 课程：https://www.youtube.com/watch?v=KHZVXao4qXs

 　　

　　简单而言，这个指望内部的两项：

　　第一项，是优点函数，即：选择该 action 的优点，当低于 average value 的时候，该项为 negative，当比 average 要好的时候，该项为 positive；是一个标量（scalar）；

　　第二项，告诉咱们了使得 log 函数 增长的方向；

　　

　　将这两项乘起来，咱们发现：likelihood of actions that are better than average is increased, and likelihood of actions worse than average is decreased. 

　　Fortunately, running an episode with a policy π yields samples distributed exactly as we need. States encountered and actions taken are indeed an unbiased sample from the and π(s) distributions. That’s great news. We can simply let our agent run in the environment and record the (s, a, r, s’) samples. When we gather enough of them, we use the formula above to find a good approximation of the gradient . We can then use any of the existing techniques based on gradient descend to improve our policy.

　　

　　Actor-Critic：

　　咱们首先要计算的是优点函数 A(s, a)，将其展开：

　　

　　运行一次获得的 sample 能够给咱们提供一个 Q(s, a) 函数的 unbiased estimation。咱们知道，这个时候，咱们仅仅须要知道 V(s) 就能够计算 A(s, a）。

　　这个 value function 是容易用 NN 来计算的，就像在 DQN 中估计 action-value function 同样。相比较而言，这个更简单，由于 每一个 state 仅仅有一个 value。

　　咱们能够将 value function 和 action-value function 联合的进行预测。最终的网络框架以下：

　　

　　这里，咱们有两个东西须要优化，即： actor 以及 critic。

　　actor：优化这个 policy，使得其表现的愈来愈好；

　　critic：尝试估计 value function，使其更加准确；

　　这些东西来自于 the Policy Gradient Theorem :

　　

　　简单来说，就是：actor 执行动做，而后 critic 进行评价，说这个动做的选择是好是坏。

　　

　　Parallel agents：

　　若是只用 单个 agent 进行样本的采集，那么咱们获得的样本就很是有多是高度相关的，这会使得 machine learning 的model 出问题。由于 machine learning 学习的条件是：sample 知足独立同分布的性质。可是不能是这样子高度相关的。在 DQN 中，咱们引入了 experience replay 来克服这个难题。可是，这样子就是 offline 的了，由于你是先 sampling，而后将其存储起来，而后再 update 你的参数。

　　那么，问题来了，可否 online 的进行学习呢？而且在这个过程当中，仍然打破这种高度相关性呢？

　　We can run several agents in parallel, each with its own copy of the environment, and use their samples as they arrive.

　　1. Different agents will likely experience different states and transitions, thus avoiding the correlation².

　　2. Another benefit is that this approach needs much less memory, because we don’t need to store the samples.

　　

　　此外，还有一个概念也是很是重要的：N-step return 。

　　一般咱们计算的 Q(s, a), V(s) or A(s, a) 函数的时候，咱们只是计算了 1-step 的 return。

　　

　　在这种状况下，咱们利用的是从 sample （s0, a0, r0, s1）得到的 即刻奖励（immediate return），而后该函数下一步预测 value 给咱们提供了一个估计 approximation。可是，咱们能够利用更多的步骤来提供另一个估计：

　　

　　或者 n-step return：

　　

　　The n-step return has an advantage that changes in the approximated function get propagated much more quickly. Let’s say that the agent experienced a transition with unexpected reward. In 1-step return scenario, the value function would only change slowly one step backwards with each iteration. In n-step return however, the change is propagated n steps backwards each iteration, thus much quicker. 

　　N-step return has its drawbacks. It’s higher variance because the value depends on a chain of actions which can lead into many different states. This might endanger the convergence. 

　　

　　这个就是 异步优点actor-critic 算法（Asynchronous advantage actor-critic , 即：A3C）。

　　

　　以上是  A3C 的算法部分，下面从 coding 的角度来看待这个算法：

　　基于 python+Keras+gym 的code 实现，能够参考这个 GitHub 连接：https://github.com/jaara/AI-blog/blob/master/CartPole-A3C.py

　　所涉及到的大体流程，能够概括为：

　　

　　在这其中，最重要的是 loss function 的定义：

　　

　　其中， is the loss of the policy, is the value error and is a regularization term. These parts are multiplied by constants and , which determine what part we stress more. 

　　下面分别对这三个部分进行介绍：

　　1. Policy Loss：

　　咱们定义 objective function $J(\pi)$ 以下：

　　

　　这个是：经过策略 $\pi$ 平均全部起始状态所获得的总的 reward（total reward an agent can achieve under policy $\pi$ averaged over all starting states）。

　　根据 Policy Gradient Theorem 咱们能够获得该函数的 gradient：

　　

　　咱们尝试最大化这个函数，那么，对应的 loss 就是这个 负函数：

　　

　　咱们将 A(s,a) 看作是一个 constant，而后从新将上述函数改写为以下的形式：

　　

　　咱们就对于minibatch 中全部样本进行平均，来扫一遍这个指望值。最终的 loss 能够记为：

　　

　　

　　2. Value Loss:

　　the truth value function V(s) 应该是知足 Bellman Equation 的：

　　

　　而咱们估计的 V(s) 应该是收敛的，那么，根据上述式子，咱们能够计算该 error：

　　

　　这里你们可能比较模糊，刚开始我也是比较晕，这里的 groundtruth 是怎么获得的？？？

　　其实这里是根据 sampling 到的样本，而后计算两个 V(s) 之间的偏差，看这两个 value function 之间的差距。

　　因此，咱们定义 Lv 为 mean squared error （given all samples）:

　　

　　3. Regularizaiton with Policy Entropy : 

　　为什么要加这一项呢？咱们想要在 agent 与 environment 进行互动的过程当中，平衡 探索和利用，咱们想去以必定的概率来尝试其余的 action，从而不至于采样获得的样本太过于集中。因此，引入这个 entropy，来使得输出的分布，可以更加的平衡。举个例子：

　　fully deterministic policy [1, 0, 0, 0] 的 entropy 是 0 ； 而 totally uniform policy[0.25, 0.25, 0.25, 0.25]的 entropy 对于四个value的分布，值是最大的。

　　咱们为了使得输出的分布更加均衡，因此要最大化这个 entropy，那么就是 minimize 这个 负的 entropy。

　　

　　总而言之，咱们能够借助于现有的 deep learning 的框架来 minimize 这个这些 total loss，以达到 优化网络参数的目的。

　　

　　Reference：

　　1. https://github.com/jaara/AI-blog/blob/master/CartPole-A3C.py

　　2. https://jaromiru.com/2017/03/26/lets-make-an-a3c-implementation/

　　3. https://www.youtube.com/watch?v=KHZVXao4qXs

　　4. https://github.com/ikostrikov/pytorch-a3c

　　

 

　　======================================================

　　  Policy Gradient Method 目标函数梯度的计算过程： 

　　======================================================

　　reference paper：policy-gradient-methods-for-reinforcement-learning-with-function-approximation （NIPS 2000, MIT press）

　　过去有不少算法都是基于 value-function 进行的，虽然取得了很大的进展，可是这种方法有以下两个局限性：　　
　　首先，这类方法的目标在于找到 deterministic policy，可是最优的策略一般都是 stochastic 的，以特定的几率选择不一样的 action；

　　其次，一个任意的小改变，均可能会致使一个 action 是否会被选择。这个不连续的改变，已经被广泛认为是创建收敛精度的关键瓶颈。

　　而策略梯度的方法，则是从另一个角度来看待这个问题。咱们知道，咱们的目标就是想学习一个，从 state 到 action 的一个策略而已，那么，咱们有必要非得先学一个 value function 吗？咱们能够直接输入一个 state，而后通过 NN，输出action 的distribution 就好了嘛，而后，将 NN 中的参数，看作是可调节的 policy 的参数。咱们假设 policy 的实际执行的表现为 $\rho$，即：the averaged reward per step。咱们能够直接对这个 $\rho$ 求偏导，而后进行参数更新，就能够进行学习了嘛：

　　

　　若是上述公式是成立的，那么，$\theta$ 一般均可以保证能够收敛到局部最优策略。而这个文章就提供了上述梯度的一个无偏估计，这是利用 一个估计的知足特定属性的 value function，从 experience 中进行估计。

　　1. Policy Gradient Theorem （策略梯度定理）

　　这里讨论的是标准的 reinforcement learning framework，有一个 agent 与 环境进行交互，而且知足马尔科夫属性。

　　在每一个时刻 $t \in {0, 1, 2, ... }$ 的状态，动做，奖励 分别记为：st, at, rt。而环境的动态特征能够经过 状态转移几率（state transition probability）来刻画。

　　

　　从上面，能够发现各个概念的符号表示及其意义。

　　

 　　====>> 　　未完，待续 。。。

　　

 

 

　　======================================================

　　  　　　　　　Pytorch for A3C

　　======================================================

　　本文将继续以 Pytorch 框架为基础，从代码层次上来看具体的实现，本文所用的 code，来自于：https://github.com/ikostrikov/pytorch-a3c

　　代码的层次以下所示：

　　

　　咱们来看几个核心的code：

　　

　　main.py

　　====>> 所用到的各类重要的参数设置及其初始化：

　　

　　

　　

　　train.py

　　

　　

　　

　　model.py