dqn_dqn算法 - CSDN
dqn 订阅
DQN,网络流行语,来自日语发音的缩写“ドキュン”(读作dokyun,缩写为dqn),贬义词,指横蛮无理、爱用暴力甚至反社会的人,或指缺乏常识、学历低下的人,如奇葩不良少年等。 展开全文
DQN,网络流行语,来自日语发音的缩写“ドキュン”(读作dokyun,缩写为dqn),贬义词,指横蛮无理、爱用暴力甚至反社会的人,或指缺乏常识、学历低下的人,如奇葩不良少年等。
信息
性    质
网络流行语
中文名
DQN
DQN词语来源
起源于朝日电视台帮助委托人寻人的节目《目撃!ドキュン》,但登场的“不良少年”过多。后来日本网民用dqn嘲笑低学历者。2ch网站上的变体为“ドキュソ”,谐音日语“大便”,更加贬义。 [1] 
收起全文
精华内容
参与话题
  • 深度强化学习——DQN

    千次阅读 2017-12-11 19:48:05
    一、DRL 原因:在普通的Q-learning中,当状态和动作空间是离散且维数不高时可使用Q-Table储存每个状态动作对的Q值,而当状态和动作空间是高维连续时,使用Q-Table不现实。 通常做法是把Q-Table的更新问题变成...

    一、DRL

    原因:在普通的Q-learning中,当状态和动作空间是离散且维数不高时可使用Q-Table储存每个状态动作对的Q值,而当状态和动作空间是高维连续时,使用Q-Table不现实。

    通常做法是把Q-Table的更新问题变成一个函数拟合问题,相近的状态得到相近的输出动作。如下式,通过更新参数 θ 使Q函数逼近最优Q值 

    Q(s,a;θ)Q(s,a)
    而深度神经网络可以自动提取复杂特征,因此,面对高维且连续的状态使用深度神经网络最合适不过了。

    DRL是将深度学习(DL)与强化学习(RL)结合,直接从高维原始数据学习控制策略。而DQN是DRL的其中一种算法,它要做的就是将卷积神经网络(CNN)和Q-Learning结合起来,CNN的输入是原始图像数据(作为状态State),输出则是每个动作Action对应的价值评估Value Function(Q值)。

    二、DL与RL结合的问题

    1. DL需要大量带标签的样本进行监督学习;RL只有reward返回值,而且伴随着噪声,延迟(过了几十毫秒才返回),稀疏(很多State的reward是0)等问题;
    2. DL的样本独立;RL前后state状态相关;
    3. DL目标分布固定;RL的分布一直变化,比如你玩一个游戏,一个关卡和下一个关卡的状态分布是不同的,所以训练好了前一个关卡,下一个关卡又要重新训练;
    4. 过往的研究表明,使用非线性网络表示值函数时出现不稳定等问题。

    三、DQN解决问题方法

    1. 通过Q-Learning使用reward来构造标签(对应问题1)
    2. 通过experience replay(经验池)的方法来解决相关性及非静态分布问题(对应问题2、3)
    3. 使用一个CNN(MainNet)产生当前Q值,使用另外一个CNN(Target)产生Target Q值(对应问题4)

    1、构造标签

    前面提到DQN中的CNN作用是对在高维且连续状态下的Q-Table做函数拟合,而对于函数优化问题,监督学习的一般方法是先确定Loss Function,然后求梯度,使用随机梯度下降等方法更新参数。DQN则基于Q-Learning来确定Loss Function。

    Q-Learning 
    有关RL的基础知识不再啰嗦,直接看Q-Learning的更新公式:

    Q(s,a)=Q(s,a)+α(r+γmaxaQ(s,a)Q(s,a))

    而DQN的Loss Function为
    L(θ)=E[(TargetQQ(s,a;θ))2]

    其中 θ 是网络参数,目标为
    TargetQ=r+γmaxaQ(s,a;θ)

    显然Loss Function是基于Q-Learning更新公式的第二项确定的,两个公式意义相同,都是使当前的Q值逼近Target Q值。

    接下来,求 L(θ) 关于 θ 的梯度,使用SGD等方法更新网络参数 θ

    2、经验池(experience replay)

    经验池的功能主要是解决相关性及非静态分布问题。具体做法是把每个时间步agent与环境交互得到的转移样本 (st,at,rt,st+1) 储存到回放记忆单元,要训练时就随机拿出一些(minibatch)来训练。(其实就是将游戏的过程打成碎片存储,训练时随机抽取就避免了相关性问题)

    3、目标网络

    在Nature 2015版本的DQN中提出了这个改进,使用另一个网络(这里称为TargetNet)产生Target Q值。具体地,Q(s,a;θi) 表示当前网络MainNet的输出,用来评估当前状态动作对的值函数;Q(s,a;θi) 表示TargetNet的输出,代入上面求 TargetQ 值的公式中得到目标Q值。根据上面的Loss Function更新MainNet的参数,每经过N轮迭代,将MainNet的参数复制给TargetNet。

    引入TargetNet后,再一段时间里目标Q值使保持不变的,一定程度降低了当前Q值和目标Q值的相关性,提高了算法稳定性。

    四、DQN算法流程

    1、网络模型

    这里写图片描述

    输入的是被处理成灰度图的最近4帧 84×84 图像,经过几个卷积层(没有池化层)后接两个全连接层,输出是所有动作的Q值。

    2、算法伪代码

    NIPS 2013版 
    这里写图片描述

    Nature 2015版 
    这里写图片描述

    2、算法流程图(2015版)

    主要流程图 
    这里写图片描述

    Loss Function 的构造 
    这里写图片描述

    五、总结

    DQN是第一个将深度学习模型与强化学习结合在一起从而成功地直接从高维的输入学习控制策略。

    创新点:

    1. 基于Q-Learning构造Loss Function(不算很新,过往使用线性和非线性函数拟合Q-Table时就是这样做)。
    2. 通过experience replay(经验池)解决相关性及非静态分布问题;
    3. 使用TargetNet解决稳定性问题。

    优点:

    1. 算法通用性,可玩不同游戏;
    2. End-to-End 训练方式;
    3. 可生产大量样本供监督学习。

    缺点:

    1. 无法应用于连续动作控制;
    2. 只能处理只需短时记忆问题,无法处理需长时记忆问题(后续研究提出了使用LSTM等改进方法);
    3. CNN不一定收敛,需精良调参。

    参考文献 
    [1]Playing Atari with Deep Reinforcement Learning 
    [2]Human-level control through deep reinforcement learning



    展开全文
  • 强化学习—DQN算法原理详解

    万次阅读 多人点赞 2019-01-23 11:39:06
    强化学习—DQN算法原理详解 一、 概述 强化学习算法可以分为三大类:value based, policy based 和 actor critic。常见的是以DQN为代表的value based算法,这种算法中只有一个值函数网络,没有policy网络,以及以...

    强化学习—DQN算法原理详解

    一、 概述

    强化学习算法可以分为三大类:value based, policy based 和 actor critic。常见的是以DQN为代表的value based算法,这种算法中只有一个值函数网络,没有policy网络,以及以DDPG,TRPO为代表的actor-critic算法,这种算法中既有值函数网络,又有policy网络。

    说到DQN中有值函数网络,这里简单介绍一下强化学习中的一个概念,叫值函数近似。在基本概念这篇中有讲过,一个state action pair (s,a)(s,a)对应一个值函数Q(s,a)Q(s,a)。理论上对于任意的(s,a)(s,a)我们都可以由公式求出它的值函数,即用一个查询表lookup table来表示值函数。但是当state或action的个数过多时,分别去求每一个值函数会很慢。因此我们用函数近似的方式去估计值函数:^Q(s,a,w)≈Qπ(s,a)Q^(s,a,w)≈Qπ(s,a)

    这样,对于未出现的state action也可以估计值函数。
    至于近似函数,DQN中用的是神经网络,当然如果环境比较简单的话用线性函数来近似也是可以的。

    DQN算法原文链接: 2013版(arxiv) 2015版(nature)

    二、算法原理

    基本概念中有说过,强化学习是一个反复迭代的过程,每一次迭代要解决两个问题:给定一个策略求值函数,和根据值函数来更新策略。

    上面说过DQN使用神经网络来近似值函数,即神经网络的输入是state ss,输出是Q(s,a),∀a∈AQ(s,a),∀a∈A (action space)。通过神经网络计算出值函数后,DQN使用ϵ−greedyϵ−greedy策略来输出action(第四部分中介绍)。值函数网络与ϵ−greedyϵ−greedy策略之间的联系是这样的:首先环境会给出一个obs,智能体根据值函数网络得到关于这个obs的所有Q(s,a)Q(s,a),然后利用ϵ−greedyϵ−greedy选择action并做出决策,环境接收到此action后会给出一个奖励Rew及下一个obs。这是一个step。此时我们根据Rew去更新值函数网络的参数。接着进入下一个step。如此循环下去,直到我们训练出了一个好的值函数网络。

    DQN-network

    那么每次迭代如何更新神经网络的参数呢?

    与机器学习类似,首先会定义一个loss function,然后使用梯度下降GD来更新参数。接下来首先介绍DQN的loss function,它与Q-Learning的非常类似,只是添加了一个target Q function。然后会介绍除此之外,DQN在Q-Learning上所做的改进。

    1、Loss Function

    L(ω)=E[(R+γ⋅maxa′Q(s′,a′;ω−)−Q(s,a;ω))2]L(ω)=E[(R+γ⋅maxa′Q(s′,a′;ω−)−Q(s,a;ω))2]这个公式表面上看起来很复杂,实际上很好理解,它就是一个残差模型,和我们平常见的最小二乘法很类似,真实值与预测值之间的差的平方。预测值就是Q(s,a;ω)Q(s,a;ω),它是神经网络的输出。“真实值”略微有一点复杂。

    想象一下假如我们想求出(s,a)(s,a)的真实值函数Q(s,a)Q(s,a)。它表示我从state ss开始出发,并采取action aa的话,我所能得到的整体收益的期望值。一种可能的情况是,我们知道环境的模型。这在强化学习中也叫Model Based RL。即我们知道状态转移概率矩阵:当处于(s,a)(s,a)时,下一个到达的状态可能是什么,并且到达每一个状态的概率是什么;我们还知道奖励函数:当处于(s,a)(s,a)时,得到的立即回报的期望值是什么;另外还知道折扣因子。由此,我们便可以通过贝尔曼方程来求解值函数。这种情况下我们可能也并不需要神经网络近似值函数之类的,直接由策略迭代或值迭代便可以求出最优策略。具体方法可以看一下MDP。

    另一种情况就是Model Free RL:不管有没有环境模型,反正我不用。那么在不知道环境模型的情况下如何求解值函数呢?答案就是采样。强化学习中有多种采样的方法,这里简单介绍一下:

    (1) Monte Carlo

    MC

    • MC使用一个完整的episode去更新值函数,因此它需要从StSt到Terminal state的完整样本。
    • 而且需要等到episode结束才能更新值函数。
    • 由于有一条完整的样本,它可以计算出return,而值函数是return的期望,所以我们可以用return去更新值函数。

    (2) Temporal Difference / SarSa

    TD

    • 与MC不一样的是,TD不需要完整的样本,它只依赖下一个step的值函数,即它用V(St+1)V(St+1) 去更新 V(St)V(St) (TD), 或用 Q(St+1,at+1)Q(St+1,at+1) 去更新 Q(St,at)Q(St,at) (SarSa)
    • 它不用等到episode结束,每走一步就可以更新值函数。
    • 它不是用的真实的return值来更新值函数,而是用的一个估计值去更新另一个估计值的思想。

    另外还有TD(λ)TD(λ) (或 SarSa(λ)SarSa(λ))方法,由于DQN中不涉及,暂不介绍。

    DQN属于Model Free的强化学习算法,它需要采样。且同SarSa类似,只依赖下一个step的值函数。但它更新值函数的方式与SarSa又有所不同。下面介绍从SarSa到Q-Learning再到DQN的更新值函数的方式。

    (1) SarSa

    sarsa

    SarSa中更新值函数的公式为:Q(s,a)←Q(s,a)+α[R+γQ(s′,a′)−Q(s,a)]Q(s,a)←Q(s,a)+α[R+γQ(s′,a′)−Q(s,a)]也称它的target是 Rt+1+γQ(St+1,at+1)Rt+1+γQ(St+1,at+1)。理解这个target代表的意义:V(s)=E[Gt|St=s]=E[Rt+1+γGt+1|St=s]=E[Rt+1+γV(St+1)|St=s]V(s)=E[Gt|St=s]=E[Rt+1+γGt+1|St=s]=E[Rt+1+γV(St+1)|St=s]将V换成Q的话我们可以看到,SarSa target Rt+1+γQ(St+1,at+1)Rt+1+γQ(St+1,at+1) 是 Q(St,at)Q(St,at) 的估计值。

    在值函数近似中,我们都是使用target来替代真实的值函数,即Loss中的真实值。

    前面说过DQN是使用ϵ−greedyϵ−greedy策略来输出action,SarSa和Q-Learning也是。SarSa中使用ϵ−greedyϵ−greedy策略生成action at+1at+1,随即又用 at+1at+1处对应的值函数来计算target,更新上一步的值函数。这种学习方式又称为On-policy

    SarSa属于On-policy Learning,而Q-Learning属于Off-policy Learning。

    (2) Q-Learning

    qlearning

    Q-Learning的target是 Rt+1+γmaxa′Q(St+1,a′)Rt+1+γmaxa′Q(St+1,a′)。它使用 ϵ−greedyϵ−greedy策略来生成action at+1at+1,但用来计算target的action却不一定是at+1at+1,而是使得 Q(St+1,a)Q(St+1,a)最大的action。这种产生行为的策略和进行评估的策略不一样的方法称为Off-policy方法。对于Q-Learning来说,产生行为的策略是ϵ−greedyϵ−greedy,而进行评估的策略是greedy。

    (3) DQN

    Off-policy是Q-Learning的特点,DQN中也延用了这一特点。而不同的是,Q-Learning中用来计算target和预测值的Q是同一个Q,也就是说使用了相同的神经网络。这样带来的一个问题就是,每次更新神经网络的时候,target也都会更新,这样会容易导致参数不收敛。回忆在有监督学习中,标签label都是固定的,不会随着参数的更新而改变。

    因此DQN在原来的Q网络的基础上又引入了一个target Q网络,即用来计算target的网络。它和Q网络结构一样,初始的权重也一样,只是Q网络每次迭代都会更新,而target Q网络是每隔一段时间才会更新。DQN的target是 Rt+1+γmaxa′Q(St+1,a′;ω−)Rt+1+γmaxa′Q(St+1,a′;ω−)。用 ω−ω−表示它比Q网络的权重 ωω更新得要慢一些。

    理解了DQN的target之后也就可以理解DQN的Loss Function了。

    2、DQN所做的改进

    相比于Q-Learning,DQN做的改进:一个是使用了卷积神经网络来逼近行为值函数,一个是使用了target Q network来更新target,还有一个是使用了经验回放Experience replay。

    由于在强化学习中,我们得到的观测数据是有序的,step by step的,用这样的数据去更新神经网络的参数会有问题。回忆在有监督学习中,数据之间都是独立的。因此DQN中使用经验回放,即用一个Memory来存储经历过的数据,每次更新参数的时候从Memory中抽取一部分的数据来用于更新,以此来打破数据间的关联。

    三、算法整体流程

    • 首先初始化Memory D,它的容量为N;
    • 初始化Q网络,随机生成权重ωω;
    • 初始化target Q网络,权重为ω−=ωω−=ω;
    • 循环遍历episode =1, 2, …, M:
    • 初始化initial state S1S1;
    • 循环遍历step =1,2,…, T:
      • 用ϵ−greedyϵ−greedy策略生成action atat:以ϵϵ概率选择一个随机的action,或选择at=maxaQ(St,a;ω)at=maxaQ(St,a;ω);
      • 执行action atat,接收reward rtrt及新的state St+1St+1;
      • 将transition样本 (St,at,rt,St+1)(St,at,rt,St+1)存入D中;
      • 从D中随机抽取一个minibatch的transitions (Sj,aj,rj,Sj+1)(Sj,aj,rj,Sj+1);
      • 令yj=rjyj=rj,如果 j+1j+1步是terminal的话,否则,令 yj=rj+γmaxa′Q(St+1,a′;ω−)yj=rj+γmaxa′Q(St+1,a′;ω−);
      • 对(yj−Q(St,aj;ω))2(yj−Q(St,aj;ω))2关于ωω使用梯度下降法进行更新;
      • 每隔C steps更新target Q网络,ω−=ωω−=ω。
    • End For;
    • End For.

    附上原文的算法流程:

    dqn

    四、ϵ−greedyϵ−greedy策略

    greedygreedy策略,顾名思义,是一种贪婪策略,它每次都选择使得值函数最大的action,即at=maxaQ(St,a;ω)at=maxaQ(St,a;ω)。但是这种方式有问题,就是对于采样中没有出现过的(state, action) 对,由于没有评估,没有Q值,之后也不会再被采到。

    其实这里涉及到了强化学习中一个非常重要的概念,叫Exploration & Exploitation,探索与利用。前者强调发掘环境中的更多信息,并不局限在已知的信息中;后者强调从已知的信息中最大化奖励。而greedygreedy策略只注重了后者,没有涉及前者。所以它并不是一个好的策略。

    而ϵ−greedyϵ−greedy策略兼具了探索与利用,它以ϵϵ的概率从所有的action中随机抽取一个,以1−ϵ1−ϵ的概率抽取at=maxaQ(St,a;ω)at=maxaQ(St,a;ω)。

    强化学习正是因为有了探索Exploration,才会常常有一些出人意表的现象,才会更加与其他机器学习不同。例如智能体在围棋游戏中走出一些人类经验之外的好棋局。

    参考资料:

    David Silver的课程:www0.cs.ucl.ac.uk/staff/D.Silver/web/Teaching.html

    展开全文
  • 【强化学习】Deep Q Network(DQN)算法详解

    万次阅读 多人点赞 2019-12-04 09:09:27
    DQN(Deep Q-Learning)是将深度学习deeplearning与强化学习reinforcementlearning相结合,实现了从感知到动作的端到端的革命性算法。使用DQN玩游戏的话简直6的飞起,其中fladdy bird这个游戏就已经被DQN玩坏了。当...
    > DQN(Deep Q-Learning)是将深度学习deeplearning与强化学习reinforcementlearning相结合,实现了从感知到动作的端到端的革命性算法。使用DQN玩游戏的话简直6的飞起,其中fladdy bird这个游戏就已经被DQN玩坏了。当我们的Q-table他过于庞大无法建立的话,使用DQN是一种很好的选择
    

    引用 morvan大神的教程图片 https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/4-1-A-DQN/

    1、算法思想

    DQN与Qleanring类似都是基于值迭代的算法,但是在普通的Q-learning中,当状态和动作空间是离散且维数不高时可使用Q-Table储存每个状态动作对的Q值,而当状态和动作空间是高维连续时,使用Q-Table不动作空间和状态太大十分困难。
    所以在此处可以把Q-table更新转化为一函数拟合问题,通过拟合一个函数function来代替Q-table产生Q值,使得相近的状态得到相近的输出动作。因此我们可以想到深度神经网络对复杂特征的提取有很好效果,所以可以将DeepLearning与Reinforcement Learning结合。这就成为了DQN
    这里写图片描述
    DL与RL结合存在以下问题 :

    • DL是监督学习需要学习训练集,强化学习不需要训练集只通过环境进行返回奖励值reward,同时也存在着噪声和延迟的问题,所以存在很多状态state的reward值都是0也就是样本稀疏
    • DL每个样本之间互相独立,而RL当前状态的状态值是依赖后面的状态返回值的。
    • 当我们使用非线性网络来表示值函数的时候可能出现不稳定的问题

    DQN中的两大利器解决了以上问题

    • 通过Q-Learning使用reward来构造标签
    • 通过experience replay(经验池)的方法来解决相关性及非静态分布问题
    • 使用一个MainNet产生当前Q值,使用另外一个Target产生Target Q

    2、experience replay 经验池

    经验池DQN中的记忆库用来学习之前的经历,又因为Q learning 是一种 off-policy 离线学习法, 它能学习当前经历着的, 也能学习过去经历过的, 甚至是学习别人的经历,所以在学习过程中随机的加入之前的经验会让神经网络更有效率。
    所以经验池解决了相关性及非静态分布问题。他通过在每个timestep下agent与环境交互得到的转移样本 (st,at,rt,st+1s_t,a_t,r_t,s_{t+1}) 储存到回放记忆网络,要训练时就随机拿出一些(minibatch)来训练因此打乱其中的相关性。

    3、Q-target 目标网络

    Q-targets的作用其实也是一种打乱相关性的机制,使用Q-targets会使得DQN中出现两个结构完全相同但是参数却不同的网络,预测Q估计的的网络MainNet使用的是最新的参数,而预测Q现实的神经网络TargetNet参数使用的却是很久之前的,Q(s,a;θi)Q(s,a;θ_i) 表示当前网络MainNet的输出,用来评估当前状态动作对的值函数;Q(s,a;θi)Q(s,a;θ_i)表示TargetNet的输出,可以解出targetQ并根据LossFunction更新MainNet的参数,每经过一定次数的迭代,将MainNet的参数复制给TargetNet。
    引入TargetNet后,再一段时间里目标Q值使保持不变的,一定程度降低了当前Q值和目标Q值的相关性,提高了算法稳定性。

    4、算法流程

    4.1、前置公式

    DQN的更新方式和Qlearning一样,详细的值函数与动作值函数此处不再推导,在Qlearning中有详细讲解不了解的请移步上一篇博客

    Q(s,a)Q(s,a)+α[r+γmaxaQ(s,a)Q(s,a)]Q(s,a)←Q(s,a)+α[r+γmax_{a′}Q(s′,a′)−Q(s,a)]

    DQN的损失函数如下 θ表示网络参数为均方误差损失

    L(θ)=E[(TargetQQ(s,a;θ))2]L(θ)=E[(TargetQ−Q(s,a;θ))^2]
    TargetQ=r+γmaxaQ(s,a;θ)TargetQ=r+γmax_{a′}Q(s′,a′;θ)
    这里写图片描述
    4.2、算法流程

    DQN中存在两个结构完全相同但是参数却不同的网络,预测Q估计的网络MainNet使用的是最新的参数,而预测Q现实的神经网络TargetNet参数使用的却是很久之前的,Q(s,a;θi)Q(s,a;θ_i)表示当前网络MainNet的输出,用来评估当前状态动作对的值函数;Q(s,a;θi)Q(s,a;θ^−_i) 表示TargetNet的输出,可以解出targetQ,因此当agent对环境采取动作a时就可以根据上述公式计算出Q并根据LossFunction更新MainNet的参数,每经过一定次数的迭代,将MainNet的参数复制给TargetNet。这样就完成了一次学习过程
    算法伪代码
    在这里插入图片描述

    5、代码实现

    根据morvan老师的例子所得

    class DeepQNetwork:
        def __init__(
                self,
                n_actions,
                n_features,
                learning_rate=0.01,
                reward_decay=0.9,
                e_greedy=0.9,
                replace_target_iter=300,
                memory_size=500,
                batch_size=32,
                e_greedy_increment=None,
                output_graph=True,
        ):
            self.n_actions = n_actions
            self.n_features = n_features
            self.lr = learning_rate
            self.gamma = reward_decay
            self.epsilon_max = e_greedy
            self.replace_target_iter = replace_target_iter
            self.memory_size = memory_size
            self.batch_size = batch_size
            self.epsilon_increment = e_greedy_increment
            self.epsilon = 0 if e_greedy_increment is not None else self.epsilon_max
    
            # 统计训练次数
            self.learn_step_counter = 0
    
            # 初始化记忆 memory [s, a, r, s_]
            self.memory = np.zeros((self.memory_size, n_features * 2 + 2))
    
            # 有两个网络组成 [target_net, evaluate_net]
            self._build_net()
            t_params = tf.get_collection('target_net_params')
            e_params = tf.get_collection('eval_net_params')
            self.replace_target_op = [tf.assign(t, e) for t, e in zip(t_params, e_params)]
    
            self.sess = tf.Session()
    
            if output_graph:
                # 开启tensorboard
                # $ tensorboard --logdir=logs
                # tf.train.SummaryWriter soon be deprecated, use following
                tf.summary.FileWriter(r'D:\logs', self.sess.graph)
    
            self.sess.run(tf.global_variables_initializer())
            self.cost_his = []
    
        def _build_net(self):
            # -------------- 创建 eval 神经网络, 及时提升参数 --------------
            self.s = tf.placeholder(tf.float32, [None, self.n_features], name='s')  # 用来接收 observation
            self.q_target = tf.placeholder(tf.float32, [None, self.n_actions],
                                           name='Q_target')  # 用来接收 q_target 的值, 这个之后会通过计算得到
            with tf.variable_scope('eval_net'):
                # c_names(collections_names) 是在更新 target_net 参数时会用到
                c_names, n_l1, w_initializer, b_initializer = \
                    ['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES], 10, \
                    tf.random_normal_initializer(0., 0.3), tf.constant_initializer(0.1)  # config of layers
    
                # eval_net 的第一层. collections 是在更新 target_net 参数时会用到
                with tf.variable_scope('l1'):
                    w1 = tf.get_variable('w1', [self.n_features, n_l1], initializer=w_initializer, collections=c_names)
                    b1 = tf.get_variable('b1', [1, n_l1], initializer=b_initializer, collections=c_names)
                    l1 = tf.nn.relu(tf.matmul(self.s, w1) + b1)
    
                # eval_net 的第二层. collections 是在更新 target_net 参数时会用到
                with tf.variable_scope('l2'):
                    w2 = tf.get_variable('w2', [n_l1, self.n_actions], initializer=w_initializer, collections=c_names)
                    b2 = tf.get_variable('b2', [1, self.n_actions], initializer=b_initializer, collections=c_names)
                    self.q_eval = tf.matmul(l1, w2) + b2
    
            with tf.variable_scope('loss'):  # 求误差
                self.loss = tf.reduce_mean(tf.squared_difference(self.q_target, self.q_eval))
            with tf.variable_scope('train'):  # 梯度下降
                self._train_op = tf.train.RMSPropOptimizer(self.lr).minimize(self.loss)
    
            # ---------------- 创建 target 神经网络, 提供 target Q ---------------------
            self.s_ = tf.placeholder(tf.float32, [None, self.n_features], name='s_')  # 接收下个 observation
            with tf.variable_scope('target_net'):
                # c_names(collections_names) 是在更新 target_net 参数时会用到
                c_names = ['target_net_params', tf.GraphKeys.GLOBAL_VARIABLES]
    
                # target_net 的第一层. collections 是在更新 target_net 参数时会用到
                with tf.variable_scope('l1'):
                    w1 = tf.get_variable('w1', [self.n_features, n_l1], initializer=w_initializer, collections=c_names)
                    b1 = tf.get_variable('b1', [1, n_l1], initializer=b_initializer, collections=c_names)
                    l1 = tf.nn.relu(tf.matmul(self.s_, w1) + b1)
    
                # target_net 的第二层. collections 是在更新 target_net 参数时会用到
                with tf.variable_scope('l2'):
                    w2 = tf.get_variable('w2', [n_l1, self.n_actions], initializer=w_initializer, collections=c_names)
                    b2 = tf.get_variable('b2', [1, self.n_actions], initializer=b_initializer, collections=c_names)
                    self.q_next = tf.matmul(l1, w2) + b2
    
        def store_transition(self, s, a, r, s_):
            # 判断是否包含对应属性 没有就赋予初值
            if not hasattr(self, 'memory_counter'):
                self.memory_counter = 0
    
            # 纵向延伸
            transition = np.hstack((s, [a, r], s_))
    
            # 使用新的记忆替换掉旧网络的记忆
            index = self.memory_counter % self.memory_size
            self.memory[index, :] = transition
    
            self.memory_counter += 1
    
        def choose_action(self, observation):
            # 给观测值加上batch_size维度
            observation = observation[np.newaxis, :]
    
            if np.random.uniform() < self.epsilon:
                # forward feed the observation and get q value for every actions
                actions_value = self.sess.run(self.q_eval, feed_dict={self.s: observation})
                action = np.argmax(actions_value)
            else:
                action = np.random.randint(0, self.n_actions)
            return action
    
        def learn(self):
            # 判断是否应该更新target-net网络了
            if self.learn_step_counter % self.replace_target_iter == 0:
                self.sess.run(self.replace_target_op)
                print('\ntarget_params_replaced\n')
    
            # 从以前的记忆中随机抽取一些记忆
            if self.memory_counter > self.memory_size:
                sample_index = np.random.choice(self.memory_size, size=self.batch_size)
            else:
                sample_index = np.random.choice(self.memory_counter, size=self.batch_size)
            batch_memory = self.memory[sample_index, :]
    
            q_next, q_eval = self.sess.run(
                [self.q_next, self.q_eval],
                feed_dict={
                    self.s_: batch_memory[:, -self.n_features:],  # fixed params
                    self.s: batch_memory[:, :self.n_features],  # newest params
                })
    
            # change q_target w.r.t q_eval's action
            q_target = q_eval.copy()
    
            # 下面这几步十分重要. q_next, q_eval 包含所有 action 的值,
            # 而我们需要的只是已经选择好的 action 的值, 其他的并不需要.
            # 所以我们将其他的 action 值全变成 0, 将用到的 action 误差值 反向传递回去, 作为更新凭据.
            # 这是我们最终要达到的样子, 比如 q_target - q_eval = [1, 0, 0] - [-1, 0, 0] = [2, 0, 0]
            # q_eval = [-1, 0, 0] 表示这一个记忆中有我选用过 action 0, 而 action 0 带来的 Q(s, a0) = -1, 所以其他的 Q(s, a1) = Q(s, a2) = 0.
            # q_target = [1, 0, 0] 表示这个记忆中的 r+gamma*maxQ(s_) = 1, 而且不管在 s_ 上我们取了哪个 action,
            # 我们都需要对应上 q_eval 中的 action 位置, 所以就将 1 放在了 action 0 的位置.
    
            # 下面也是为了达到上面说的目的, 不过为了更方面让程序运算, 达到目的的过程有点不同.
            # 是将 q_eval 全部赋值给 q_target, 这时 q_target-q_eval 全为 0,
            # 不过 我们再根据 batch_memory 当中的 action 这个 column 来给 q_target 中的对应的 memory-action 位置来修改赋值.
            # 使新的赋值为 reward + gamma * maxQ(s_), 这样 q_target-q_eval 就可以变成我们所需的样子.
            # 具体在下面还有一个举例说明.
    
            batch_index = np.arange(self.batch_size, dtype=np.int32)
            eval_act_index = batch_memory[:, self.n_features].astype(int)
            reward = batch_memory[:, self.n_features + 1]
    
            q_target[batch_index, eval_act_index] = reward + self.gamma * np.max(q_next, axis=1)
    
            """
                   假如在这个 batch 中, 我们有2个提取的记忆, 根据每个记忆可以生产3个 action 的值:
                   q_eval =
                   [[1, 2, 3],
                    [4, 5, 6]]
    
                   q_target = q_eval =
                   [[1, 2, 3],
                    [4, 5, 6]]
    
                   然后根据 memory 当中的具体 action 位置来修改 q_target 对应 action 上的值:
                   比如在:
                       记忆 0 的 q_target 计算值是 -1, 而且我用了 action 0;
                       记忆 1 的 q_target 计算值是 -2, 而且我用了 action 2:
                   q_target =
                   [[-1, 2, 3],
                    [4, 5, -2]]
    
                   所以 (q_target - q_eval) 就变成了:
                   [[(-1)-(1), 0, 0],
                    [0, 0, (-2)-(6)]]
    
                   最后我们将这个 (q_target - q_eval) 当成误差, 反向传递会神经网络.
                   所有为 0 的 action 值是当时没有选择的 action, 之前有选择的 action 才有不为0的值.
                   我们只反向传递之前选择的 action 的值,
            """
    
            # 训练eval网络
            _, self.cost = self.sess.run([self._train_op, self.loss],
                                         feed_dict={self.s: batch_memory[:, :self.n_features],
                                                    self.q_target: q_target})
            self.cost_his.append(self.cost)
    
            # 因为在训练过程中会逐渐收敛所以此处动态设置增长epsilon
            self.epsilon = self.epsilon + self.epsilon_increment if self.epsilon < self.epsilon_max else self.epsilon_max
            self.learn_step_counter += 1
    
    展开全文
  • 强化学习入门简单实例 DQN

    万次阅读 多人点赞 2020-03-29 17:14:34
    基础知识 作者:甄景贤 ...我在外国博客上写过一些基於人工智能的文章,有些搬到了博客园,上面转录的是其中一篇:什么是强化学习? 我正在研究的 AI architecture 是用强化学习控制 recurrent 神经网络,我相信这...

    [强化学习入门 第一讲 MDP](https://zhuanlan.zhihu.com/p/25498081)
    [随笔分类 - 0084. 强化学习](https://www.cnblogs.com/pinard/category/1254674.html)

    基础知识

    作者:甄景贤
    链接:https://www.zhihu.com/question/41775291/answer/93276779



    我在外国博客上写过一些基於人工智能的文章,有些搬到了博客园,上面转录的是其中一篇:
    什么是强化学习?

     

    我正在研究的 AI architecture 是用强化学习控制 recurrent 神经网络,我相信这个设置可以做到逻辑推理和答问题的功能,基本上就是 strong AI。 但还有一些未解决的细节。 论文的标题是《游荡在思考的迷宫中》,即将发表。

    補充: 還有一點,就是監督學習的問題可以很容易化為強化學習的問題(雖然這樣增加了複雜性而沒有益處),但反之則沒有一般的辦法。 見:Reinforcement Learning and itsRelationship to SupervisedLearning,Barto and Dietterich, 2004.
    "But is it possible to do this theother way around: to convert a reinforcement learning task into a supervised learningtask?
    "In general, there is no way to do this. The key difficulty is that whereas insupervised learning, the goal is to reconstruct the unknown function f that assignsoutput values y to data points x, in reinforcement learning, the goal is to find theinput x* that gives the maximum reward R(x*).
    "Nonetheless, is there a way that we could apply ideas from supervised learningto perform reinforcement learning? Suppose, for example, that we are given a setof training examples of the form (xi, R(xi)), where the xi are points and the R(xi)are the corresponding observed rewards. In supervised learning, we would attemptto find a function h that approximates R well. If h were a perfect approximation ofR, then we could find x* by applying standard optimization algorithms to h."

     

    手把手实例Q-learning

    作者: peghoty 

    出处: http://blog.csdn.net/peghoty/article/details/9361915

     

    第一部分:中文翻译

     

     从Q-Learning到DQN

     

    来源

    2 维度灾难

    在上面的简单分析中,我们使用表格来表示Q(s,a),但是这个在现实的很多问题上是几乎不可行的,因为状态实在是太多。使用表格的方式根本存不下。

    举Atari为例子。

     

    计算机玩Atari游戏的要求是输入原始图像数据,也就是210x160像素的图片,然后输出几个按键动作。总之就是和人类的要求一样,纯视觉输入,然后让计算机自己玩游戏。那么这种情况下,到底有多少种状态呢?有可能每一秒钟的状态都不一样。因为,从理论上看,如果每一个像素都有256种选择,那么就有:

     

    256^{210\times 160}

    这简直是天文数字。所以,我们是不可能通过表格来存储状态的。我们有必要对状态的维度进行压缩,解决办法就是 价值函数近似Value Function Approximation

    3 价值函数近似Value Function Approximation

    什么是价值函数近似呢?说起来很简单,就是用一个函数来表示Q(s,a)。即

    Q(s,a) = f(s,a)

    f可以是任意类型的函数,比如线性函数:

    Q(s,a) = w_1s + w_2a + b 其中w_1,w_2,b是函数f的参数。

    大家看到了没有,通过函数表示,我们就可以无所谓s到底是多大的维度,反正最后都通过矩阵运算降维输出为单值的Q。

    这就是价值函数近似的基本思路。

    如果我们就用w来统一表示函数f的参数,那么就有

    Q(s,a) = f(s,a,w)

    为什么叫近似,因为我们并不知道Q值的实际分布情况,本质上就是用一个函数来近似Q值的分布,所以,也可以说是

    Q(s,a)\approx f(s,a,w)

    4 高维状态输入,低维动作输出的表示问题

    对于Atari游戏而言,这是一个高维状态输入(原始图像),低维动作输出(只有几个离散的动作,比如上下左右)。那么怎么来表示这个函数f呢?

    难道把高维s和低维a加在一起作为输入吗?

    必须承认这样也是可以的。但总感觉有点别扭。特别是,其实我们只需要对高维状态进行降维,而不需要对动作也进行降维处理。

    那么,有什么更好的表示方法吗?

    当然有,怎么做呢?

    其实就是Q(s) \approx f(s,w),只把状态s作为输入,但是输出的时候输出每一个动作的Q值,也就是输出一个向量[Q(s,a_1),Q(s,a_2),Q(s,a_3),...,Q(s,a_n)],记住这里输出是一个值,只不过是包含了所有动作的Q值的向量而已。这样我们就只要输入状态s,而且还同时可以得到所有的动作Q值,也将更方便的进行Q-Learning中动作的选择与Q值更新(这一点后面大家会理解)。

    5 Q值神经网络化!

    终于到了和深度学习相结合的一步了!

    意思很清楚,就是我们用一个深度神经网络来表示这个函数f。

    这里假设大家对深度学习特别是卷积神经网络已经有基本的理解。如果不是很清楚,欢迎阅读本专栏的CS231n翻译系列文章。

     

    以DQN为例,输入是经过处理的4个连续的84x84图像,然后经过两个卷积层,两个全连接层,最后输出包含每一个动作Q值的向量。

     

    对于这个网络的结构,针对不同的问题可以有不同的设置。如果大家熟悉Tensorflow,那么肯定知道创建一个网络是多么简单的一件事。这里我们就不具体介绍了。我们将在之后的DQN tensorflow实战篇进行讲解。

    总之,用神经网络来表示Q值非常简单,Q值也就是变成用Q网络(Q-Network)来表示。接下来就到了很多人都会困惑的问题,那就是

    怎么训练Q网络???

    6 DQN算法

    我们知道,神经网络的训练是一个最优化问题,最优化一个损失函数loss function,也就是标签和网络输出的偏差,目标是让损失函数最小化。为此,我们需要有样本,巨量的有标签数据,然后通过反向传播使用梯度下降的方法来更新神经网络的参数。

    所以,要训练Q网络,我们要能够为Q网络提供有标签的样本。

    所以,问题变成:

    如何为Q网络提供有标签的样本?

    答案就是利用Q-Learning算法。

    大家回想一下Q-Learning算法,Q值的更新依靠什么?依靠的是利用Reward和Q计算出来的目标Q值:

    R_{t+1}+\lambda \max _aQ(S_{t+1},a)

    因此,我们把目标Q值作为标签不就完了?我们的目标不就是让Q值趋近于目标Q值吗?

    因此,Q网络训练的损失函数就是

     

    上面公式是s^`,a^` 即下一个状态和动作。这里用了David Silver的表示方式,看起来比较清晰。

     

    既然确定了损失函数,也就是cost,确定了获取样本的方式。那么DQN的整个算法也就成型了!

    接下来就是具体如何训练的问题了!

    7 DQN训练

    我们这里分析第一个版本的DQN,也就是NIPS 2013提出的DQN。

     

    我们分析了这么久终于到现在放上了DQN算法,真是不容易。如果没有一定基础直接上算法还真是搞不明白。

     

    具体的算法主要涉及到Experience Replay,也就是经验池的技巧,就是如何存储样本及采样问题。

    由于玩Atari采集的样本是一个时间序列,样本之间具有连续性,如果每次得到样本就更新Q值,受样本分布影响,效果会不好。因此,一个很直接的想法就是把样本先存起来,然后随机采样如何?这就是Experience Replay的意思。按照脑科学的观点,人的大脑也具有这样的机制,就是在回忆中学习。

    那么上面的算法看起来那么长,其实就是反复试验,然后存储数据。接下来数据存到一定程度,就每次随机采用数据,进行梯度下降!

    也就是

    在DQN中增强学习Q-Learning算法和深度学习的SGD训练是同步进行的!

    通过Q-Learning获取无限量的训练样本,然后对神经网络进行训练。

    样本的获取关键是计算y,也就是标签。

     与DQN不同的Policy Gradient:

    来源

    2 Why Policy Network?

    我们已经知道DQN是一个基于价值value的方法。换句话说就是通过计算每一个状态动作的价值,然后选择价值最大的动作执行。这是一种间接的做法。那么,更直接的做法是什么?

    能不能直接更新策略网络Policy Network呢?

    什么是策略网络Policy Network?就是一个神经网络,输入是状态,输出直接就是动作(不是Q值)。

    a = \pi(s,\theta)a = \pi(s,\theta)

    或者输出概率:a = \pi(a|s,\theta)

    这里要提一下概率输出的问题。对于DQN来说,本质上是一个接近于确定性输出的算法。至多就是采用\epsilon-greedy进行探索。但是有很多时候,在某一个特定状态下,很多动作的选择可能都是可以的。比如说我有20块钱去买饭。那么不管我买的是蛋炒饭还是土豆肉片盖码饭,结果都是一样的填饱肚子。因此,采用输出概率会更通用一些。而DQN并不能输出动作的概率,所以采用Policy Network是一个更好的办法。

    3 Policy Gradient

    要更新策略网络,或者说要使用梯度下降的方法来更新网络,我们需要有一个目标函数。对于策略网络,目标函数其实是比较容易给定的,就是很直接的,最后的结果!也就是

    L(\theta) = \mathbb E(r_1+\gamma r_2 + \gamma^2 r_3 + ...|\pi(,\theta)) 所有带衰减reward的累加期望

    那么问题就在于如何利用这个目标来更新参数\theta呢?咋一看这个损失函数和策略网络简直没有什么直接联系,reward是环境给出的,如何才能更新参数?换个说法就是如何能够计算出损失函数关于参数的梯度(也就是策略梯度):

    \nabla_{\theta} L(\theta)

    咋一看根本就没有什么思路是不是,所以先换一个思路来考虑问题。

    4 就给我一个Policy Network,也没有loss,怎么更新?

    改变动作的出现概率!

    现在我们不考虑别的,就仅仅从概率的角度来思考问题。我们有一个策略网络,输入状态,输出动作的概率。然后执行完动作之后,我们可以得到reward,或者result。那么这个时候,我们有个非常简单的想法:

    如果某一个动作得到reward多,那么我们就使其出现的概率增大,如果某一个动作得到的reward少,那么我们就使其出现的概率减小。

    当然,也显然的,用reward来评判动作的好坏是不准确的,甚至用result来评判也是不准确的。毕竟任何一个reward,result都依赖于大量的动作才导致的。但是这并不妨碍我们做这样的思考:

    如果能够构造一个好的动作评判指标,来判断一个动作的好与坏,那么我们就可以通过改变动作的出现概率来优化策略!

    假设这个评价指标是f(s,a),那么我们的Policy Network输出的是概率。一般情况下,更常使用log likelihood log \pi(a|s,\theta)。原因的话看这里Why we consider log likelihood instead of Likelihood in Gaussian Distribution

    因此,我们就可以构造一个损失函数如下:

    L(\theta) = \sum log\pi(a|s,\theta)f(s,a)

    怎么理解呢?举个简单的AlphaGo的例子吧。对于AlphaGo而言,f(s,a)就是最后的结果。也就是一盘棋中,如果这盘棋赢了,那么这盘棋下的每一步都是认为是好的,如果输了,那么都认为是不好的。好的f(s,a)就是1,不好的就-1。所以在这里,如果a被认为是好的,那么目标就是最大化这个好的动作的概率,反之亦然。

    这就是Policy Gradient最基本的思想。

    5 另一个角度:直接算

    f(s,a)不仅仅可以作为动作的评价指标,还可以作为目标函数。就如同AlphaGo,评价指标就是赢或者输,而目标就是结果赢。这和之前分析的目标完全没有冲突。因此,我们可以利用评价指标f(s,a)来优化Policy,同时也是在优化的同时优化了f(s,a).那么问题就变成对f(s,a)求关于参数的梯度。下面的公式直接摘自Andrej Karpathy的blog,f(x)即是f(s,a)

    \begin{align}\nabla_{\theta} E_x[f(x)] &= \nabla_{\theta} \sum_x p(x) f(x) & \text{definition of expectation} \\& = \sum_x \nabla_{\theta} p(x) f(x) & \text{swap sum and gradient} \\& = \sum_x p(x) \frac{\nabla_{\theta} p(x)}{p(x)} f(x) & \text{both multiply and divide by } p(x) \\& = \sum_x p(x) \nabla_{\theta} \log p(x) f(x) & \text{use the fact that } \nabla_{\theta} \log(z) = \frac{1}{z} \nabla_{\theta} z \\& = E_x[f(x) \nabla_{\theta} \log p(x) ] & \text{definition of expectation}\end{align}

    从公式得到的结论可以看到正好和上一小结分析得到的目标函数一致。

    因此,Policy Gradient方法就这么确定了。

    结合DQN和Policy Gradient的Actor Critic:

    来源

    一句话概括 Actor Critic 方法:结合了 Policy Gradient (Actor) 和 Function Approximation (Critic) 的方法. Actor 基于概率选行为, Critic 基于 Actor 的行为评判行为的得分, Actor 根据 Critic 的评分修改选行为的概率.

    Actor Critic 方法的优势: 可以进行单步更新, 比传统的 Policy Gradient 要快(回合结束更新).

    Actor Critic 方法的劣势: 取决于 Critic 的价值判断, 但是 Critic 难收敛, 再加上 Actor 的更新, 就更难收敛. 为了解决收敛问题, Google Deepmind 提出了 Actor Critic 升级版 Deep Deterministic Policy Gradient. 后者融合了 DQN 的优势, 解决了收敛难的问题.

    Actor 修改行为时就像蒙着眼睛一直向前开车, Critic 就是那个扶方向盘改变 Actor 开车方向的.

    或者说详细点, 就是 Actor 在运用 Policy Gradient 的方法进行 Gradient ascent 的时候, 由 Critic 来告诉他, 这次的 Gradient ascent 是不是一次正确的 ascent, 如果这次的得分不好, 那么就不要 ascent 那么多.

    DDPG

    它吸收了 Actor critic 让 Policy gradient 单步更新的精华, 而且还吸收让计算机学会玩游戏的 DQN 的精华, 合并成了一种新算法, 叫做 Deep Deterministic Policy Gradient一句话概括 DDPG: Google DeepMind 提出的一种使用 Actor Critic 结构, 但是输出的不是行为的概率, 而是具体的行为, 用于连续动作 (continuous action) 的预测. DDPG 结合了之前获得成功的 DQN 结构, 提高了 Actor Critic 的稳定性和收敛性.

    现在我们来说说 DDPG 中所用到的神经网络. 它其实和我们之前提到的 Actor-Critic 形式差不多, 也需要有基于策略 Policy 的神经网络和基于价值 Value 的神经网络, 但是为了体现 DQN 的思想, 每种神经网络我们都需要再细分为两个, Policy Gradient 这边, 我们有估计网络和现实网络, 估计网络用来输出实时的动作, 供 actor 在现实中实行. 而现实网络则是用来更新价值网络系统的. 所以我们再来看看价值系统这边, 我们也有现实网络和估计网络, 他们都在输出这个状态的价值, 而输入端却有不同, 状态现实网络这边会拿着从动作现实网络来的动作加上状态的观测值加以分析, 而状态估计网络则是拿着当时 Actor 施加的动作当做输入.在实际运用中, DDPG 的这种做法的确带来了更有效的学习过程.

    DDPG中,actor网络的输入是state,输出Action,以DNN进行函数拟合,对于连续动作NN输出层可以用tanh或sigmod,离散动作以softmax作为输出层则达到概率输出的效果。Critic网络的输入为state和action,输出为Q值。

    A3C(Asynchronous Advantage Actor-Critic)

    我们知道目前的计算机多半是有双核, 4核, 甚至 6核, 8核. 一般的学习方法, 我们只能让机器人在一个核上面玩耍. 但是如果使用 A3C 的方法, 我们可以给他们安排去不同的核, 并行运算. 实验结果就是, 这样的计算方式往往比传统的方式快上好多倍. 

    一句话概括 A3C: Google DeepMind 提出的一种解决 Actor-Critic 不收敛问题的算法. 它会创建多个并行的环境, 让多个拥有副结构的 agent 同时在这些并行环境上更新主结构中的参数. 并行中的 agent 们互不干扰, 而主结构的参数更新受到副结构提交更新的不连续性干扰, 所以更新的相关性被降低, 收敛性提高.

    全面提升基础知识

    https://www.cnblogs.com/pinard/category/1254674.html

    展开全文
  • 强化学习 DQN算法

    万次阅读 2018-11-05 11:59:10
    (以下内容取自莫凡大神的教程:...1,什么是DQN: 一种融合了神经网络和 Q learning 的方法。 2,为什么提出DQN: 传统的表格形式的强化学习有这样一个瓶颈,用表格来存储每一个状态 state, 和在...
  • 1 概述  在之前介绍的几种方法,我们对值函数一直有一个很大的限制,那就是它们需要用表格的形式表示。虽说表格形式对于求解有很大的帮助,但它也有自己的缺点。如果问题的状态和行动的空间非常大,使用表格表示...
  • dqn

    千次阅读 2019-05-28 15:58:47
    DL与RL结合的问题 DL需要大量带标签的样本进行监督学习;RL只有reward返回值,而且伴随着噪声,延迟(过了几十毫秒才返回),稀疏(很多State的reward是0)等问题; DL的样本独立;RL前后state状态相关;...
  • DQN实现的两种版本

    2020-07-30 15:42:34
    关于DQN的两种版本(使用stop_gradient与不使用stop_gradient) 对不起.....我不知道怎么将文件放到CSDN博客中下载,所以只能放这边了,没有资源分为0的选项.....
  • DQN

    2019-03-10 21:24:20
    http://www.algorithmdog.com/drl
  • DQN算法分析

    万次阅读 2017-09-21 18:14:27
    分析了DeepMind在2013年和2015 年提出的深度增强算法
  • 上篇文章强化学习——详解 DQN 算法我们介绍了 DQN 算法,但是 DQN 还存在一些问题,本篇文章介绍针对 DQN 的问题的改进算法 一、Double DQN 算法 1、算法介绍 DQN的问题有:目标 Q 值(Q Target )计算是否准确?...
  • 用keras搭建DQN

    千次阅读 2018-10-30 21:33:53
    dqn总结: 最近时间虽然一直看这个dqn代码,虽然看懂了,但是思路却一直不明确,无法自己复写出自己的代码,所以就想写一篇博客来整理一下思路。如果这篇文章写完了,应该思路就清晰了。 本文主要是看了莫烦的...
  • Dueling DQN 在深度强化学习(7)中,我们讨论了对DQN的经验回放池按权重采样来优化DQN算法的方法,本文讨论另一种优化方法,Dueling DQN。 不管是最初的DQN,还是由DQN演化出的Double DQN、经验优先回放DQN在值函数...
  • DQN的多种改进(1)

    万次阅读 2019-03-08 21:27:35
    1.N-step DQN N-step DQN的核心是将bellman方程展开,即 Q(st,at)=rt+γrt+1+γ2maxa′Q(st+2,a′)Q(s_t,a_t) = r_t + \gamma r_{t+1} + \gamma^2 max_{a&amp;#x27;}Q(s_{t+2},a&amp;#x27;)Q(st​,at​)=rt...
  • tensorflow2.0 实现 DQN

    2020-08-16 18:18:03
    文章目录DQN 简介DQN 实践注意事项 DQN 简介 表格型方法存储的状态数量有限,当面对围棋或机器人控制这类有数不清的状态的环境时,表格型方法在存储和查找效率上都受局限,DQN的提出解决了这一局限,使用神经网络来...
  • DQN,deep Q-network,用一个深度网络来拟合强化学习中的Q值Double DQN,分为主网络和target网络,主网络选择动作,target网络拟合Q值。主网络的变化浮动大,target网络变化浮动小。q_target = reward + gamma * np....
  • Double DQN and Dueling DQN

    2020-04-09 12:34:31
    不是很清楚的可以先看看这篇简洁版DQN介绍 只讲思想,不讲原理 1.Over-estimate 一般的Q-Learning中总会存在一些问题,由于下图中maxamax_amaxa​的存在,总是会过大的估计Q-VALUE。 Q-value是一个神经网络,因此...
  • 用Tensorflow基于Deep Q Learning DQN 玩Flappy Bird

    万次阅读 多人点赞 2016-03-22 00:11:57
    前言2013年DeepMind 在NIPS上发表Playing Atari with Deep Reinforcement Learning 一文,提出了DQN(Deep Q Network)算法,实现端到端学习玩Atari游戏,即只有像素输入,看着屏幕玩游戏。Deep Mind就凭借这个应用...
  • Dueling-DQN是对传统DQN的一种改进算法,它的核心思路是优化神经网络的结构。在传统DQN算法中,根据神经网络的输出确定每个动作Q值,然后选出最优的动作,其神经网络的大概模型如下图。 在Dueling-DQN中,对网络...
  • 在上一篇文章强化学习——DQN介绍 中我们详细介绍了DQN 的来源,以及对于强化学习难以收敛的问题DQN算法提出的两个处理方法:经验回放和固定目标值。这篇文章我们就用代码来实现 DQN 算法 一、环境介绍 1、Gym 介绍 ...
1 2 3 4 5 ... 20
收藏数 4,994
精华内容 1,997
关键字:

dqn