精华内容
下载资源
问答
  • 强化学习DQN

    2018-05-25 14:53:15
    这本书详细介绍了强化学习的常用算法以及算法原理,从蒙特卡罗方法到Q_learning最终到DQN
  • 深度强化学习DQN训练Flappy Bird源代码,可以直接运行FlappyBirdDQN.py使用。
  • 具体内容请看: 深度强化学习DQN详解 深度强化学习—DQN 深度强化学习入门

    1.DQN算法

    关于DQN详细算法请参考:
    深度强化学习DQN详解
    深度强化学习—DQN
    深度强化学习入门

    2.DQN源代码

    源代码中一共有三个主要.py文件。

    BrainDQN_Nature.py和BrainDQN_NIPS.py主要定义网络结构,FlappyBirdDQN.py是训练文件,FlappyBirdDQN的源代码如下所示,可以直接运行。

    # -------------------------
    # Project: Deep Q-Learning on Flappy Bird
    # Author: Flood Sung
    # Date: 2016.3.21
    # -------------------------
    
    import cv2
    import sys
    sys.path.append("game/")
    import wrapped_flappy_bird as game
    from BrainDQN_Nature import BrainDQN
    import numpy as np
    
    # preprocess raw image to 80*80 gray image
    def preprocess(observation):
    	observation = cv2.cvtColor(cv2.resize(observation, (80, 80)), cv2.COLOR_BGR2GRAY)
    	ret, observation = cv2.threshold(observation,1,255,cv2.THRESH_BINARY)
    	return np.reshape(observation,(80,80,1))
    
    def playFlappyBird():
    	# Step 1: init BrainDQN
    	actions = 2
    	brain = BrainDQN(actions)
    	# Step 2: init Flappy Bird Game
    	flappyBird = game.GameState()
    	# Step 3: play game
    	# Step 3.1: obtain init state
    	action0 = np.array([1,0])  # do nothing
    	observation0, reward0, terminal = flappyBird.frame_step(action0)
    	observation0 = cv2.cvtColor(cv2.resize(observation0, (80, 80)), cv2.COLOR_BGR2GRAY)
    	ret, observation0 = cv2.threshold(observation0,1,255,cv2.THRESH_BINARY)
    	brain.setInitState(observation0)
    
    	# Step 3.2: run the game
    	while 1!= 0:
    		action = brain.getAction()
    		nextObservation,reward,terminal = flappyBird.frame_step(action)
    		nextObservation = preprocess(nextObservation)
    		brain.setPerception(nextObservation,action,reward,terminal)
    
    def main():
    	playFlappyBird()
    
    if __name__ == '__main__':
    	main()
    		
    
    

    3.实验结果

    跑了好久,大约训练了三个小时吧,这个bird终于学会飞了。
    本博文所用源代码链接:https://download.csdn.net/download/qq_29462849/10776375,可以直接运行。

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 深度强化学习系列论文,包括最基础的DQNDQN模型改进,DQN算法改进,分层DRL,基于策略梯度的深度强化学习等等,论文基本源自顶会
  • 强化学习DQN并玩CartPole游戏 1、强化学习 一张经典的关于强化学习的图。 一个代理(Agent)存在一个空间中,并观察环境,得到该环境的状态(observation),于是做出一个动作(action),一旦发出了动作则会改变...

    强化学习DQN并玩CartPole游戏

    1、强化学习

    在这里插入图片描述

    一张经典的关于强化学习的图。

    一个代理(Agent)存在一个空间中,并观察环境,得到该环境的状态(observation),于是做出一个动作(action),一旦发出了动作则会改变环境,环境的改变则产生一个回报(reward)给代理,回报有正有负、有大有小。

    强化学习是,让代理在该环境中生存。不断地试错,以试图获取最大的回报。

    这便是强化学习的过程。

    2、马尔科夫链

    在代理不断地观察环境做出动作得到回报,观察环境做出动作得到回报,…,观察环境做出动作得到回报中。

    这是一步一步的离散的动作着的,于是构成了一条马尔可夫链。

    马尔可夫链(Markov chain),又称离散时间马尔可夫链(discrete-time Markov chain),为离散的序列链条,为状态空间中经过从一个状态到另一个状态的转换的随机过程。

    不过马尔科夫链要求具备“无记忆”的性质:下一状态的概率分布只能由当前状态决定,在时间序列中它前面的事件均与之无关。
    P(xtxt1,xt2,...,xtn)=P(xtxt1) P(x_{t}|x_{t-1},x_{t-2},...,x_{t-n})=P(x_{t}|x_{t-1})
    即从状态xt1x_{t-1}转移到状态xtx_{t}的概率,只和上一状态xt1x_{t-1}有关,而和之前的没有关系。

    3、贝尔曼方程

    那么在一个状态到另一状态的转变过程中,应该选择什么样的动作呢?

    我们可以预测回报的多少来进行决策,选择那一个动作,即那一动作回报多则选择那一动作。

    但是当前的回报并非我们最终的目标。

    比如,在围棋中,有一围棋死活问题中一种独特的棋形,倒脱靴。

    在这里插入图片描述

    在如图的例子中,白8提掉黑四子后,黑棋第九手走到△的位置上,反吃掉白三子,成为活棋。

    对黑棋来讲是先得到负回报,然后在得到极大的正回报。故需要看到未来的一个回报,而非仅仅眼前的利益(当前的正回报可能会造成最终的负回报,输掉整盘棋)。

    于是定义R为最终的参考回报,rtr_{t}为立即回报。于是R应该等于当前时刻的立即回报,同时要加上下一时刻、下下时刻、…、一直到最终:
    Rt=rt+rt+1+rt+2+...+rt+n R_{t} = r_{t} + r_{t+1} + r_{t+2}+...+r_{t+n}
    但未来的事情尚未发生。过多考虑未来的不稳定的事情,容易造成前期的崩溃。基于这种不确定性,故需要加上一个衰减的系数。于是得:
    Rt=rt+γrt+1+γ2rt+2+...+γnrt+n R_{t} = r_{t} + \gamma r_{t+1} + \gamma^{2}r_{t+2}+...+\gamma^{n}r_{t+n}
    此为贝尔曼方程,也称价值方程。

    γ\gamma 取值0~1。

    γ\gamma取0的话,就是过分短视,只参考当前回馈,就如认为世事无常及时行乐的人。

    γ\gamma取1的话,则是过分考虑长远,而不顾当前回馈的恶化,导致无法抵达遥远未来。

    则未来离得越远,则参考的价值越小,除非未来的回报足够大。

    R能求解出来吗?在未来不确定情况下,无法计算,是无解的。

    但未来可期,可通过其期望来求解。虽然每一个回报是不稳定的,但是期望是稳定的。

    则:
    V=E(Rt) V = E(R_{t})
    回报的期望,为价值。

    4、Q函数

    Rt=rt+γrt+1+γ2rt+2+...+γnrt+n=rt+γ(rt+1+γ(rt+2+...))=rt+γRt+1 R_{t} = r_{t} + \gamma r_{t+1} + \gamma^{2}r_{t+2}+...+\gamma^{n}r_{t+n} \\=r_{t} + \gamma (r_{t+1} + \gamma (r_{t+2}+...))\\ =r_{t} + \gamma R_{t+1}

    贝尔曼方程可变形为上式。

    那么当我们考虑当前状态下,选择某一动作能够带来的价值时,应该为下式:
    Q(s,a)=r+γmaxaQ(s,a) Q(s,a) = r + \gamma max_{a^{'}}Q(s^{'},a^{'})
    即:某一状态下选择的某一动作的价值 = 环境反馈回的回报 + 下一状态下能带来的最大价值 X 衰减值。

    此为Q函数

    但是在我们不知道未来如何的时候,为了知道每一状态下、每一动作的价值,则需要多次试验。

    举例一个经典小游戏说明:

    在这里插入图片描述

    一个小游戏,机器人随机放置在任意房间里,标识为0、1、2、3、4。现在需要走出外界,标识为5。

    于是将每一个房间标识为一个节点。可以画出状态转移图形为:

    在这里插入图片描述

    我们规定,当机器人走到户外,即状态5时,获得奖励100。则图为:

    在这里插入图片描述

    将其写为矩阵,为:

    在这里插入图片描述

    这是当处在何种状态,然后选择何种动作,给出何种回报的回报矩阵。

    例如,当机器人处在房间3时,可采取的动作为1、2、4,当采取动作1时,回报为0。当机器人处在房间4时,如果采取动作5,则返回回报100;如果是采取动作3,则回报为0。



    至此,我们需要计算出每一个状态下,每一种行动的价值。比如这样:

    在这里插入图片描述

    如此便能非常容易的选择什么样的策略,即价值最大的动作。

    但是当我们的价值未知的时候,则定义一个零矩阵,通过回报矩阵,迭代优化它。

    在这里插入图片描述



    由Q函数,可知该矩阵如何优化:
    Q[st,a]=R[st,a]+γmax(Q(st+1,:)) Q[s_{t},a] = R[s_{t},a] + \gamma max(Q(s_{t+1},:))
    即更新当前状态选择的当前动作的价值时,等于此时的回报(当前状态选择的当前动作的回报)加上价值矩阵中的转移至下一状态的最大价值。

    于是在python中定义如下回报矩阵和价值矩阵:

    import numpy as np
    import random
    
    """初始化价值矩阵"""
    Q = np.zeros((6, 6))
    
    """定义回报矩阵R"""
    R = np.array([[-1, -1, -1, -1,  0,  -1],
                  [-1, -1, -1,  0, -1, 100],
                  [-1, -1, -1,  0, -1,  -1],
                  [-1,  0,  0, -1,  0,  -1],
                  [ 0, -1, -1,  0, -1, 100],
                  [-1,  0, -1, -1,  0, 100]])
    

    定义未来远见系数为0.8:

    gamma = 0.8
    

    然后迭代求解价值矩阵Q,

    """迭代"""
    for i in range(20000):
        """对每一次迭代,随机选择一种状态作为初始"""
        state = random.randint(0, 5)
        while True:
            """选择当前状态下的所有可能动作"""
            actions = []
            for action in range(6):
                if R[state, action] >= 0:
                    actions.append(action)
    
            """随机选择一个可以行动的动作"""
            state_next = actions[random.randint(0, len(actions) - 1)]
    
            """更新Q矩阵,通过当前状态,下一状态,该状态转移的回报,和该状态转移的价值。"""
            Q[state, state_next] = R[state, state_next] + gamma * (Q[state_next]).max()
            state = state_next
            """游戏最大可行动次数,达到即结束"""
            if state == 5:
                break
    print((Q/Q.max()*100).astype(np.int))
    

    将最后的结果归化至百分比值:

    在这里插入图片描述

    如此就能指导该机器人如何行动了。

    但这只能解决状态有限,动作有限的问题。因为Q矩阵有明确的大小限制,只要有一样无限,则Q矩阵会无穷大,进而不能使用。甚至只要状态或是动作中有一个情况比较多时,则难以应用。例如游戏中,可进行的操作有限,但状态是无限的,每一帧的画面都是不同的,不可能穷举完。

    5、DQN

    DQN(Deep Q-Learning),因为Q学习只能解决状态有限动作有限的问题。

    Q矩阵只是为了得到某一个状态下、选择某一动作的估值。

    同时神经网络是一个万能的函数逼近器,只要足够大,能拟合任意函数。


    于是可以使用神经网络来代替Q矩阵。

    在这里插入图片描述

    通过输入状态,和动作得到该状态、动作下的估值。

    但当动作较多的时候,需要输入多次。

    在这里插入图片描述

    于是可以改为上图结构,输入状态,评估每一动作的价值。

    6、玩CartPole游戏

    gym平台上的CartPole游戏。游戏状态为二维向量,动作为0、1,控制杆子不掉下去。

    在这里插入图片描述

    则该网络输入为二维向量,输出也同样是二维向量,那么构建该网络:

    class DQNet(nn.Module):
    
        def __init__(self, num_state, num_actions):
            """
            初始化网络
            :param num_state: 输入状态数
            :param num_actions: 输出动作数
            """
            super(DQNet, self).__init__()
            self.layer = nn.Sequential(
                nn.Linear(num_state, 64),
                nn.LeakyReLU(),
                nn.Linear(64, 128),
                nn.LeakyReLU(),
                nn.Linear(2, num_actions)
            )
    
        def forward(self, input_):
            return self.layer(input_)
    



    然后根据Q矩阵的更新方式来更新神经网络。

    数据的获取,需要让网络先试玩游戏,以获取经验:

    experience_pool.append([state, R, action, state_next, done])
    

    根据经验来训练网络,则损失为:

    """得到当前状态,动作下的估计值"""
    valuations = q_net(state)
    valuation = torch.gather(valuations, dim=1, index=action)
    
    """得到下一状态的估计值,并选择最大的估值"""
    valuations_next = q_net(states_next)
    valuations_max = torch.max(valuations_next, dim=1, keepdim=True)[0]
    
    """当前状态的目标估值按照Q函数计算"""
    target = values + (1 - dons) * valuations_max * foresight
    
    """于是能够计算损失"""
    loss = loss_function(valuation, target.detach())
    

    AI游玩该游戏的效果。

    在这里插入图片描述
    代码

    展开全文
  • Playing Flappy Bird Using Deep Reinforcement Learning (Based on Deep Q Learning DQN)
  • 强化学习 DQN算法

    万次阅读 2018-11-05 11:59:10
    (以下内容取自莫凡大神的教程:https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/4-1-A-DQN/) ...传统的表格形式的强化学习有这样一个瓶颈,用表格来存储每一个状态 state, 和在...

    (以下内容取自莫凡大神的教程:https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/4-1-A-DQN/

    1,什么是DQN:

    一种融合了神经网络和 Q learning 的方法。

    2,为什么提出DQN:

    传统的表格形式的强化学习有这样一个瓶颈,用表格来存储每一个状态 state, 和在这个 state 每个行为 action 所拥有的 Q 值. 而当今问题是在太复杂, 状态可以多到比天上的星星还多(比如下围棋). 如果全用表格来存储它们, 恐怕我们的计算机有再大的内存都不够, 而且每次在这么大的表格中搜索对应的状态也是一件很耗时的事. 

    3,DQN的输入形式:

             可以将状态和动作当成神经网络的输入, 然后经过神经网络分析后得到动作的 Q 值, 这样我们就没必要在表格中记录 Q 值, 而是直接使用神经网络生成 Q 值.

            也能只输入状态值, 输出所有的动作值, 然后按照 Q learning 的原则, 直接选择拥有最大值的动作当做下一步要做的动作.

    4,神经网络的更新方式:

    基于第二种神经网络来分析, 我们知道, 神经网络是要被训练才能预测出准确的值. 那在强化学习中, 神经网络是如何被训练的呢? 首先, 我们需要 a1, a2 正确的Q值, 这个 Q 值我们就用之前在 Q learning 中的 Q 现实来代替. 同样我们还需要一个 Q 估计 来实现神经网络的更新. 所以神经网络的的参数就是老的 NN 参数 加学习率 alpha 乘以 Q 现实 和 Q 估计 的差距.也就是下图这样:

    我们通过 NN 预测出Q(s2, a1) 和 Q(s2,a2) 的值, 这就是 Q 估计. 然后我们选取 Q 估计中最大值的动作来换取环境中的奖励 reward. 而 Q 现实中也包含从神经网络分析出来的两个 Q 估计值, 不过这个 Q 估计是针对于下一步在 s’ 的估计. 最后再通过刚刚所说的算法更新神经网络中的参数。

    5,DQN两大利器

    Experience replay:DQN 有一个记忆库用于学习之前的经历,Q learning 是一种 off-policy 离线学习法, 它能学习当前经历着的, 也能学习过去经历过的, 甚至是学习别人的经历. 所以每次 DQN 更新的时候, 我们都可以随机抽取一些之前的经历进行学习. 随机抽取这种做法打乱了经历之间的相关性, 也使得神经网络更新更有效率.。

    Fixed Q-targets:是一种打乱相关性的机理, 如果使用 fixed Q-targets, 我们就会在 DQN 中使用到两个结构相同但参数不同的神经网络, 预测 Q 估计 的神经网络具备最新的参数, 而预测 Q 现实 的神经网络使用的参数则是很久以前的。

    6,DQN算法:

    7,DQN实现走迷宫的小例子

    下面的代码,是DQN用于环境交互重要的的部分:

    def run_maze():
        step = 0    # 用来控制什么时候学习
        for episode in range(300):
            # 初始化环境
            observation = env.reset()
    
            while True:
                # 刷新环境
                env.render()
    
                # DQN 根据观测值选择行为
                action = RL.choose_action(observation)
    
                # 环境根据行为给出下一个 state, reward, 是否终止
                observation_, reward, done = env.step(action)
    
                # DQN 存储记忆
                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   # 总步数
    
        # end of game
        print('game over')
        env.destroy()
    
    
    if __name__ == "__main__":
        env = Maze()
        RL = DeepQNetwork(env.n_actions, env.n_features,
                          learning_rate=0.01,
                          reward_decay=0.9,
                          e_greedy=0.9,
                          replace_target_iter=200,  # 每 200 步替换一次 target_net 的参数
                          memory_size=2000, # 记忆上限
                          # output_graph=True   # 是否输出 tensorboard 文件
                          )
        env.after(100, run_maze)
        env.mainloop()
        RL.plot_cost()  # 观看神经网络的误差曲线

    为了使用 Tensorflow 来实现 DQN, 比较推荐的方式是搭建两个神经网络, target_net 用于预测 q_target 值, 他不会及时更新参数. eval_net 用于预测 q_eval, 这个神经网络拥有最新的神经网络参数. 不过这两个神经网络结构是完全一样的, 只是里面的参数不一样

    两个神经网络是为了固定住一个神经网络 (target_net) 的参数, target_net 是 eval_net 的一个历史版本, 拥有 eval_net 很久之前的一组参数, 而且这组参数被固定一段时间, 然后再被 eval_net 的新参数所替换. 而 eval_net 是不断在被提升的, 所以是一个可以被训练的网络 trainable=True. 而 target_net 的 trainable=False.

    class DeepQNetwork:
        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
    

    之后代码讲解和完整程序请参考:https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/4-3-DQN3/

    本人对这份代码并没有完全搞明白,正在不断研究中。。。。。

    展开全文
  • play-daxigua-using-Re强化学习:使用强化学习DQN算法,训练AI模型来玩合成大西瓜游戏,提供Keras版本和PARL(paddle)版本
  • 强化学习DQN算法

    2019-12-30 08:02:00
    DQN,即Deep Q-learning算法,是将神经网络与Q-learning算法相结合而得到的强化学习算法。在DeepMind发表的论文《Playing Atari with Dee...

    DQN,即Deep Q-learning算法,是将神经网络与Q-learning算法相结合而得到的强化学习算法。在DeepMind发表的论文《Playing Atari with Deep Reinforcement Learning》(https://arxiv.org/abs/1312.5602)中,DeepMind使用DQN算法训练出可以玩Atari游戏的模型,该模型甚至在某些游戏上表现的比人类还要优秀。然而,该算法性能如此优秀,原理却不是很复杂,本篇文章将介绍这个神奇的算法。

    算法思想

    DQN是神经网络和Q-learning算法相结合的产物,其基本思想与Q-learning一致,都是通过估计动作价值函数的值以选择合适的策略。两者的不同之处在于:

    1. 原本在Q-learning中用来存储值的Table,在DQN中被取缔了,取而代之的是一个神经网络。

    2. 在模型训练过程中,DQN算法利用离线记忆存储的方式,打破了样本的相关性。

    在原本的Q-learning算法中,使用一个张Table存储所有状态以及动作空间的值。如果状态和动作空间是离散且动作维度不高的时候,一张Table完全可以存储。如果状态和动作空间高维连续时,这时候Table所需要存储的数据就非常巨大甚至海量,这时候Table就显得很无力了。

    事实上,Table在整个Q-learning算法中的作用是根据输入的状态,输出动作空间值,如果用函数来表示如下:

    从公式上看,只要完成这一功能,使用何种形式去实现都可以,而神经网络恰好是其中一个很合适的方案。因为神经网络的本质就是使用一组有限的参数,根据某种规律来拟合某种分布,以进行预测评估。有于神经网络只需要一组有限的参数,因此可以避免存储数量庞大的样本,减少样本存储占用,提升性能。

    同样,在原本的Q-learning算法中,每一次与环境进行交互之后,得到的样本基本只能使用一次。这就导致样本的利用率不是很高,尤其是对于那些有着非常积极影响的样本。通过将这些样本存储下来,之后对样本进行采样训练,可以在一定程度上提高对样本的利用率,加速算法的收敛。

    算法流程

    1. 初始化一个存储容量为的记忆池,同时随机初始化一个网络。

    2. 按以下流程迭代轮。

      1. 通过-greedy算法根据状态从动作空间中得到动作,通过网络选择动作的公式如下。

      2. 执行动作并观测环境,得到奖励以及图片

      3. 设置并对提取特征得到

      4. 将状态存储到记忆池中。

      5. 随机从记忆池中选择一组的记忆,并根据以下公式计算收获:

      6. 通过来计算损失,并通过梯度更新网络的参数。

      7. 初始化状态为第一个状态,并进行处理得到特征向量

      8. 按以下流程迭代轮。

    需要注意的是:

    1. 记忆池的容量为,当记忆池中的记忆数量达到时,在新加入记忆时,会将最久远的记忆清除掉。

    2. 在实际训练时,-greedy算法的值会随着迭代次数的增加而减小。

    3. 网络的目标函数是,目的是让网络预测的值更加接近真实值。

    关注【Java与Android技术栈】

    更多精彩内容请关注扫码

    展开全文
  • ROS开发笔记(10)——ROS 深度强化学习dqn应用之tensorflow版本(double dqn/dueling dqn/prioritized replay dqn) 在ROS开发笔记(9)中keras版本DQN算法基础上,参考莫烦强化学习的视频教程与代码,编写了应用在...
  • 本文章通过keras实现DQN算法来解决倒立摆的平衡问题 一.环境 cartpole是一个经典的环境,可以验证许多的算法。这次我用的是cartpole-v0,一个离散动作空间的倒立摆环境,该环境有两个动作,即左和右,并且包含环境的...
  • 强化学习DQN算法,训练AI模型来玩合成大西瓜游戏,提供Keras版本和PARL(paddle)版本。 B站:https://space.bilibili.com/470550823 CSDN:https://blog.csdn.net/weixin_44936889 AI Studio:https:/
  • 强化学习DQN系列小结

    2021-02-22 12:53:15
    DQN 作为 value-based 的强化学习方法,擅长处理离散情境下的强化学习问题。其本质是 deep learning 版本的 Q-learning,所以其基本模型和 Q-learning 类似,基于TD时间差分设置目标函数,并 ϵ−greedy\epsilo
  • 利用DQN框架完成倒立摆调节1、从Q-Learning到DQNQ-LearningDQN2、...Q-Learning是一种通过Q-table来进行决策的value-based强化学习方案,Q表格中的每一个Q值通过智慧体agent与环境不停交互获得的reward进行更新,由于这
  • 程序化交易入门(二)强化学习DQN及其衍生体1. 引入1.1 Machine Learning在做什么?1.2 DQN在寻找什么?1.2.1 Step1. Neural Network as Actor1.2.2 Goodness of function1.2.3 pick the best function1.4 几种假设...
  • 深度强化学习DQN

    2019-05-13 17:04:18
    ###DQN模型 输入的是处理后的连续帧图像(降维幅度图),经过卷积层层后接两个全连接层,输出是所有动作的Q值。 算法 1. NIPS 2013 2. Nature 2015 2.1 算法 2.2 流程图 3. 不足 由于Replay Memory原因: 无法...
  • 强化学习DQN算法实战之CartPole

    千次阅读 2019-04-10 23:51:15
    简介 这篇笔记主要是记录了Deep Q-Learning Network的开发过程。开发环境是:Ubuntu18.04 、tensorflow-gpu 1.13.1 和 ...强化学习的一个困难的地方,在于数据收集和环境描述。而 OpenAI的gym给我们提供了一个非常强...
  • 深度强化学习DQN系算法理解

    千次阅读 2020-04-07 22:15:00
    致谢 进行DQN方法整理时,主要对原文进行了学习,并参考了几位作者的笔记,在此一并表示感谢。索引网页如下: https://www.jianshu.com/p/6fe18d0d8822 https://www.jianshu.com/p/0fb311d96da4 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,963
精华内容 1,985
关键字:

强化学习dqn