精华内容
下载资源
问答
  • 强化学习—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

    展开全文
  • 本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程 ...DQN算法原理和Agent实现 Double-DQN、Dueling DQN结构原理和Agent实现 Policy Gradients算法原理和Agent实现 A2C、A3C算法原理和Age...

    本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程
    本系列主要分几个部分进行介绍

    1. 强化学习背景介绍
    2. SARSA算法原理和Agent实现
    3. Q-learning算法原理和Agent实现
    4. DQN算法原理和Agent实现(tensorflow)
    5. Double-DQN、Dueling DQN算法原理和Agent实现(tensorflow)
    6. Policy Gradients算法原理和Agent实现(tensorflow)
    7. Actor-Critic、A2C、A3C算法原理和Agent实现(tensorflow)

    一、DQN算法原理

    DQN其实就是Q-learning的一种实现框架,在最早的Q-learning重,是通过Q-table来找到Q(s,a)Q(s,a),这是查找是一种映射关系。但是当状态很多或者动作连续时Q-table变得很难处理,既然是映射关系就可以使用神经网络。
    先回顾一下前面的知识
    化学习的主要功能就是让agent学习尽可能好的动作action,使其后续获得的奖励尽可能的大。
    假设在时刻t时,长期(全局)奖励为:
    在这里插入图片描述
    其中rt+nr_{t+n}为t+n时获得的局部奖励,γγ为下一期奖励传递到当期的衰减因子。则状态s的价值为GtG_t的条件期望:
    在这里插入图片描述
    同样定义状态s时执行动作a的价值也为GtG_t的条件期望:
    在这里插入图片描述
    可知:E(Qπ(s,a))=Vπ(s)E(Q_π(s,a))=V_π(s)
    下面直接给出深度学习最核心的Bellman 公式
    在这里插入图片描述
    Bellman 公式十分的直观,Vπ(s)V_π(s)=根据动作走到下个状态的奖励+下个状态长期价值*衰减值的期望。价值会不断的传递,因此可以看出Vπ(s)V_π(s)衡量的是状态s的长期价值。
    因为RL需要是Agent不断变强,就可以理解为让状态或让动作的价值不断变大,因此会选择根据如下方式获得新的Vπ(s)V_π(s)Qπ(s,a)Q_π(s,a)
    在这里插入图片描述
    下面先给出DQN算法:
    在这里插入图片描述
    上面算法中核心思想与Q-learning一样:求出Q(s,a)=r+γmax[Q(s,a)]Q_*(s,a)=r+γmax[Q(s',a')]是关键。
    具体的,我们可以学习某个状态s的评价Vπ(s)V_π(s),也可以学习某个状态s休执行动作a的评价Q(s,a)Q(s,a)

    1. 学习Vπ()V_π()

    当学习某个状态s的评价Vπ(s)V_π(s)Vπ()V_π()就我们要学习的函数,可用如下结构表示:
    在这里插入图片描述
    其中Vπ(s)V_π(s)的获得有如下两种方式:
    1. Monte-Carlo (MC) based approach :
    在这里插入图片描述
    我们再状态sas_a下执行一些列动作,直到游戏结束,和观测到这一系列奖励的总和GaG_a,我们直接将GaG_a赋值给Vπ(s)V_π(s),即用如下公式更新:
    在这里插入图片描述
    2.Temporal-difference (TD) approach :
    在这里插入图片描述
    在一种方法MC中,我们必须达到游戏结束状态才能计算出sts_t的价值。但是由于传递性,我们可以通过st+1s_{t+1}的价值与状态sts_t的奖励=rt=r_t的组合来求解sts_t的价值。具体的更新公式为:
    在这里插入图片描述
    实际上,MC由于要进行一系列动作,链条较长,不稳定,因此方差较大,但可以看做全局的方式,精度较高;而TD的方式由于误差不断传递,导致精度稍低,但是只有=rt=r_t存在方差,因此方差比较小
    在这里插入图片描述

    1. 学习Qπ()Q_π()
      上面是学习状态的价值Vπ(s)V_π(s),实际上更常用的方式是求解状态s下动作a的价值Qπ(s,a)Q_π(s,a),对于此DQN结构,有两种构建方式,一种是输入状态s,输出该状态下没每一种动作的价值。一种是输入状态s和动作a,输出状态s下执行动作a的价值:
      输入状态s,输出该状态下没每一种动作的价值
      输入状态s和动作a,输出状态s下执行动作a的价值
      神经网络输出的价值Q(s,a)Q(s,a),假设我们再状态s下有一个动作:(s,a),执行完到达状态s’,继续执行a’达到(s’,a’)。通过神经网络可以求出Q(s,a)Q(s,a)Q(s,a)Q(s',a'),其中Q(s,a)=r+γmax[Q(s,a)]Q_*(s,a)=r+γmax[Q(s',a')],则可根据Q(s,a)Q(s,a)Q_*(s,a)与Q(s,a)的差距来对QQ进行学习。这与Q-learning的思路是一致的。

    但上面算法中,也有一些与与Q-learning不同的地方,这是使DQN变得更加有效和技巧:

    1. target network
      目标是学习网络QQ,我们记录为eval network。根据公式,更新时需要求解Q(s,a)=r+γmax[Q(s,a)]Q_*(s,a)=r+γmax[Q(s',a')],这里的Q(s,a)=Qπ(st+1,π(st+1))Q(s',a')=Q^\pi(s_{t+1},\pi(s_{t+1})),是网络在St+1S_{t+1}的输出,由于网络的eval network一直在更新,导致Q(s,a)Q_*(s,a)Q(s,a)Q(s,a)一直在变化的,是会是训练十分不稳定。
      解决办法是我们使用一个与eval network结构相同的target network来计算Q(s,a)Q_*(s,a)。其中target network使用的eval network较老的参数,eval network每训练n次才更新一次target network(方式是直接将eval network的参数赋值给target network)。这样在一定时间内就相当于固定了Q(s,a)Q_*(s,a),使得训练变得稳定。
      在这里插入图片描述
    2. replay buffer
      把之前与环境互动的记录 (st,at,rt,st+1)放到一个buffer里面,随机抽取buffer中的n条记录来训练神经网络。
      其中buffer里面的记录可能来自采取不同时期的神经网络。比如互动产生10000个(st,at,rt,st+1)后就更新一次网络参数,buffer的储存上限为50000个(st,at,rt,st+1),这使得buffer中可能储存着之前5次更新神经网络的产生的记录。
      这样做的好处是buffer中的记录可以反复被使用,减少了交互所浪费的时间。同时增加数据多样性,降低batch内相关性,提高泛化性能,训练效果更好。
      在这里插入图片描述

    三、DQN Agent代码

    此处直接参考莫烦python的强化学习教程进行代码编写,在基础上说明每一行代码的用途
    采用此种神经网络结构:
    在这里插入图片描述

    import numpy as np
    import pandas as pd
    import tensorflow as tf
    from maze_env_drl import Maze    #即为environment
    
    class DeepQNetwork(object):
        #replace_target_iter为更新target network的步数,防止target network和eval network差别过大
        #memory_size为buffer储存记忆上线,方便使用以前记忆学习
        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=False):
            self.n_actions = n_actions
            self.n_features = n_features
            self.lr = learning_rate
            self.gamma = reward_decay
            self.epsilon_max = e_greedy     # epsilon后面奖励对前面的递减参数
            self.replace_target_iter = replace_target_iter  # 更换 target_net 的步数
            self.memory_size = memory_size  # 记忆上限
            self.batch_size = batch_size    # 每次更新时从 memory 里面取多少记忆出来
            self.epsilon_increment = e_greedy_increment # epsilon 的增量
            #epsilon = 0等于0时,后面的奖励创传不到前面,前面的状态就开启随机探索模式
            self.epsilon = 0 if e_greedy_increment is not None else self.epsilon_max # 是否开启探索模式, 并逐步减少探索次数
            
            # 记录学习次数 (用于判断是否更换 target_net 参数)
            self.learn_step_counter = 0
            
            # 初始化全 0 记忆 [s, a, r, s_], 实际上feature为状态的维度,n_features*2分别记录s和s_,+2记录a和r
            self.memory = np.zeros((self.memory_size, n_features*2+2))
            #构建网络
            self._build_net()
            
            #替换 target net 的参数
            t_params = tf.get_collection('target_net_params')  #提取 target_net 的参数
            e_params = tf.get_collection('eval_net_params')   # 提取  eval_net 的参数
            #将eval_network中每一个variable的值赋值给target network的对应变量
            self.replace_target_op = [tf.assign(t, e) for t, e in zip(t_params, e_params)] #更新 target_net 参数
            
            
            self.sess = tf.Session()
            
            if output_graph:
                tf.summary.FileWriter("logs/", self.sess.graph)
            
            self.sess.run(tf.global_variables_initializer())
            #用于记录# 记录所有 cost 变化
            self.cost_his = []
        
        #李宏毅老师克重的relpay buffer,通过以往的记忆中不断训练
        #这是DQN变为off-policy的核心
        def store_transition(self, s, a, r, s_):
            #如果DeepQNetwork中定义了memory_counter,进行记忆存储
            if not hasattr(self, 'memory_counter'):
                self.memory_counter = 0
            
            #记录一条 [s, a, r, s_] 记录
            transition = np.hstack((s, [a, r], s_))
            
            #总 memory 大小是固定的, 如果超出总大小, 旧 memory 就被新 memory 替换
            index = self.memory_counter % self.memory_size  #类似hashmap赋值思想
            self.memory[index, :] = transition  #进行替换
            
            self.memory_counter += 1
            
        #建立神经网络
        #此处建立两个申请网络,一个为target network,用于得到q现实。一个为eval_network,用于得到q估计
        #target network和eval_network结构一样,target network用比较老的参数,eval_network为真正训练的神经网络
        def _build_net(self):
            tf.reset_default_graph()  #清空计算图
            
            #创建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的值, 这个之后会通过计算得到,神经网络的输出
            #eval_net域下的变量
            with tf.variable_scope('eval_net'):
                #c_names用于在一定步数之后更新target network
                #GLOBAL_VARIABLES作用是collection默认加入所有的Variable对象,用于共享
                c_names = ['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES]
                n_l1 = 10  #n_l1为network隐藏层神经元的个数 
                w_initializer = tf.random_normal_initializer(0.,0.3)  
                b_initializer = tf.constant_initializer(0.1)
                
                #eval_network第一层全连接神经网络
                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_network第二层全连接神经网络
                with tf.variable_scope('l1'):
                    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)
                    #求出q估计值,长度为n_actions的向量
                    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'):    # 梯度下降
                optimizer = tf.train.RMSPropOptimizer(self.lr)
                self._train_op = optimizer.minimize(self.loss)
            
            #创建target network,输入选择一个action后的状态s_,输出q_target
            self.s_ = tf.placeholder(tf.float32, [None, self.n_features], name='s_')    # 接收下个 observation
            with tf.variable_scope('target_net'):
                c_names = ['target_net_params', tf.GraphKeys.GLOBAL_VARIABLES]
                
                # target_net 的第一层fc, 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 的第二层fc
                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 choose_action(self, observation):
            #根据observation(state)选行为
            #使用eval network选出state下的行为估计
            #将observation的shape变为(1, size_of_observation),行向量变为列向量才能与NN维度统一
            observation = observation[np.newaxis, :]
            
            if np.random.uniform() < self.epsilon:
                action_value = self.sess.run(self.q_eval, feed_dict={self.s:observation})
                action = np.argmax(action_value)
                
            else:
                action = np.random.randint(0, self.n_actions)   #随机选择
            
            return action
        
        def learn(self):
            if self.learn_step_counter % self.replace_target_iter ==0:
                self.sess.run(self.replace_target_op)
                print('\ntarget_params_replaced\n')
            
            #从memory中随机抽取batch_size这么多记忆
            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现实(target_net产生的q)和q_eval(eval_net产生的q)
            #q_next和q_eval都是一个向量,包含了对应状态下所有动作的q值
            #实际上feature为状态的维度,batch_memory[:, -self.n_features:]为s_,即状态s采取动作action后的状态s_, batch_memory[:, :self.n_features]为s
            q_next, q_eval = self.sess.run([self.q_next, self.q_eval], feed_dict={self.s_: batch_memory[:, -self.n_features:],self.s: batch_memory[:, :self.n_features]})
            
            #下面这几步十分重要. 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, 而action0带来的 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 位置, 所以就将 q_target的1放在了 action0的位置.
            
            # 下面也是为了达到上面说的目的, 不过为了更方面让程序运算, 达到目的的过程有点不同.# 是将 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 就可以变成我们所需的样子.
            
            q_target = q_eval.copy()
            #每个样本下标
            batch_index = np.arange(self.batch_size, dtype=np.int32)
            #记录每个样本在st时刻执行的动作
            eval_act_index = batch_memory[:, self.n_features].astype(int)
            #记录每个样本动作的奖励
            reward = batch_memory[:, self.n_features + 1]
            
            #生成每个样本中q值对应动作的更新,即生成的q现实,
            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.copy()
            
            #然后根据memory当中的具体action位置来修改 q_target 对应 action 上的值:
            #比如在:记忆 0的q_target计算值是 -1,而且我用了action0;忆1的q_targe 计算值是-2, 而且我用了action2:
            #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 的值,
            _, 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) # 记录 cost 误差
            
            #每调用一次learn,降低一次epsilon,即行为随机性
            self.epsilon = self.epsilon + self.epsilon_increment if self.epsilon < self.epsilon_max else self.epsilon_max
            
            self.learn_step_counter += 1
            
        def plot_cost(self):
            import matplotlib.pyplot as plt
            plt.plot(np.arange(len(self.cost_his)), self.cost_his)
            plt.ylabel('Cost')
            plt.xlabel('training steps')
            plt.show()
    
    def run_maze():
        step = 0
        for episode in range(300):
            # 初始化环境
            observation = env.reset()
            
            while True:
                # 刷新环境
                env.render()
                
                # DQN 根据观测值选择行为
                action = RL.choose_action(observation)   #一种off-poliy的方法
                
                # 环境根据行为给出下一个 state, reward, 是否终止
                observation_, reward, done = env.step(action)
                
                # DQN 存储记忆
                #即存在李宏毅老师课中的replay buffer,便于使用以前的记忆训练
                RL.store_transition(observation, action, reward, observation_)   
                
                # 控制学习起始时间和频率 (先累积一些记忆再开始学习)
                if (step>200) and (step % 5 == 0):
                    RL.learn()
                
                # 将下一个 state_ 变为 下次循环的 state
                observation = observation_
                
                # 如果终止, 就跳出循环
                if done:
                    break
                
                step+=1
        
        print('game over')
        env.destroy()
        
    if __name__=="__main__":
        env = Maze()
        #replace_target_iter为更新target network的步数,即莫烦中的fixed Q-targets
        #memory_size为replay buffer的储存上限,用于不在实际交互下也能进行训练,即莫烦中的memory
        RL = DeepQNetwork(env.n_actions,env.n_features,learning_rate=0.01,reward_decay=0.9,e_greedy=0.9,replace_target_iter=200,memory_size=2000,output_graph=True)
        
        env.after(100, run_maze)
        env.mainloop()
        RL.plot_cost()
    
    展开全文
  • DQN算法原理详解

    2019-05-22 21:27:00
    常见的是以DQN为代表的value based算法,这种算法中只有一个值函数网络,没有policy网络,以及以DDPG,TRPO为代表的actor-critic算法,这种算法中既有值函数网络,又有policy网络。 说到DQN中有值函数网络,这里简单...

     

    一、 概述

    强化学习算法可以分为三大类:value based, policy based 和 actor critic。

    常见的是以DQN为代表的value based算法,这种算法中只有一个值函数网络,没有policy网络,以及以DDPG,TRPO为代表的actor-critic算法,这种算法中既有值函数网络,又有policy网络。

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

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

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

    二、算法原理

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

    DQN使用神经网络来近似值函数,即神经网络的输入是state s,输出是Q(s,a),aA (action space)。通过神经网络计算出值函数后,DQN使用ϵgreedy策略来输出action(第四部分中介绍)。值函数网络与ϵgreedy策略之间的联系是这样的:首先环境会给出一个obs,智能体根据值函数网络得到关于这个obs的所有Q(s,a),然后利用ϵ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+γmaxaQ(s,a;ω)Q(s,a;ω))2]这个公式表面上看起来很复杂,实际上很好理解,它就是一个残差模型,和我们平常见的最小二乘法很类似,真实值与预测值之间的差的平方。预测值就是Q(s,a;ω),它是神经网络的输出。“真实值”略微有一点复杂。

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

    另一种情况就是Model Free RL:不管有没有环境模型,反正我不用。那么在不知道环境模型的情况下如何求解值函数呢?答案就是采样

     

    强化学习中有多种采样的方法:

    (1) Monte Carlo

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

    (2) Temporal Difference / SarSa

     

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

    另外还有TD(λ或 SarSa(λ))方法,DQN中不涉及。

     

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

    (1) SarSa

     

    SarSa中更新值函数的公式为:Q(s,a)Q(s,a)+α[R+γQ(s,a)Q(s,a)]也称它的target是 Rt+1+γQ(St+1,at+1)。理解这个target代表的意义:

    转载于:https://www.cnblogs.com/shona/p/10908618.html

    展开全文
  • 深度Q学习将深度学习和强化学习相结合,是第一个深度强化学习算法。深度Q学习的核心就是用一个人工神经网络q(s,a;w),s∈S,a∈Aq(s,a;w),s∈\mathcal{S} ,a∈\mathcal{A}q(s,a;w),s∈S,a∈A 来代替动作价值函数。由于...

    深度Q学习

    深度Q学习将深度学习和强化学习相结合,是第一个深度强化学习算法。深度Q学习的核心就是用一个人工神经网络q(s,a;w),sS,aAq(s,a;w),s∈\mathcal{S} ,a∈\mathcal{A} 来代替动作价值函数。由于神经网络具有强大的表达能力,能够自动寻找特征,所以采用神经网络有潜力比传统人工特征强大得多。最近基于深度Q网络的深度强化学习算法有了重大的进展,在目前学术界有非常大的影响力。
    ·经验回放(experience replay):将经验(即历史的状态、动作、奖励等)存储起来,再在存储的经验中按一定的规则采样。
    ·目标网络(target network):修改网络的更新方式,例如不把刚学习到的网络权重马上用于后续的自益过程。

    经验回放

    V.Mnih等在2013年发表文章《Playing Atari with deep reinforcement learning》,提出了基于经验回放的深度Q网络,标志着深度Q网络的诞生,也标志着深度强化学习的诞生。
    采用批处理的模式能够提供稳定性。经验回放就是一种让经验的概率分布变得稳定的技术,它能提高训练的稳定性。经验回放主要有“存储”和“采样回放”两大关键步骤。

    ·存储:将轨迹以(St,At,Rt+1,St+1)(S_t,A_t,R_{t+1},S_{t+1})等形式存储起来;

    ·采样回放:使用某种规则从存储的(St,At,Rt+1,St+1)(S_t,A_t,R_{t+1},S_{t+1})中随机取出一条或多条经验。

    算法9给出了带经验回放的Q学习最优策略求解算法。

    算法9 带经验回放的Q学习最优策略求解
    1.(初始化)任意初始化参数ww
    2.逐回合执行以下操作。
    2.1 (初始化状态动作对)选择状态SS
    2.2 如果回合未结束,执行以下操作:
    2.2.1 (采样)根据q(S,;w)q(S,·;w)选择动作A并执行,观测得到奖励R和新状态S’;
    2.2.2 (存储)将经验(S,A,R,S)(S,A,R,S')存入经验库中;
    2.2.3 (回放)从经验库中选取经验(Si,Ai,Ri,Si)(S_i,A_i,R_i,S_i')
    2.2.4 (计算回报的估计值)UiRi+γmaxaq(Si,a;w)Ui←Ri+γmaxaq(S_i',a;w)
    2.2.5 (更新动作价值函数)更新ww以减小Uiq(Si,Ai;w)2ww+αUiq(Si,Ai;w)q(Si,Ai;w)[U_{i} -q (Si,Ai;w)]^2(如w←w+α[U_i-q(S_i,A_i;w)]▽q(S_i,A_i;w))
    2.2.6 SSS←S'

    经验回放有以下好处。

    ·在训练Q网络时,可以消除数据的关联使得数据更像是独立同分布的(独立同分布是很多有监督学习的证明条件)这样可以减小参数更新的方差,加快收敛

    ·能够重复使用经验,对于数据获取困难的情况尤其有用。从存储的角度,经验回放可以分为集中式回放和分布式回放。

    ·集中式回放:智能体在一个环境中运行,把经验统一存储在经验池中。

    ·分布式回放:智能体的多份拷贝(worker)同时在多个环境中运行,并将经验统一存储于经验池中。由于多个智能体拷贝同时生成经验,所以能够在使用更多资源的同时更快地收集经验。

    从采样的角度,经验回放可以分为均匀回放和优先回放。

    ·均匀回放:等概率从经验集中取经验,并且用取得的经验来更新最优价值函数。

    ·优先回放(Prioritized Experience Replay,PER):为经验池里的每个经验指定一个优先级,在选取经验时更倾向于选择优先级高的经验。

    T.Schaul等于2016年发表文章《Prioritized experience replay》,提出了优先回放。优先回放的基本思想是为经验池里的经验指定一个优先级,在选取经验时更倾向于选择优先级高的经验。一般的做法是,如果某个经验(例如经验i)的优先级为pip_i,那么选取该经验的概率为
    在这里插入图片描述
    经验值有许多不同的选取方法,最常见的选取方法有成比例优先和基于排序优先。

    ·成比例优先(proportional priority):第i个经验的优先级为pi=(δi+ε)αp_i=(δ_i+ε)α其中δiδ_i是时序差分误差,εε是预先选择的一个小正数,αα是正参数。

    ·基于排序优先(rank-based priority):第i个经验的优先级为
    在这里插入图片描述
    其中rankirank_i是第i个经验从大到小排序的排名,排名从1开始。D.Horgan等在2018发表文章《Distributed prioritized experience replay》,将分布式经验回放和优先经验回放相结合,得到分布式优先经验回放(distributed prioritized experience replay)。经验回放也不是完全没有缺点。例如,它也会导致回合更新和多步学习算法无法使用。一般情况下,如果我们将经验回放用于Q学习,就规避了这个缺点。

    带目标网络的深度Q学习

    对于基于自益的Q学习,其回报的估计和动作价值的估计都和权重ww有关。当权重值变化时,回报的估计和动作价值的估计都会变化。在学习的过程中,动作价值试图追逐一个变化的回报,也容易出现不稳定的情况。在半梯度下降中,在更新价值参数ww时,不对基于自益得到的回报估计Ut求梯度。其中一种阻止对Ut求梯度的方法就是将价值参数复制一份得到ww目标,在计算UtU_t时用w目标计算。基于这一方法,V.Mnih等在2015年发表了论文《Human-level control through deep reinforcement learning》,提出了目标网络(target network)这一概念。目标网络是在原有的神经网络之外再搭建一份结构完全相同的网络。原先就有的神经网络称为评估网络(evaluation network)。在学习的过程中,使用目标网络来进行自益得到回报的评估值,作为学习的目标。在权重更新的过程中,只更新评估网络的权重,而不更新目标网络的权重。这样,更新权重时针对的目标不会在每次迭代都变化,是一个固定的目标。在完成一定次数的更新后,再将评估网络的权重值赋给目标网络,进而进行下一批更新。这样,目标网络也能得到更新。由于在目标网络没有变化的一段时间内回报的估计是相对固定的,目标网络的引入增加了学习的稳定性。所以,目标网络目前已经成为深度Q学习的主流做法。
    算法10给出了带目标网络的深度Q学习算法。算法开始时将评估网络和目标网络初始化为相同的值。为了得到好的训练效果,应当按照神经网络的相关规则仔细初始化神经网络的参数。

    算法10 带经验回放和目标网络的深度Q学习最优策略求解
    1.(初始化)初始化评估网络q(,;w)q(·,·;w)的参数w;目标网络q(,;w)q(·,·;w_{目标})的参数www_{目标}←w
    2.逐回合执行以下操作。
    2.1 (初始化状态动作对)选择状态SS
    2.2 如果回合未结束,执行以下操作:
    2.2.1 (采样)根据q(S,;w)q(S,·;w)选择动作A并执行,观测得到奖励R和新状态S’;
    2.2.2 (经验存储)将经验(S,A,R,S)(S,A,R,S')存入经验库中;
    2.2.3 (经验回放)从经验库中选取一批经验(Si,Ai,Ri,Si)iB(S_i,A_i,R_i,S_i')(i∈ \mathcal{B})
    2.2.4 (计算回报的估计值)
    在这里插入图片描述
    2.2.5 (更新动作价值函数)更新以减小在这里插入图片描述
    2.2.6 SSS←S'
    2.2.7 (更新目标网络)在一定条件下(例如访问本步若干次)更新目标网络的权重www_{目标}←w

    在更新目标网络时,可以简单地把评估网络的参数直接赋值给目标网络(即www_{目标}←w),也可以引入一个学习率α目标把旧的目标网络参数和新的评估网络参数直接做加权平均后的值赋值给目标网络(即w(1α)w+αww_{目标}←(1-α_{目标})w_{目标}+α_{目标}w)。事实上,直接赋值的版本是带学习率版本在α=1α_{目标}=1时的特例。对于分布式学习的情形,有很多独立的拷贝(worker)同时会修改目标网络,则就更常用学习率α(0,1)α_{目标}∈(0,1)

    双重深度Q网络

    Q学习会带来最大化偏差,而双重Q学习却可以消除最大化偏差。基于查找表的双重Q学习引入了两个动作价值的估计q(0)q(1)q^{(0)}和q^{(1)},每次更新动作价值时用其中的一个网络确定动作,用确定的动作和另外一个网络来估计回报。

    对于深度Q学习也有同样的结论。Deepmind于2015年发表论文《Deep reinforcement learning with double Q-learning》,将双重Q学习用于深度Q网络,得到了双重深度Q网络(Double Deep Q Network,Double DQN)。考虑到深度Q网络已经有了评估网络和目标网络两个网络,所以双重深度Q学习在估计回报时只需要用评估网络确定动作,用目标网络确定回报的估计即可。所以,只需要将算法10中的
    在这里插入图片描述
    更换为
    在这里插入图片描述
    就得到了带经验回放的双重深度Q网络算法。

    对偶深度Q网络

    Z.Wang等在2015年发表论文《Dueling network architectures for deep reinforcement learning》,提出了一种神经网络的结构——对偶网络(duel network)。对偶网络理论利用动作价值函数和状态价值函数之差定义了一个新的函数——优势函数(advantage function)
    在这里插入图片描述
    对偶Q网络仍然用q(w)q(w)来估计动作价值,只不过这时候q(w)q(w)是状态价值估计v(s;w)v(s;w)和优势函数估计a(s,a;w)a(s,a;w)的叠加,即q(s,a;w)=v(s;w)+a(s,a;w)q(s,a;w)=v(s;w)+a(s,a;w)
    其中v(wv(w)和a(w)a(w)可能都只用到了ww中的部分参数。在训练的过程中,v(w)v(w)a(w)a(w)是共同训练的,训练过程和单独训练普通深度Q网络并无不同之处。
    不过,同一个q(w)事实上存在着无穷多种分解为v(w)和a(w)的方式。如果某个q(s,a;w)q(s,a;w)可以分解为某个v(s;w)a(s,a;w)v(s;w)和a(s,a;w),那么它也能分解为v(s;w)+c(s)v(s;w)+c(s)a(s,a;w)c(s)a(s,a;w)-c(s),其中c(s)c(s)是任意一个只和状态ss有关的函数。为了不给训练带来不必要的麻烦,往往可以通过增加一个由优势函数导出的量,使得等效的优势函数满足固定的特征,使得分解唯一。常见的方法有以下两种:
    ·考虑优势函数的最大值,令
    在这里插入图片描述
    使得等效优势函数a(s,a;w)=a(s,a;w)maxa(s,a;w)a_{等效}(s,a;w) = a(s,a;w)-\max{a(s,a;w)}满足
    在这里插入图片描述
    ·考虑优势函数的平均值,令
    在这里插入图片描述
    使得等效优势函数a(s,a;w)=a(s,a;w)1Aa(s,a;w)a_{等效}(s,a;w)=a(s,a;w)-\dfrac{1}{|{A}|}\sum{a(s,a;w)}满足
    在这里插入图片描述

    展开全文
  • 利用神经网络近似值函数的方法表示为: V^(s,w)≈Vπ(s)q^(s,a,w)≈qπ(s,a) ... 以及如何从端到端的过程,本文将讲解Deep Q Network(DQN, 而这正是由DeepMind于2013年和2015年分别提出的两篇论文《Playi
  • 文章目录前言一、DQN算法原理二、DQN算法代码部分1.网络结构2.经验存储函数3.动作选择函数4.DQN算法训练 前言 DQN算法是一种深度强化学习算法(Deep Reinforcement Learning,DRL),DQN算法是深度学习(Deep ...
  • Double DQN算法实战

    2020-12-22 15:29:01
    食用本篇之前,需要有DQN算法的基础,参考DQN算法实战。 原理简介 Double-DQN是2016年提出的算法,灵感源自2010年的Double-Qlearning,可参考论文Deep Reinforcement Learning with Double Q-learning。 跟Nature ...
  • DQN算法实战

    千次阅读 2020-11-28 10:08:57
    本文不赘述DQN原理,可先看Q-learning以及DQN其他相关文章,参考比如datawhale李宏毅笔记-Q学习。 实战的意思就是撸出代码来,在简单了解原理的基础上,根据论文分析 Human-level control through deep ...
  • 本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程 ...DQN算法原理和Agent实现 Double-DQN、Dueling DQN结构原理和Agent实现 Policy Gradients算法原理和Agent实现 A2C、A3C算法原理和Age...
  • DQN算法及案例:如何使用DQN实现走迷宫算法原理案例详解 算法原理 在了解DQN之前,我们需要知道值函数近似这一思想。 值函数近似:在数据较大情况下,根据s&a去查询Q值会比较困难。值函数近似是输入s和a,近似地...
  • 本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程 本系列主要分几个部分进行...Double-DQN、Dueling DQN算法原理和Agent实现 Policy Gradients算法原理和Agent实现 A2C、A3C算法原理和Age...
  • 本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程 ...DQN算法原理和Agent实现 Double-DQN算法原理和Agent实现 Policy Gradients算法原理和Agent实现 A2C、A3C算法原理和Agent实现 一、SARS...
  • 本文主要介绍DQN算法的基本原理,以及在它基础上改进的DDQN和Dueling DQN,介绍完后会结合对应的PARL代码进行解析说明(PARL 是一个高性能、灵活的强化学习框架)。 三篇相关的论文地址如下,接下去的三个小节会围绕...
  • 在之前的文章中,我们做了如下工作: 如何设计一个类flappy-bird小游戏:【python实战】使用pygame写一个flappy-bird类小游戏...其基本原理:无需公式或代码,用生活实例谈谈AI自动控制技术“强化学习”算法框架 本节开
  • 本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程 本系列主要分几个部分进行介绍 ...Double-DQN、Dueling DQN算法原理和Agent实现(tensorflow) Policy Gradients算法原理...
  • 文章目录Q-learning原理图Q-learning算法描述:pytorch实现:Q-network实现:DQN实现:2个Q-network,其中一个为target Q-network;take action获取下一步的动作,这个部分就是和环境互动的部分,选取动作是基于e-...
  • 在前面的章节中我们介绍了时序差分算法(TD)和Q-Learning,当状态和动作空间是离散且维数不高时可使用Q-Table储存每个状态动作对的Q值,而当状态和动作空间是高维连续时,使用Q-Table不动作空间和状态太大十分困难...
  • 本论文是由DeepMind操刀,Schaul主导完成的文章,发表于顶会ICLR2016上,主要解决经验回放中的”采样问题“(在DQN算法中使用了经典的”experience replay“,但存在一个问题是其采用均匀采样和批次更新,导致特别少...
  • DQN解决cartpole原理

    千次阅读 2018-11-01 15:52:19
    DQN算法更新附录(莫凡代码) 当学习状态空间很大,例如围棋的学习中,由于状态空间过大导致Q表远远超过内存,所以在复杂学习情况下Q表更新并不适用。 取而代之的是用神经网络当做Q表使用,第一种神经网络是输入状态...
  • 本文主要整理和参考了李宏毅的强化学习系列课程和莫烦python的强化学习教程 本系列主要分几个部分进行...Double-DQN、Dueling DQN算法原理和Agent实现 Policy Gradients算法原理和Agent实现 A2C、A3C算法原理和Age...
  • 有关DQN算法以及各种改进算法的原理和实现,可以参考之前的文章: 实战深度强化学习DQN-理论和实践:https://www.jianshu.com/p/10930c371cac DQN三大改进(一)-Double DQN:https://www.jianshu.com/p/fae51b5fe000...
  • 本文是DeepMind发表于ICML2016顶会的文章(获得Best Paper奖),第一作者Ziyu Wang(第四作Hado Van Hasselt就是前几篇文章#Double Q-learning#,Double DQN的作者),可以说DeepMind开创了DQN系列算法(后续阐述Open...

空空如也

空空如也

1 2 3 4
收藏数 73
精华内容 29
关键字:

dqn算法原理