内容简介：刚刚举行的 WAVE SUMMIT 2019深度学习开发者峰会上，PaddlePaddle 发布了 PARL 1.1 版本，这一版新增了 IMPALA、A3C、A2C 等一系列并行算法。作者重新测试了一遍内置 example，发现卷积速度也明显加快，从 1.0 版本的训练一帧需大约 1 秒优化到了 0.15 秒（配置：win8，i5-6200U，GeForce-940M，batch-size=32）。嘿嘿，超级本实现游戏智能的时代终于来临！废话不多说，我们赶紧试试 PARL 的官方 DQN 算法，玩一玩 F
刚刚举行的 WAVE SUMMIT 2019深度学习开发者峰会上，PaddlePaddle 发布了 PARL 1.1 版本，这一版新增了 IMPALA、A3C、A2C 等一系列并行算法。作者重新测试了一遍内置 example，发现卷积速度也明显加快，从 1.0 版本的训练一帧需大约 1 秒优化到了 0.15 秒（配置：win8，i5-6200U，GeForce-940M，batch-size=32）。
嘿嘿，超级本实现游戏智能的时代终于来临！废话不多说，我们赶紧试试 PARL 的官方 DQN 算法，玩一玩 Flappy-Bird。
关于作者：曹天明（kosora），2011 年毕业于天津科技大学，7 年的 PHP+Java 经验。个人研究方向——融合 CLRS 与 DRL 两大技术体系，并行刷题和模型训练。专注于游戏智能、少儿趣味编程两大领域。
模拟环境
相信大家对于这个游戏并不陌生，我们需要控制一只小鸟向前飞行，只有飞翔、下落两种操作，小鸟每穿过一根柱子，总分就会增加。由于柱子是高低不平的，所以需要想尽办法躲避它们。一旦碰到了柱子，或者碰到了上、下边缘，都会导致 game-over。下图展示了未经训练的小笨鸟，可以看到，他处于 人工智障 的状态，经常撞柱子或者撞草地：
▲ 未经训练的小笨鸟
先简要分析一下环境 Environment 的主要代码。
BirdEnv.py 继承自 gym.Env，实现了 init、reset、reward、render 等标准接口。init 函数，用于加载图片、声音等外部文件，并初始化得分、小鸟位置、上下边缘、水管位置等环境信息：
def __init__(self):
if not hasattr(self,'IMAGES'):
print('InitGame!')
self.beforeInit()
self.score = self.playerIndex = self.loopIter = 0
self.playerx = int(SCREENWIDTH * 0.3)
self.playery = int((SCREENHEIGHT - self.PLAYER_HEIGHT) / 2.25)
self.baseShift = self.IMAGES['base'].get_width() - self.BACKGROUND_WIDTH
newPipe1 = getRandomPipe(self.PIPE_HEIGHT)
newPipe2 = getRandomPipe(self.PIPE_HEIGHT)
#...other code
step 函数，执行两个动作，0 表示不采取行动（小鸟会自动下落），1 表示飞翔；step 函数有四个返回值，image_data 表示当前状态，也就是游戏画面，reward 表示本次 step 的即时奖励，terminal 表示是否是吸收状态，{} 表示其他信息：
def step(self, input_action=0):
pygame.event.pump()
reward = 0.1
terminal = False
if input_action == 1:
if self.playery > -2 * self.PLAYER_HEIGHT:
self.playerVelY = self.playerFlapAcc
self.playerFlapped = True
#...other code
image_data=self.render()
return image_data, reward, terminal,{}
奖励 reward；初始奖励是 +0.1，表示小鸟向前飞行一小段距离；穿过柱子，奖励 +1；撞到柱子，奖励为 -1，并且到达 terminal 状态：
#飞行一段距离,奖励+0.1
reward = 0.1
#...other code
playerMidPos = self.playerx + self.PLAYER_WIDTH / 2
for pipe in self.upperPipes:
pipeMidPos = pipe['x'] + self.PIPE_WIDTH / 2
#穿过一个柱子奖励加1
if pipeMidPos <= playerMidPos < pipeMidPos + 4:
self.score += 1
reward = self.reward(1)
#...other code
if isCrash:
#撞到边缘或者撞到柱子,结束,并且奖励为-1
terminal = True
reward = self.reward(-1)
reward 函数，返回即时奖励 r：
def reward(self,r):
return r
reset 函数，调用 init，并执行一次飞翔操作，返回 observation,reward,isOver：
def reset(self,mode='train'):
self.__init__()
self.mode=mode
action0 = 1
observation, reward, isOver,_ = self.step(action0)
return observation,reward,isOver
render 函数，渲染游戏界面，并返回当前画面：
def render(self):
image_data = pygame.surfarray.array3d(pygame.display.get_surface())
pygame.display.update()
self.FPSCLOCK.tick(FPS)
return image_data
至此，强化学习所需的状态、动作、奖励等功能均定义完毕。接下来简单推导一下 DQN (Deep-Q-Network) 算法的原理。
DQN的发展过程
DQN 的进化历史可谓源远流长，从最开始 Bellman 在 1956 年提出的动态规划，到后来 Watkins 在 1989 年提出的的Q-learning，再到DeepMind的 Nature-2015 稳定版，最后到 Dueling DQN、Priority Replay Memory、Parameter Noise 等优化算法，横跨整整一个甲子，凝聚了无数专家、教授们的心血。如今的我们站在先贤们的肩膀上，从以下角度逐步分析：
-
贝尔曼（最优）方程与 VQ 树
-
Q-learning
-
参数化逼近
-
DQN 算法框架
贝尔曼 (最优) 方程与VQ树
我们从经典的表格型强化学习（Tabular Reinforcement Learning）开始，回忆一下马尔可夫决策（MDP）过程，MDP 可由五元组 (S,A,P,R,γ) 表示，其中：
-
S 状态集合，维度为 1×|S|
-
A 动作集合，维度为 1×|A|
-
P 状态转移概率矩阵，经常写成
，其维度为 |S|×|A|×|S|
-
R 回报函数，如果依赖于状态值函数 V，维度为 1×|S|，如果依赖于状态-动作值函数 Q，则维度为 |S|×|A|
-
γ 折扣因子，用来计算带折扣的累计回报 G(t)，维度为 1
S、A、R、γ 均不难理解，可能部分同学对 有疑问——既然 S 和 A 确定了，下一个状态 S' 不是也确定了吗？为什么会有概率转移矩阵呢？
其实我初学的时候也曾经被这个问题困扰过，不妨通过如下两个例子以示区别：
1. 恒等于 1.0 的情况。如图 1 所示，也就是上一次我们在策略梯度算法中所使用的迷宫，假设机器人处于左上角，这时候你命令机器人向右走，那么他转移到红框所示位置的概率就是 1.0，不会有任何异议：
▲ 图1. 迷宫寻宝 2.
不等于 1.0 的情况。假设现在我们下一个飞行棋，如图 2 所示。有两种骰子，第一种是普通的正方体骰子，可以投出 1~6，第二种是正四面体的骰子，可以投出 1~4。现在飞机处于红框所示的位置，现在我们选择 投掷第二种骰子 这个动作，由于骰子本身具有均匀随机性，所以飞机转移到终点的概率仅仅是 0.25。这就说明，在某些环境中，给定 S、A 的情况下，转移到具体哪一个 S' 其实是不确定的：
▲ 图2. 飞行棋
除了经典的五元组外，为了研究长期回报，还经常加入三个重要的元素，分别是：
-
策略 π(a∣s)，维度为 |S|×|A|
-
状态值函数
，维度为 1×|S|，表示当智能体采用策略 π 时，累积回报在状态 s 处的期望值：
▲
图3 状态值函数
-
状态-行为值函数
，也叫状态-动作值函数，维度为 |S|×|A|，表示当智能体采取策略 π 时，累计回报在状态 s 处并执行动作 a 时的期望值：
图4. 状态-行为值函数
知道了 π、v、q 的具体含义后，我们来看一个重要的概念，也就是 V、Q 的递归展开式。
学过动态规划的同学都知道，动态规划本质上是一个 bootstrap（自举）问题，它包含 最优子结构 与 重叠子问题 两个性质，也就是说，通常有两种方法解决动态规划：
-
将总问题划分为 k 个子问题，递归求解这些子问题，然后将子问题进行合并，得到总问题的最优解；对于重复的子问题，我们可以将他们进行缓存（记忆搜索 MemorySearch，请回忆 f(n)=f(n-1)+f(n-2) 这个递归程序）；
-
计算最小的子问题，合并这些子问题产生一个更大的子问题，不断的自底向上计算，随着子问题的规模越来越大，我们会得到最终的总问题的最优解（打表 DP，请回忆杨辉三角中的 dp[i-1,j-1]+dp[i-1,j]=dp[i,j]）。
这两种切题技巧，对于有过 ACM 或者 LeetCode 刷题经验的同学，可以说是老朋友了，那么能否把以上思想迁移到强化学习呢？答案是肯定的！
分别考虑 v、q 的展开式：
-
处在状态 s 时，由于有策略 π 的存在，故可以把状态值函数 v 展开成以下形式：
▲ 图5. v展开成q
这个公式表示：在状态 s 处的值函数，等于采取策略 π 时，所有状态-行为值函数的总和。
-
处在状态 s、并执行动作 a，可以把状态-行为值函数 q 展开成以下形式：
▲ 图6. q展开成v
这个公式表示：在状态 s 采用动作 a 的状态行为值函数，等于回报加上后序可能产生的的状态值函数的总和。
我们可以看到：v 可以展开成 q，同时 q 也可以展开成 v。
所以可以用以下 v、q 节点相隔的树来表示以上两个公式，这颗树比纯粹的公式更容易理解，我习惯上把它叫做 V-Q 树 ，它显然是一个递归的结构：
▲ 图7. V-Q树
注意画红圈中的两个节点，体现了 重叠子问题 特性。如何理解这个性质呢？不妨回忆一下上文提到的飞行棋，假设飞机处在起点位置 1，那么无论投掷 1 号骰子还是 2 号骰子，都是有机会可以到达位置 3 的，这就是重叠子问题的一个例子。
有了这棵递归树之后，就不难推导出 v 和 v'，以及 q 和 q' 自身的递归展开式：
▲ 图8. 状态值函数v自身的递归展开式
▲ 图9. 状态-行为值函数q自身的递归展开式
其实无论是 v 还是 q，都拥有最优子结构特性。不妨利用反证法加以证明：
假设要求总问题 V(s) 的最优解，那么它包含的每个子问题 V(s') 也必须是最优解；否则，如果某个子问题 V(s') 不是最优，那么必然有一个更优的子问题 V'(s') 存在，使得总问题 V'(s) 比原来的总问题 V(s) 更优，与我们的假设相矛盾，故最优子结构性质得证，q(s) 的最优子结构性质同理。
计算值函数的目的是为了构建学习算法得到最优策略，每个策略对应着一个状态值函数，最优策略自然也对应着最优状态值函数，故而定义如下两个函数：
-
最优状态值函数
，表示在所有策略中最大的值函数，即：
▲ 图10. 最优状态值函数
-
最优状态-行为值函数
，表示在所有策略中最大的状态-行为值函数：
▲ 图11. 最优状态-行为值函数
结合上文的递归展开式和最优子结构性质，可以得到 v 与 q 的 贝尔曼最优方程 ：
▲ 图12. v的贝尔曼最优方程
▲ 图13. q的贝尔曼最优方程
重点理解 第二个公式 ，也就是关于 q 的贝尔曼最优方程，它是今天的主角Q-learning以及 DQN 的理论基础。
有了贝尔曼最优方程，我们就可以通过纯粹贪心的策略来确定 π，即：仅仅把最优动作的概率设置为 1，其他所有非最优动作的概率都设置为 0。这样做的好处是：当算法收敛的时候，策略 π(a|s) 必然是一个 one-hot 型的矩阵。用数学公式表达如下：
▲ 图14. 算法收敛时候的策略π
强化学习中的动态规划方法实质上是一种 model-based（模型已知）方法，因为 MDP 五元组是已知的，特别是状态转移概率矩阵 是已知的。
也就是说，所有的环境信息对于我们来说是 100% 完备的，故而可以对整个解空间树进行全局搜索，下图展示了动态规划方法的示意图，在确定根节点状态 S(t) 的最优值的时候，必须遍历他所有的 S(t+1) 子节点并选出最优解：
▲ 图15.动态规划方法的解空间搜索过程
不过，和传统的 刷题动态规划 略有不同，强化学习往往是利用值迭代（Value Iteration）、策略迭代（Policy Iteration）、策略改善（Policy Improve）等方式使 v、q、π 等元素达到收敛状态，当然也有直接利用矩阵求逆计算解析解的方法，有兴趣的同学可以参考相关文献，这里不再赘述。
Q-learning
上文提到的动态规划方法是一种 model-based 方法，仅仅适用于 已知的情况。若状态转移概率矩阵未知，model-free（无模型）方法就派上用场了，上一期的 MCPG 算法就是一种典型的 model-free 方法。它搜索解空间的方式更像是 DFS（深度优先搜索），而且一条道走到黑，没有指针回溯的操作，下图展示了蒙特卡洛算法的求解示意图：
▲ 图16. MC系列方法的解空间搜索过程
虽然每次只能走一条分支，但随机数发生器会帮助算法遍历整个解空间，再通过大量的迭代，所有节点也会收敛到最优解。
不过，MC 类方法有两个小缺点：
1. 使用 作为训练标签，其本身就是值函数准确的无偏估计。但是，这也正是它的缺点，因为 MC 方法会经历很多随机的状态和动作，使得每次得到的 G(t) 随机性很大，具有很高的方差。
2. 由于采用的是 一条道走到黑 的方式从根节点遍历到叶子节点，所以必须要等到 episode 结束才能进行训练，而且每轮 episode 产生的数据只训练一次，每轮 episode 产生数据的 batch-size 还不一定相同，所以在训练过程中，MC 方法的 loss 函数（或者 TD-Error）的波动幅度较大，而数据利用效率不高。
那么，能否边产生数据边训练呢？可以！时序差分（Temporal-Difference-Learning，简称 TD）算法应运而生了。
时序差分学习是模拟（或者经历）一段序列，每行动一步（或者几步）就根据新状态的价值估计当前执行的状态价值。大致可以分为两个小类：
1. TD(0) 算法，只向后估计一个 step。其值函数更新公式为：
▲ 图17. TD(0)算法的更新公式
其中，α 为学习率， 称为 TD 目标，MC 方法中的 G(t) 也可以叫做 TD 目标，
称为 TD-Error，当模型收敛时，TD-Error 会无限接近于 0。
2. Sarsa(λ) 算法，向后估计 n 步，n 为有限值，还有一个衰减因子 λ。其值函数的更新公式为：
▲ 图18. Sarsa(λ)算法的更新公式
▲ 图19. 的计算方法
与 MC 方法相比，TD 方法只用到了一步或者有限步随机状态和动作，因此它是一个有偏估计。不过，由于 TD 目标的随机性比 MC 方法的 G(t) 要小，所以方差也比 MC 方法小的多，值函数的波动幅度较小，训练比较稳定。
看一下 TD 方法的解空间搜索示意图，红框表示 TD(0)，蓝框表示 Sarsa(λ)。虽然每次估计都有一定的偏差，但随着算法的不断迭代，所有的节点也会收敛到最优解：
▲ 图20. TD方法的解空间搜索过程
有了 TD 的框架，既然我们要求状态值函数 v、状态-行为值函数 q 的最优解，那么是否能直接选择最优的 TD 目标作为 Target 呢？答案是肯定的，这也是 Q-Learning 算法的基本思想，其公式如下所示：
▲ 图21.Q-learning算法的学习公式
其中，动作 a 由 ε-greedy 策略选出，从而在状态 s 处执行 a 之后产生了另一个状态 s'，接下来选出状态 s' 处最大的状态-行为值函数 q(s',a')，这样，TD 目标就可以确定为 R+γmax[a′]Q(s′,a′)。这种思想很像贪心算法中的 总是选择在当前看来最优的决策 ，它一开始可能会得到一个局部最优解，不过没关系，随着算法的不断迭代，整个解空间树也会收敛到全局最优解。
以下是Q-learning算法的伪代码，和 on-policy 的 MC 方法对应，它是一种 off-policy（异策略）方法：
#define maxEpisode=65535 //定义最大迭代轮数
#define maxStep=1024 //定义每一轮最多走多少步
initialize Q_table[|S|,|A|] //初始化Q矩阵
for i in range(0,maxEpisode):
s=env.reset() //初始化状态s
for j in range(0,maxStep):
//用ε-greedy策略在s行选一个动作a
choose action a using ε-greedy from Q_table[s]
s',R,terminal,_=env.step(a) //执行动作a,得到下一个状态s',奖励R，是否结束terminal
max_s_prime_action=np.max(Q_table[s',:]) //选s'对应的最大行为值函数
td=R+γ*max_s_prime_action //计算TD目标
Q_table[s,a]= Q_table[s,a]+α*(td-Q_table[s,a]) //学习Q(s,a)的值
s=s' //更新s，注意，和sarsa算法不同，这里的a不用更新
if terminal:
break
Q-learning是一种优秀的算法，不仅简单直观，而且平均速度比 MC 快。在 DRL 未出现之前，它在强化学习中的地位，差不多可以媲美 SVM 在机器学习中的地位。
参数化逼近
有了Q-learning算法，是否就能一招吃遍天下鲜了呢？答案是否定的，我们看一下它存在的问题。
上文所提到的，无论是 DP、MC 还是 TD，都是基于表格（tabular）的方法，当状态空间比较小的时候，计算机内存完全可以装下,表格式型强化学习是完全适用的。但遇到高阶魔方（三阶魔方的总变化数是 ）、围棋（
）这类问题时，S、V、Q、P 等表格均会出现维度灾难，早就超出了计算机内存甚至硬盘容量。这时候，参数化逼近方法就派上用场了。
所谓参数化逼近，是指值函数可以由一组参数θ 来近似，如Q-learning中的 Q(s,a) 可以写成 Q(s,a|θ) 的形式。这样，不但降低了存储维度，还便于做一些额外的特征工程，而且 θ 更新的同时，Q(s,a|θ) 会进行整体更新，不仅避免了过拟合情况，还使得模型的泛化能力更强。
既然有了可训练参数，我们就要研究损失函数了，Q-Learning 的损失函数是什么呢？
先看一下 Q-Learning 的优化目标——使得 TD-Error 最小：
▲ 图22. Q-Learning的优化目标
加入参数θ 之后，若将 TD 目标 作为标签 target，将 Q(s,a) 作为模型的输出 y，则问题转化为：
▲ 图23. 带参数的优化目标
这是我们所熟悉的监督学习中的回归问题，显然 loss 函数就是 mse，故而可以用梯度下降算法最小化 loss，从而更新参数θ：
▲ 图24. loss函数的梯度下降公式
注意到，TD 目标是标签，所以 Q(s',a'|θ) 中的 θ 是不能更新的，这种方法并非完全的梯度法，只有部分梯度，称为半梯度法，这是 NIPS-2013 的雏形。
后来，DeepMind在 Nature-2015 版本中将 TD 网络单独分开，其参数为 θ'，它本身并不参与训练，而是每隔固定步数将值函数逼近的网络参数θ 拷贝给 θ'，这样保证了 DQN 的训练更加稳定：
▲ 图25. 含有目标网络参数θ'的梯度下降公式 至此，DQN 的 Loss 函数、梯度下降公式推导完毕。
DQN算法框架
接下来，还要解决两个问题——数据从哪里来？如何采集？
针对以上两个问题，DeepMind团队提出了深度强化学习的全新训练方法：经验回放（experience replay）。
在强化学习过程中，智能体将数据存储到一个 ReplayBuffer 中（任何一种集合，可以是哈希表、数组、队列，也可以是数据库），然后利用均匀随机采样的方法从 ReplayBuffer 中抽取数据，这些数据就可以进行 Mini-Batch-SGD，这样就打破了数据之间的相关性，使得数据之间尽量符合独立同分布原则。
DQN 的基本网络结构如下：
▲ 图26. DQN的基本网络结构
要特别注意：
1. 与参数θ 做线性运算 (wx+b) 的仅仅是输入状态 s，这一步没有动作 a 的参与；
2. output_1 的维度为 |A|，表示神经网络Q(s,θ) 的输出；
3. 输入动作 a 是 one-hot，与 output_1 作哈达马积后产生的 output_2 是一个数字，作为损失函数中的 Q(s,a|θ)，也就是 y。
以下是 DQN 算法的伪代码：
#Deep-Q-Network,Nature 2015 version
#定义为一个双端队列D，作为经验回放区域，最大长度为max_size
Initialize replay_memory D as a deque,mas_size=50000
#初始化状态-行为值函数Q的<mark data-type="technologies" data-id="72b0bcc0-d8f9-4edd-919f-fa7c2560388c">神经网络</mark>，权值随机
Initialize action-value function Q(s,a|θ) as Neural Network with random-weights-initializer
#初始化TD目标网络，初始权值和θ相等
Initialize target action-value function Q(s,a|θ) with weights θ'=θ
#迭代max_episode个轮次
for episode in range(0,max_episode=65535):
#重置环境env，得到初始状态s
s=env.reset()
#循环事件的每一步，最多迭代max_step_limit个step
for step in range(0,max_step_limit=1024):
#通过ε-greedy的方式选出一个动作action
With probability ε select a random action a or select a=argmax(Q(s,θ))
#在env中执行动作a，得到下一个状态s'，奖励R,是否终止terminal
s',R,terminal,_=env.step(a)
#将五元组(s,a,s',R,terminal)压进队尾
D.addLast(s,a,s',R,terminal)
#如果队列满，弹出队头元素
if D.isFull():
D.removeFirst()
#更新状态s
s=s'
#从队列中进行随机采样
batch_experience[s,a,s',R,terminal]=random_select(D,batch_size=32)
#计算TD目标
target = R + γ*(1- terminal) * np.max(Q(s',θ'))
#对loss函数执行Gradient-decent，训练<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>θ
θ=θ+α*(target-Q(s,a|θ))▽Q(s,a|θ)
#每隔C步，同步θ与θ'的权值
Every C steps set θ'=θ
#是否结束
if terminal：
break
我们玩的游戏 Flappy-Bird，它的输入是一帧一帧的图片，所以，经典的 Atari-CNN 模型就可以派上用场了：
▲ 图27. Atari游戏的CNN网络结构
网络的输入是被处理成灰度图的最近 4 帧 84*84 图像（4 是经验值），经过若干 CNN 和 FullyConnect 后，输出各个动作所对应的状态-行为值函数 Q。以下是每一层的具体参数，由于 atari 游戏最多有 18 个动作，所以最后一层的维度是 18：
▲ 图28.神经网络的具体参数
至此，理论部分推导完毕。下面，我们分析一下 PARL 中的 DQN 部分的源码，并实现 Flappy-Bird 的游戏智能。
代码实现
依次分析 env、model、algorithm、agent、replay_memory、train 等模块。
1. BirdEnv.py，环境；上文已经分析过了。
2. BirdModel.py，神经网络模型；使用三层 CNN+两层 FC，CNN 的 padding 方式都是 valid，最后输出状态-行为值函数 Q，维度为 |A|。注意输入图片归一化，并按照官方模板填入代码：
class BirdModel(Model):
def __init__(self, act_dim):
self.act_dim = act_dim
#padding方式为valid
p_valid=0
self.conv1 = layers.conv2d(
num_filters=32, filter_size=8, stride=4, padding=p_valid, act='relu')
self.conv2 = layers.conv2d(
num_filters=64, filter_size=4, stride=2, padding=p_valid, act='relu')
self.conv3 = layers.conv2d(
num_filters=64, filter_size=3, stride=1, padding=p_valid, act='relu')
self.fc0=layers.fc(size=512)
self.fc1 = layers.fc(size=act_dim)
def value(self, obs):
#输入归一化
obs = obs / 255.0
out = self.conv1(obs)
out = self.conv2(out)
out = self.conv3(out)
out = layers.flatten(out, axis=1)
out = self.fc0(out)
out = self.fc1(out)
return out
3. dqn.py，算法层； 官方仓库已经提供好了，我们无需自己再写，直接复用算法库（parl.algorithms）里边的 DQN 算法即可。
简单分析一下 DQN 的源码实现。
define_learn 函数，用于神经网络的学习。接收 [状态 obs, 动作 action, 即时奖励 reward, 下一个状态 next_obs, 是否终止 terminal] 这样一个五元组，代码实现如下：
#根据obs以及<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>θ计算状态-行为值函数pred_value，对应<mark data-type="technologies" data-id="5796887d-ff61-4bb5-8cb1-201201bd42e9">伪代码</mark>中的Q(s,θ) pred_value = self.model.value(obs) #根据next_obs以及<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>θ'计算目标网络的状态-行为值函数next_pred_value，对应<mark data-type="technologies" data-id="5796887d-ff61-4bb5-8cb1-201201bd42e9">伪代码</mark>中的Q(s',θ') next_pred_value = self.target_model.value(next_obs) #选出next_pred_value的最大值best_v，对应<mark data-type="technologies" data-id="5796887d-ff61-4bb5-8cb1-201201bd42e9">伪代码</mark>中的np.max(Q(s',θ'))；注意θ'不参与训练，所以要stop_gradient best_v = layers.reduce_max(next_pred_value, dim=1) best_v.stop_gradient = True #计算TD目标 target = reward + (1.0 - layers.cast(terminal, dtype='float32')) * self.gamma * best_v #输入的动作action与pred_value作哈达玛积，选出要评估的状态-行为值函数pred_action_value，对应<mark data-type="technologies" data-id="5796887d-ff61-4bb5-8cb1-201201bd42e9">伪代码</mark>中的 Q(s,a|θ) action_onehot = layers.one_hot(action, self.action_dim) action_onehot = layers.cast(action_onehot, dtype='float32') pred_action_value = layers.reduce_sum(layers.elementwise_mul(action_onehot, pred_value), dim=1) #mse以及<mark data-type="technologies" data-id="847e8a6a-524c-4d34-a50e-b17cc5dd84d4">梯度下降</mark>，对应<mark data-type="technologies" data-id="5796887d-ff61-4bb5-8cb1-201201bd42e9">伪代码</mark>中的θ=θ+α*(target-Q(s,a|θ))▽Q(s,a|θ) cost = layers.square_error_cost(pred_action_value, target) cost = layers.reduce_mean(cost) optimizer = fluid.optimizer.Adam(self.lr, epsilon=1e-3) optimizer.minimize(cost)
sync_target 函数用于同步网络参数：
def sync_target(self, gpu_id):
""" sync parameters of self.target_model with self.model
"""
self.model.sync_params_to(self.target_model, gpu_id=gpu_id)
4. BirdAgent.py，智能体。其中，build_program 函数封装了 algorithm 中的 define_predict 和 define_learn，sample 函数以 ε-greedy 策略选择动作，predict 函数以 100% 贪心的策略选择 argmax 动作，learn 函数接收五元组 (obs, act, reward, next_obs, terminal) 完成学习功能，这些函数和 Policy-Gradient 的写法类似。
除了这些常用功能之外，由于游戏的训练时间比较长，所以附加了两个函数，save_params 用于保存模型，load_params 用于加载模型：
#保存模型
def save_params(self, learnDir,predictDir):
fluid.io.save_params(
executor=self.fluid_executor,
dirname=learnDir,
main_program=self.learn_programs[0])
fluid.io.save_params(
executor=self.fluid_executor,
dirname=predictDir,
main_program=self.predict_programs[0])
#加载模型
def load_params(self, learnDir,predictDir):
fluid.io.load_params(
executor=self.fluid_executor,
dirname=learnDir,
main_program=self.learn_programs[0])
fluid.io.load_params(
executor=self.fluid_executor,
dirname=predictDir,
main_program=self.predict_programs[0])
另外，还有四个超参数，可以进行微调：
#每训练多少步更新target网络,超<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>可调 self.update_target_steps = 5000 #初始探索概率ε,超<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>可微调 self.exploration = 0.8 #每步探索的衰减程度,超<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>可微调 self.exploration_dacay=1e-6 #最小探索概率,超<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>可微调 self.min_exploration=0.05
5. replay_memory.py，经验回放单元。双端队列 _context 是一个滑动窗口，用来记录最近 3 帧（再加上新产生的 1 帧就是 4 帧）；state、action、reward 等用 numpy 数组存储，因为 numpy 的功能比双端队列更丰富，max_size 表示 replay_memory 的最大容量：
self.state = np.zeros((self.max_size, ) + state_shape, dtype='int32') self.action = np.zeros((self.max_size, ), dtype='int32') self.reward = np.zeros((self.max_size, ), dtype='float32') self.isOver = np.zeros((self.max_size, ), dtype='bool') #_context是一个滑动窗口,长度永远保持3 self._context = deque(maxlen=context_len - 1)
其他的 append、recent_state、sample_batch 等函数并不难理解，都是基于 numpy 数组的进一步封装，略过一遍即可看懂。
6. Train_Test_Working_Flow.py，训练与测试，让环境 evn 和智能体 agent 进行交互。最重要的就是 run_train_episode 函数，体现了 DQN 的主要逻辑，重点分析注释部分与 DQN伪代码的对应关系，其他都是编程细节：
#训练一个episode
def run_train_episode(env, agent, rpm):
global trainEpisode
global meanReward
total_reward = 0
all_cost = []
#重置环境
state,_, __ = env.reset()
step = 0
#循环每一步
while True:
context = rpm.recent_state()
context.append(resizeBirdrToAtari(state))
context = np.stack(context, axis=0)
#用ε-greedy的方式选一个动作
action = agent.sample(context)
#执行动作
next_state, reward, isOver,_ = env.step(action)
step += 1
#存入replay_buffer
rpm.append(Experience(resizeBirdrToAtari(state), action, reward, isOver))
if rpm.size() > MEMORY_WARMUP_SIZE:
if step % UPDATE_FREQ == 0:
#从replay_buffer中随机采样
batch_all_state, batch_action, batch_reward, batch_isOver = rpm.sample_batch(batchSize)
batch_state = batch_all_state[:, :CONTEXT_LEN, :, :]
batch_next_state = batch_all_state[:, 1:, :, :]
#执行SGD,训练<mark data-type="technologies" data-id="2e982b73-88e2-41e8-a430-f7ae5a9af4bf">参数</mark>θ
cost=agent.learn(batch_state,batch_action, batch_reward,batch_next_state, batch_isOver)
all_cost.append(float(cost))
total_reward += reward
state = next_state
if isOver or step>=MAX_Step_Limit:
break
if all_cost:
trainEpisode+=1
#以滑动平均的方式打印平均奖励
meanReward=meanReward+(total_reward-meanReward)/trainEpisode
print('\n trainEpisode:{},total_reward:{:.2f}, meanReward:{:.2f} mean_cost:{:.3f}'\
.format(trainEpisode,total_reward, meanReward,np.mean(all_cost)))
return total_reward, step
除了主要逻辑外，还有一些常见的优化手段，防止训练过程中出现 trick：
#充满replay-memory,使其达到warm-up-size才开始训练 MEMORY_WARMUP_SIZE = MEMORY_SIZE//20 ##一轮episode最多执行多少次step，不然小鸟会无限制的飞下去,相当于gym.env中的_max_episode_steps属性 MAX_Step_Limit=int(1<<12) #用一个双端队列记录最近16次episode的平均奖励 avgQueue=deque(maxlen=16)
另外，还有其他一些超参数，比如学习率LEARNING_RATE、衰减因子 GAMMA、记录日志的频率 log_freq 等等，都可以进行微调：
#衰减因子 GAMMA = 0.99 #<mark data-type="technologies" data-id="444ad8d1-7262-46c9-94b7-fe0aa9227006">学习率</mark> LEARNING_RATE = 1e-3 * 0.5 #记录日志的频率 log_freq=10
main 函数在这里，输入 train 训练网络，输入 test 进行测试：
if __name__ == '__main__':
print("train or test ?")
mode=input()
print(mode)
if mode=='train':
train()
elif mode=='test':
test()
else:
print('Invalid input!')
这是模型在我本机训练的输出日志，大概 3300 个 episode、50 万步之后，模型就收敛了：
▲ 图29. 模型训练的输出日志
平均奖励：
▲ 图30. 最近16次平均奖励变化曲线
各位同学可以试着调节超参数，或者修改网络模型，看看能不能遇到一些坑？哪些因素会影响训练效率？如何提升收敛速度？
接下来就是见证奇迹的时刻，当初懵懂的小笨鸟，如今已 修炼成精 了！
▲ 训练完的FlappyBird
观看 4 分钟完整版： https://www.bilibili.com/video/av49282860/
Github源码 ： https://github.com/kosoraYintai/PARL-Sample/tree/master/flappy_bird
参考文献
[1] Bellman, R.E. & Dreyfus, S.E. (1962). Applied dynamic programming. RAND Corporation.
[2] Sutton, R.S. (1988). Learning to predict by the methods of temporal difference.Machine Learning, 3, pp. 9–44.
[3] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, et al., "Human-level control through deep reinforcement learning," Nature, vol. 518(7540), pp. 529-533, 2015.
[4] https://leetcode.com/problems/climbing-stairs/
[5] https://leetcode.com/problems/pascals-triangle-ii/
[6] https://github.com/yenchenlin/DeepLearningFlappyBird
[7] https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持 码农网
猜你喜欢:
- 图算法|Dijkstra算法python实现
- 算法：经典排序算法的 Go 实现
- js实现数据结构及算法之排序算法
- 算法 - 06 | 链表（上）：如何实现LRU缓存淘汰算法?
- Twitter雪花算法SnowFlake算法的java实现
- js实现多种排序算法（算法导论第二章）
本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。
Mathematica Cookbook
Sal Mangano / O'Reilly Media / 2009 / GBP 51.99
As the leading software application for symbolic mathematics, Mathematica is standard in many environments that rely on math, such as science, engineering, financial analysis, software development, an......一起来看看 《Mathematica Cookbook》 这本书的介绍吧!
