精华内容
下载资源
问答
  • 《MATLAB强化学习入门》的第五期,讨论倒立摆的DQN神经网络控制问题,包括倒立摆的数学建模、DQN强化学习以及总的程序实现。

    在上一期中,使用DQN算法,我们让智能体能够顺利解决较大的网格迷宫问题。本期我们更进一步,尝试用DQN控制倒立摆。倒立摆是非常经典的控制问题,如果DQN能够有效实现倒立摆的控制,也就意味着DQN等强化学习算法适用于更复杂的动力学控制问题,即就是说,采用相似的思想,我们可以将强化学习算法用于机械臂控制、卫星姿态控制等工程问题上。

    像往常一样,想要实现倒立摆的强化学习控制,我们可以把这样一个大问题拆解成几个相对独立的问题解决。第一是使用MatLab实现倒立摆的数值仿真建模;第二则是修改DQN算法,使之能够与倒立摆环境相适应;第三则是改善程序的整体框架,使它更简洁、更易于维护。

    第一个问题中,倒立摆的动力学方程可以整理为常微分方程;同时,为了更好的与之前我们掌握的神经网络工具箱结合,我们使用MatLab的Ode45()函数实现动力学仿真。
    第二个问题,我们需要根据倒立摆问题调整神经网络和DQN算法的相关参数,使之能够满足控制需求。这其中,神经网络的输入、输出参数需要得到调整;DQN算法中的回报(reward)需要修改;训练循环的计数方式以及训练周期等内容也需要调整。
    最后,由于整个程序中加入了倒立摆的数值仿真,不仅参数和常数增多,程序也相对网格迷宫程序复杂了很多。因此,我们需要优化程序的编写,以提高程序的易读性和维护性。

    一、倒立摆的数学建模

    1.1 倒立摆模型的方程

    在这里插入图片描述
    倒立摆由小车以及小车上向上铰支的摆杆组成,显然,当摆杆朝上时,这是一个可以平衡但不能稳定的系统。
    小车固定在横轴上,因此在y方向上无位移,仅在x方向上有位移和速度。在水平方向上,小车受到控制力、摩擦力以及摆杆支撑力水平分量的作用。取x_c为x方向位移、x_c为x方向速度,得方程(1.1):
    在这里插入图片描述
    至于摆杆,虽然摆杆的下端固定在小车上,但摆杆的质心却是存在垂直和水平两向位移的。水平方向上,摆杆受力为支撑力的水平分量;垂直方向上,摆杆的受力包括重力和支撑力的垂直分量。
    在这里插入图片描述
    除此之外,摆杆存在转动,绕质心的转动方程为:
    在这里插入图片描述
    然而,上述动力学系统中,四个物理坐标仅仅有两个是相互独立的,
    因此,在实际的数值仿真中,为了更好的与物理现象相对应,我们选取小车的横坐标x_c和摆杆的转角θ作为状态量。摆杆质心的横纵坐标与x_c及θ的关系如下:
    在这里插入图片描述
    小车所收到的摩擦力与运动方向相反,与相对滑轨的正压力成正比,摩擦力F_f可表示为:
    在这里插入图片描述
    联立上述方程,即可得到用于适合于数值求解的方程格式:
    在这里插入图片描述

    1.2倒立摆的数值仿真

    如上,即完成了倒立摆的数值仿真建模。我们将方程在编程中实现,并调用ode45()函数,即可实现倒立摆的MatLab仿真。

    [t,y]=ode45(@CartPole_Eqs,[0,T_step],OdeInput,opts);
    
    function dotPara=CartPole_Eqs(t,Para)
    global Mc Mp Lp Cf g;
    X=Para(1);
    V=Para(2);
    Theta=Para(3);
    Omega=Para(4);
    Fc=Para(5);
    dotPara=zeros(4,1);
    
    dotPara(1,:)=V;
    
    
    if V~=0
        D1=V/abs(V);
    else
        D1=0;         %停滞状态下不考虑摩擦力,实际上,除去初值外,dotx几乎不为0
    end
    C21=(Mc+Mp)/Mc+3/4*Mp/Mc*cos(Theta)*(Cf*D1*sin(Theta)-cos(Theta));
    C22=Fc/Mc-(Mp+Mc)/Mc*Cf*D1*g+(sin(Theta)+cos(Theta)*Cf*D1)*Mp/Mc*Lp/2*(Omega^2)+0.75*(Cf*D1*sin(Theta)-cos(Theta))*Mp/Mc*sin(Theta)*g;
    dotPara(2,:)=C22/C21;
    
    dotPara(3,:)=Omega;
    dotPara(4,:)=1.5/Lp*(sin(Theta)*g-cos(Theta)*dotPara(2));
    dotPara(5,:)=0;
    

    二、倒立摆的DQN控制

    想要使用DQN控制倒立摆,有两个问题需要解决。第一,是DQN的状态和动作分别是什么?第二,DQN的奖赏如何定义?
    对于第一个问题,DQN的状态就是倒立摆动力学系统的状态,包括四个参量,小车的横坐标、水平速度,摆杆的转角以及旋转角速度。对于DQN的动作,我们知道倒立摆的平衡是由控制力F_c实现的,因此其动作自然应该是控制力。但控制力本身是连续量,在依据策略选择动作时我们没办法将这一连续量的所有值都遍历一遍以获得Q值最大的控制力。因此,**我们将倒立摆的控制力离散化成一个控制力数组来实现DQN需要的动作输入,**也就是说,倒立摆的控制力输出为一组规定的常值。**在仿真模拟中,智能体每隔规定间隔进行一次状态采样,输入DQN网络中获得该状态下所有动作的Q值并选择Q值最高的动作,此控制力即为下一时间段的控制力输出。**也就是说,由于DQN的特点,我们采用幅值和时间上均离散的控制力来实现倒立摆的控制。
    对于第二个问题,我们希望,倒立摆的小车水平位置距离导轨越近越好,摆杆如垂直方向的夹角越小越好。由于整个倒立摆控制程序中,需要在多个地方进行奖赏reward()的计算,我们将奖赏封装成如下的函数:

    function reward=Reward_Cal(CPstate)
    global X_threshold Theta_threshold;
    r1=1.4*((X_threshold-abs(CPstate(1)))/X_threshold-0.8);
    r2=(Theta_threshold-abs(CPstate(3)))/Theta_threshold-0.95;
    reward=r1+r2;
    

    奖赏的定义对DQN控制器的表现存在着较大的影响,r1与r2的权重决定了DQN对两种位置误差的敏感程度。也因此,奖赏的定义本身也是倒立摆DQN控制中可以调试的参数。读者也可尝试对奖赏函数进行修改来观察DQN的表现。

    三、 倒立摆程序设计

    我们修改在网格迷宫中搭建的MatLab程序框架,以实现其对倒立摆的控制。变化主要有以下几点:

    1. 由于神经网络智能体和倒立摆环境参数较多,参数的初始化单独用两个.m文件封装,这样也方便了参数的调整与检查。
    2. 将观察期和训练期合并成了一段代码,缩短代码长度,便于检查和维护。
    3. 单训练周期内,循环变量由次数变为时间,且时间的步进为可调参数。
    4. 在每个episode的开始,倒立摆的初始化会产生随机的扰动,一方面提高训练中的“探索”概率,另一方面模拟真实情况。
      程序的框架可由下面的流程图展示。
      在这里插入图片描述程序的主体部分则如下:
    % 忘记面孔的Batou
    % "I thought what I'd do was I'd pretend I was one of those deaf-mutes, or should I?" 
    
    clear all;
    
    run('CartPoleInitializer');  
    run('AgentInitializer'); 
    
    %训练周期设置:观察期,训练期
    N_obs=300;                       
    N_train=3000;
    N_total=N_obs+N_train;
    T_episode=60;           %每个周期的总时间
    
    %数据记录初始化,状态记录在Episode开始前进行
    TimeRecord=zeros(1,N_total);
    AveTimeRecord=zeros(2,N_total/10);
    ATRpointer=1;
    
    %episode及其余设置
    T_step=0.1;
    n_step=1;
    
    %动态绘图初始化
    Plotset=zeros(2,1);
    p = plot(Plotset(1,:),Plotset(2,:),...
       'EraseMode','background','MarkerSize',5);
    axis([0 N_obs+N_train 0 60]);
    
    
    
    for Ns=1:N_total
        CPstate=CartPoleReset();                %CPstate为4*1矩阵,x,dotx,theta,dottheta
        T1=0;
        %初始化历史记录。记录下列内容:1.控制时长;2.每个episode的600个状态与控制力矩
        TrackPointer=1;
        TrackRecord(Ns).Track=zeros(6,T_episode/T_step);
        while T1<=T_episode
            %根据tcegreedy策略选择动作
            [act,Qnow]=tcegreedy(Ns,CPstate,QNet_eval);  
            Fc=FcTable(act);
            %使用Ode45执行动作
            OdeInput=[CPstate;Fc];
            [t,y]=ode45(@CartPole_Eqs,[0,T_step],OdeInput,opts);
            Nsize=size(y); Nsize=Nsize(1);
            Newstate=y(Nsize,1:4); Newstate=Newstate';
            %Replaymemory记录+指针更新
            Rmemo(:,Memopointer)=[CPstate;act;Newstate];
            Memopointer=PointerMove(Memopointer,S_memo);
            %轨迹数据记录更新
            TrackRecord(Ns).Track(:,TrackPointer)=[T1;CPstate;Fc];
            TrackPointer=TrackPointer+1;
            %更新状态
            T1=T1+T_step;
            n_step=n_step+1;
            CPstate=Newstate;       
            
            %按照T-renew间隔更新估计Q_target的目标神经网络QNet_target
            if (mod(n_step,N_renew)==0)&&(Ns>=N_obs)
                QNet_target=QNet_eval;
            end
            
            %按照T_gap的间隔训练估计Q_eval的评估神经网络QNet_eval
            if (mod(n_step,N_gap)==0)&&(Ns>=N_obs)
                %1. 利用Rmemo生成训练数据级
                Trainset=zeros(10,nBatch);      %前9行与replaymemory一致,后一行为利用QNet_target计算得到的Q_target;
                i=1;
                while i<=nBatch
                    num1=unidrnd(S_memo);
                    if Rmemo(5,num1)>0          %有记录的第五行始终不为零
                        Trainset(1:9,i)=Rmemo(:,num1);
                        i=i+1;
                    end
                end
                %2. 计算Q_target
                Trainset(10,:)=CalculationQtarget(Trainset(1:9,:),QNet_target);            
                %3. 训练QNet_eval
                QNet_eval=train(QNet_eval,Trainset(1:5,:),Trainset(10,:));
            end
            %判断是否跳出本episode,并记录控制时长
            if (abs(CPstate(1))>X_threshold)||(abs(CPstate(3))>Theta_threshold)
                TimeRecord(Ns)=T1;
                break;
            elseif T1>=T_episode
                TimeRecord(Ns)=T1;
                break;
            end
        end
        %动态绘图
        if mod(Ns,10)==0
            Ave1=mean(TimeRecord(Ns-9:Ns));
            AveTimeRecord(:,ATRpointer)=[Ns;Ave1]';
            ATRpointer=ATRpointer+1;        
            TempP=[Ns;Ave1];
            Plotset=[Plotset,TempP];
            set(p,'XData',Plotset(1,:),'YData',Plotset(2,:));
            drawnow
            axis([0 N_obs+N_train 0 60]);             
        end
        
    end
    

    四、Let it RUN

    完成程序后,我们运行程序以观察智能体的训练。在倒立摆模型中,我们不能再简单的以智能体是否到达终点作为性能评估的标识,而以每一个episode中DQN控制倒立摆不倒(小车的坐标距离中心的偏差和摆杆的转角均不超过门限)的时长作为观察其性能的标志。我们取每10个Episode的控制时长作平均进行绘图,得到DQN的训练情况:
    在这里插入图片描述在训练完成后,单个Episode里,倒立摆呈现出如下的运动状态:
    在这里插入图片描述

    以上,即是《MatLab强化学习入门》第五期的内容。本期我们使用DQN解决倒立摆问题的完整代码,已经和第四期解决网格迷宫问题的代码合并上传,读者可以移步以下链接下载:MATLAB强化学习_神经网络控制_倒立摆问题&网格迷宫问题

    十分欢迎有心读本文的CSDNer交流讨论;如果觉得本文有帮助的话,打赏一下可是更好(๑•̀ㅂ•́)و✧

    展开全文
  • DQN框架主要包括以下几部分: 构建predict神经网络和target神经网络模块 训练predict神经网络模块 更新target神经网络模块 根据predict值选择动作模块 DQN算法图如下: 这里存在两个Q值神经网络:predict神经...

    Double-DQN框架主要包括以下几部分:
    构建eval神经网络和target神经网络模块
    训练eval神经网络模块
    更新target神经网络模块
    根据eval值选择动作模块。

    为了将动作选择和价值估计进行解耦,我们有了Double-DQN方法。在Double-DQN中,在计算Q实际值时,动作选择由eval-net得到,而价值估计由target-net得到。此时,损失函数变为:

    DQN算法图如下:

    这里存在两个Q值神经网络: predict神经网络和target神经网络。

    1. target神经网络。作用:计算目标Q值。更新:间隔一段时间进行更新。目的:保持算法稳定性。

    为了获得的Q值,Q值的更新依靠Reward和Q计算出来的目标Q值:[å¬å¼]

    这里采用一个稳定的target神经网络进行Q值计算,也就是Q(s‘,a’,w)部分是target网络,从而保持算法的稳定性。

    [å¬å¼]

    2. eval神经网络。作用:通过损失函数进行Q值网络训练。跟新:每次进行更新。目的:便于网络训练。

    eval神经网络训练的损失函数就如下:

     

    或者

    其中Q(s,a,w)或者qtheta为eval神经网络获得的Q值 。通过上述损失函数进行eval神经网络训练。

    3. target神经网络更新。

    间隔一定迭代次数。利用eval神经网络的权值更新target神经网络权值。

     

     

    展开全文
  • DQN

    千次阅读 2019-04-14 23:05:47
    DQN 算法分析: 我们的环境是确定性的,所以为了简单起见,这里给出的所有方程也是确定性地制定的。 在强化学习文献中,他们也将对环境随机转换产生预估。我们的目标是训练一个策略来最大化回报Rt0=∑∞t=t0γt−t0...

    DQN 算法分析:
    我们的环境是确定的,所以为了简单起见,这里给出的所有方程也是具有确定性的。 在强化学习文献中,他们也将对环境随机转换产生预估。

    我们的目标是训练一个策略来最大化回报 R t 0 = ∑ t = t 0 ∞ γ t − t 0 r t R_{t_0} = \sum_{t=t_0}^{\infty} \gamma^{t - t_0} r_t Rt0=t=t0γtt0rt, γ \gamma γ是折扣,是 0 0 0 1 1 1之间的一个常数,用来保证和是收敛的。它让那些在未知的未来的具有不确定性的回报小一些,而让最近的未来的那些确定的回报保持较高的可信赖度。

    Q-learning 的主要思想是如果我们有了一个函数 Q ∗ : S t a t e × A c t i o n → R Q^*: State \times Action \rightarrow \mathbb{R} Q:State×ActionR,它可以告诉我们当前的状态下执行某个动作的回报值是多少。如果有了这样的函数,那么我们可以很容易地构造相应的策略来最大化我们的回报:
    \begin{align}\pi^(s) = \argmax_a \ Q^(s, a)\end{align}
    然而,我们不知道关于这个世界的一切,所以我们没法准确获得 Q ∗ Q^* Q,但是,既然神经网络能够逼近所有函数,我们能够训练它使得它趋近于 Q ∗ Q^* Q
    对于我们训练提升的规则来说,默认对于一些策略,所有的 Q Q Q函数遵循 Bellman 方程:
    \begin{align}Q^{\pi}(s, a) = r + \gamma Q^{\pi}(s’, \pi(s’))\end{align}
    等式左右两边的区别被认为是暂时的误差 δ \delta δ
    \begin{align}\delta = Q(s, a) - (r + \gamma \max_a Q(s’, a))\end{align}
    为了消除这个误差,我们要用到 Huber loss ,当误差较小的时候,Huber loss表现得像MES[mean squared error],但是当误差较大时,MES会变得很大。所以这种损失函数让算法在估计 Q Q Q遇到很大的噪声时更加稳定。计算是针对从保存的replay memory中获取采样的B个样本:
    \begin{align}\mathcal{L} = \frac{1}{|B|}\sum_{(s, a, s’, r) \ \in \ B} \mathcal{L}(\delta)\end{align}

    \begin{align}\text{where} \quad \mathcal{L}(\delta) = \begin{cases}
    \frac{1}{2}{\delta^2} & \text{for } |\delta| \le 1, \
    |\delta| - \frac{1}{2} & \text{otherwise.}
    \end{cases}\end{align}

    展开全文
  • 创建dqn的深度神经网络 深层钢筋学习讲解— 16 (DEEP REINFORCEMENT LEARNING EXPLAINED — 16) This is the second post devoted to Deep Q-Network (DQN), in the “Deep Reinforcement Learning Explained” ...

    创建dqn的深度神经网络

    深层钢筋学习讲解— 16 (DEEP REINFORCEMENT LEARNING EXPLAINED — 16)

    This is the second post devoted to Deep Q-Network (DQN), in the Deep Reinforcement Learning Explained series, in which we will analyse some challenges that appear when we apply Deep Learning to Reinforcement Learning. We will also present in detail the code that solves the OpenAI Gym Pong game using the DQN network introduced in the previous post.

    这是 深度强化学习解释 系列中第二篇专门针对深度Q网络(DQN)的文章,其中我们将分析将深度学习应用于强化学习时出现的一些挑战。 我们还将详细介绍使用上一篇文章中介绍的DQN网络解决OpenAI Gym Pong游戏的代码。

    深度强化学习中的挑战 (Challenges in Deep Reinforcement Learning)

    Unfortunately, reinforcement learning is more unstable when neural networks are used to represent the action-values, despite applying the wrappers introduced in the previous section. Training such a network requires a lot of data, but even then, it is not guaranteed to converge on the optimal value function. In fact, there are situations where the network weights can oscillate or diverge, due to the high correlation between actions and states.

    不幸的是,尽管使用了上一节介绍的包装器,但是当使用神经网络来表示动作值时,强化学习更加不稳定。 训练这样的网络需要大量数据,但是即使如此,也不能保证收敛于最优值函数。 实际上,由于动作和状态之间的高度相关性,在某些情况下网络权​​重可能发生振荡或发散。

    In order to solve this, in this section we will introduce two techniques used by the Deep Q-Network:

    为了解决这个问题,在本节中,我们将介绍深度Q网络使用的两种技术:

    • Experience Replay

      体验重播
    • Target Network

      目标网络

    There are many more tips and tricks that researchers have discovered to make DQN training more stable and efficient, and we will cover the best of them in future posts in this series.

    研究人员发现了许多其他技巧可以使DQN培训更加稳定和高效,我们将在本系列的后续文章中介绍其中的最佳技巧。

    体验重播 (Experience Replay)

    We are trying to approximate a complex, nonlinear function, Q(s, a), with a Neural Network. To do this, we must calculate targets using the Bellman equation and then consider that we have a supervised learning problem at hand. However, one of the fundamental requirements for SGD optimization is that the training data is independent and identically distributed and when the Agent interacts with the Environment, the sequence of experience tuples can be highly correlated. The naive Q-learning algorithm that learns from each of these experiences tuples in sequential order runs the risk of getting swayed by the effects of this correlation.

    我们正在尝试用神经网络近似一个复杂的非线性函数Q(s,a)。 为此,我们必须使用Bellman方程计算目标,然后考虑手头有一个监督学习问题。 但是,SGD优化的基本要求之一是训练数据是独立且均匀分布的,并且当Agent与环境交互时,经验元组的序列可以高度相关。 从这些经验元组中按顺序学习的幼稚Q学习算法冒着被这种相关性的影响所左右的风险。

    We can prevent action values from oscillating or diverging catastrophically using a large buffer of our past experience and sample training data from it, instead of using our latest experience. This technique is called replay buffer or experience buffer. The replay buffer contains a collection of experience tuples (S, A, R, S′). The tuples are gradually added to the buffer as we are interacting with the Environment. The simplest implementation is a buffer of fixed size, with new data added to the end of the buffer so that it pushes the oldest experience out of it. The simplest implementation is a buffer of fixed size, with new data added to the end of the buffer so that it pushes the oldest experience out of it.

    我们可以使用我们过去的经验和从中获得的训练数据的较大缓冲,而不是使用我们的最新经验,来防止动作值发生剧烈的波动或发散。 此技术称为重播缓冲区体验缓冲区 。 重播缓冲区包含经验元组( SARS ')的集合。 当我们与环境交互时,将元组逐渐添加到缓冲区中。 最简单的实现是固定大小的缓冲区,将新数据添加到缓冲区的末尾,从而将最旧的体验推向缓冲区。 最简单的实现是固定大小的缓冲区,将新数据添加到缓冲区的末尾,从而将最旧的体验推向缓冲区。

    The act of sampling a small batch of tuples from the replay buffer in order to learn is known as experience replay. In addition to breaking harmful correlations, experience replay allows us to learn more from individual tuples multiple times, recall rare occurrences, and in general make better use of our experience.

    从重播缓冲区中采样一小批元组以便学习的行为称为体验重播 。 除了打破有害的相关性之外,体验重播还使我们可以多次从单个元组中学习更多,回忆起罕见的事件,并且通常可以更好地利用我们的经验。

    As a summary, the basic idea behind experience replay is to storing past experiences and then using a random subset of these experiences to update the Q-network, rather than using just the single most recent experience. In order to store the Agent’s experiences, we used a data structure called a deque in Python’s built-in collections library. It’s basically a list that you can set a maximum size on so that if you try to append to the list and it is already full, it will remove the first item in the list and add the new item to the end of the list. The experiences themselves are tuples of [observation, action, reward, done flag, next state] to keep the transitions obtained from the environment.

    总而言之,体验重播的基本思想是存储过去的体验,然后使用这些体验的随机子集来更新Q网络,而不是仅使用单个最新的体验。 为了存储Agent的经验,我们在Python的内置集合库中使用了称为deque的数据结构。 它基本上是一个列表,您可以在其上设置最大大小,以便在尝试追加到列表且该列表已满时,它将删除列表中的第一项并将新项添加到列表的末尾。 体验本身就是[观察,动作,奖励,完成标志,下一个状态]的元组,以保持从环境中获得的过渡。

    Experience = collections.namedtuple(‘Experience’, 
    field_names=[‘state’, ‘action’, ‘reward’,
    ‘done’, ‘new_state’])class ExperienceReplay:
    def __init__(self, capacity):
    self.buffer = collections.deque(maxlen=capacity) def __len__(self):
    return len(self.buffer) def append(self, experience):
    self.buffer.append(experience)

    def sample(self, batch_size):
    indices = np.random.choice(len(self.buffer), batch_size,
    replace=False)
    states, actions, rewards, dones, next_states =
    zip([self.buffer[idx] for idx in indices])
    return np.array(states), np.array(actions),
    np.array(rewards,dtype=np.float32),
    np.array(dones, dtype=np.uint8),
    np.array(next_states)

    Each time the Agent does a step in the Environment, it pushes the transition into the buffer, keeping only a fixed number of steps (in our case, 10k transitions). For training, we randomly sample the batch of transitions from the replay buffer, which allows us to break the correlation between subsequent steps in the environment.

    代理每次在环境中执行一个步骤时,都会将过渡推送到缓冲区中,仅保留固定数量的步骤(在我们的示例中为10k过渡)。 为了进行训练,我们从重播缓冲区中随机抽取了一批过渡样本,这使我们可以打破环境中后续步骤之间的相关性。

    Most of the experience replay buffer code is quite straightforward: it basically exploits the capability of the deque library. In the sample() method, we create a list of random indices and then repack the sampled entries into NumPy arrays for more convenient loss calculation.

    大多数体验重放缓冲区代码非常简单:它基本上利用了deque库的功能。 在sample()方法中,我们创建一个随机索引列表,然后将采样的条目重新打包到NumPy数组中,以更方便地进行损耗计算。

    目标网络 (Target Network)

    Remember that in Q-Learning, we update a guess with a guess, and this can potentially lead to harmful correlations. The Bellman equation provides us with the value of Q(s, a) via Q(s’, a’) . However, both the states s and s’ have only one step between them. This makes them very similar, and it’s very hard for a Neural Network to distinguish between them.

    请记住,在Q-Learning中,我们用guess更新一个猜测 ,这可能会导致有害的相关性。 贝尔曼方程式通过Q(s',a')为我们提供Q(s,a)的值。 但是,状态s和s'之间只有一步之遥。 这使它们非常相似,并且神经网络很难区分它们。

    When we perform an update of our Neural Networks’ parameters to make Q(s, a) closer to the desired result, we can indirectly alter the value produced for Q(s’, a’) and other states nearby. This can make our training very unstable.

    当我们对神经网络的参数进行更新以使Q(s,a)更接近所需结果时,我们可以间接更改为Q(s',a')和附近其他状态产生的值。 这会使我们的训练非常不稳定。

    To make training more stable, there is a trick, called target network, by which we keep a copy of our neural network and use it for the Q(s’, a’) value in the Bellman equation.

    为了使训练更稳定,有一个技巧叫做目标网络 ,通过该技巧我们可以保留神经网络的副本,并将其用于Bellman方程中的Q(s',a')值。

    That is, the predicted Q values of this second Q-network called the target network, are used to backpropagate through and train the main Q-network. It is important to highlight that the target network’s parameters are not trained, but they are periodically synchronized with the parameters of the main Q-network. The idea is that using the target network’s Q values to train the main Q-network will improve the stability of the training.

    也就是说,此第二个Q网络(称为目标网络)的预测Q值用于反向传播并训练主Q网络。 重要的是要强调目标网络的参数没有经过训练,但是会与主Q网络的参数定期同步。 这个想法是,使用目标网络的Q值来训练主Q网络将提高训练的稳定性。

    Later, when we present the code of the training loop, we will enter in more detail how to code the initialization and use of this target network.

    稍后,当我们提供训练循环的代码时,我们将更详细地输入如何对目标网络的初始化和使用进行编码。

    深度Q学习算法 (Deep Q-Learning Algorithm)

    There are two main phases that are interleaved in the Deep Q-Learning Algorithm. One is where we sample the environment by performing actions and store away the observed experienced tuples in a replay memory. The other is where we select the small batch of tuples from this memory, randomly, and learn from that batch using a gradient descent (SGD) update step.

    深度Q学习算法有两个主要阶段相互交错。 一种是我们通过执行操作对环境进行采样 ,并将观察到的有经验的元组存储在重播内存中。 另一个是我们从该内存中随机选择一小批元组,并使用梯度下降(SGD)更新步骤从该批中学习

    These two phases are not directly dependent on each other and we could perform multiple sampling steps then one learning step, or even multiple learning steps with different random batches. In practice, you won’t be able to run the learning step immediately. You will need to wait till you have enough tuples of experiences in D.

    这两个阶段并不直接相互依赖,我们可以执行多个采样步骤,然后执行一个学习步骤,甚至可以执行具有不同随机批次的多个学习步骤。 实际上,您将无法立即运行学习步骤。 您将需要等待,直到您具有足够的D元组经验。

    The rest of the algorithm is designed to support these steps. We can summarize the previous explanations with this pseudocode for the basic DQN algorithm that will guide our implementation of the algorithm:

    该算法的其余部分旨在支持这些步骤。 我们可以使用此伪代码来总结先前对基本DQN算法的解释,这些解释将指导我们实现该算法:

    Image for post

    In the beginning, we need to create the main network and the target networks, and initialize an empty replay memory D. Note that memory is finite, so we may want to use something like a circular queue that retains the d most recent experience tuples. We also need to initialize the Agent, one of the main components, which interacts with the Environment.

    首先,我们需要创建主网络和目标网络,并初始化一个空的重播内存D。 请注意,内存是有限的,因此我们可能想使用类似循环队列的方法来保留d个最近的经验元组。 我们还需要初始化与环境交互的主要组件之一的代理。

    Note that we do not clear out the memory after each episode, this enables us to recall and build batches of experiences from across episodes.

    请注意,我们不会在每个情节结束后清除内存,这使我们能够回忆起并积累来自各个情节的大量体验。

    编码训练循环 (Coding the Training Loop)

    超参数和执行时间 (Hyperparameters and execution time)

    Before going into the code, mention that DeepMind’s Nature paper contained a table with all the details about hyperparameters used to train its model on all 49 Atari games used for evaluation. DeepMind kept all those parameters the same for all games, but trained individual models for every game. The team’s intention was to show that the method is robust enough to solve lots of games with varying complexity, action space, reward structure, and other details using one single model architecture and hyperparameters.

    在进入代码之前,请提及DeepMind的Nature论文包含一张表格,其中包含有关用于在49个用于评估的Atari游戏中训练其模型的超参数的所有详细信息。 DeepMind在所有游戏中都将所有这些参数保持不变,但会为每个游戏训练单独的模型。 团队的意图是证明该方法足够健壮,可以使用一个模型结构和超参数来解决许多具有不同复杂性,动作空间,奖励结构和其他细节的游戏。

    However, our goal in this post is to solve just the Pong game, a quite simple and straightforward game in comparison to other games in the Atari test set, so the hyperparameters in the paper are are not the most suitable for a didactic post like this one. For this reason, we decided to use more personalized parameter values for our Pong Environment that converges to mean score of 19.0 in a reasonable wall time, depending on the GPU type that colab assigns to our execution (about a couple of hours at most). Remember that we can know the type of GPU that has been assigned to our runtime environment with the command !nvidia-smi.

    但是,本文的目标是解决Pong游戏,与Atari测试集中的其他游戏相比,这是一个非常简单明了的游戏,因此本文中的超参数并非最适合此类教学文章之一。 因此,我们决定在Pong Environment中使用更多个性化参数值,这些值在合理的时间间隔内收敛至平均得分19.0,具体取决于colab分配给我们执行的GPU类型(最多约两个小时)。 请记住,我们可以通过命令!nvidia-smi知道分配给运行时环境的GPU的类型。

    Let’s start introducing the code in more detail. The entire code of this post can be found on GitHub (and can be run as a Colab google notebook using this link). We skip the import details of the packages, it is quite straightforward, and we focus on the explanation of the hyperparameters:

    让我们开始更详细地介绍代码。 这篇文章的完整代码可以在GitHub上找到 (并且可以使用此链接作为Colab谷歌笔记本运行 )。 我们跳过了软件包的导入细节,这非常简单,我们集中在对超参数的解释上:

    DEFAULT_ENV_NAME = “PongNoFrameskip-v4” 
    MEAN_REWARD_BOUND = 19.0 gamma = 0.99 or
    batch_size = 32
    replay_size = 10000
    learning_rate = 1e-4
    sync_target_frames = 1000
    replay_start_size = 10000 eps_start=1.0
    eps_decay=.999985
    eps_min=0.02

    These DEFAULT_ENV_NAME identify the Environment to train on and MEAN_REWARD_BOUNDthe reward boundary to stop training. We will consider that the game has converged when our agent reaches an average of 19 games won (out of 21) in the last 100 games. The remaining parameters indicate:

    这些DEFAULT_ENV_NAME标识要在其上进行训练的环境,并MEAN_REWARD_BOUND奖励边界以停止训练。 当我们的经纪人在过去100场比赛中平均获得19场胜利(21场)时,我们将认为比赛已经收敛。 其余参数指示:

    • gammais the discount factor

      gamma是折扣因子

    • batch_size, the minibatch size

      batch_size ,最小批量大小

    • learning_rateis the learning rate

      learning_rate是学习率

    • replay_sizethe replay buffer size (maximum number of experiences stored in replay memory)

      replay_size重播缓冲区的大小(存储在重播内存中的最大体验数)

    • sync_target_framesindicates how frequently we sync model weights from the main DQN network to the target DQN network (how many frames in between syncing)

      sync_target_frames指示我们将模型权重从主DQN网络同步到目标DQN网络的频率(同步之间有多少帧)

    • replay_start_size the count of frames (experiences) to add to replay buffer before starting training.

      replay_start_size开始训练之前要添加到重播缓冲区的帧数(体验)。

    Finally, the hyperparameters related to the epsilon decay schedule are the same as the previous post:

    最后,与ε衰减时间表有关的超参数与先前的文章相同:

    eps_start=1.0
    eps_decay=.999985
    eps_min=0.02

    代理商 (Agent)

    One of the main components we need is an Agent, which interacts with the Environment, and saves the result of the interaction into the experience replay buffer. The Agent class that we will design already save directly the result of the interacts with the Environment into the experience replay buffer, performing these three steps of the sample phase indicated in the portion of the previous pseudocode:

    我们需要的主要组件之一是代理,它与环境交互,并将交互结果保存到体验重播缓冲区中。 我们将设计的Agent类已经将与环境交互的结果直接保存到体验重播缓冲区中执行前面的伪代码部分中指示的示例阶段的这三个步骤:

    Image for post

    First of all, during the Agent’s initialization, we need to store references to the Environment and experience replay buffer D indicated as an argument in the creation of the Agent’s object as exp_buffer:

    首先,在Agent初始化期间,我们需要存储对Environment的引用,并体验重放缓冲区D ,该缓冲区在创建Agent对象的过程中作为参数表示为exp_buffer

    class Agent: 
    def __init__(self, env, exp_buffer):
    self.env = env
    self.exp_buffer = exp_buffer
    self._reset()def _reset(self):
    self.state = env.reset()
    self.total_reward = 0.0

    In order to perform Agent’s steps in the Environment and store its results in the experience replay memory we suggest the following code:

    为了在环境中执行Agent的步骤并将其结果存储在体验重播内存中,我们建议使用以下代码:

    def play_step(self, net, epsilon=0.0, device=”cpu”):    done_reward = None    if np.random.random() < epsilon:
    action = env.action_space.sample()
    else:
    state_a = np.array([self.state], copy=False)
    state_v = torch.tensor(state_a).to(device)
    q_vals_v = net(state_v)
    _, act_v = torch.max(q_vals_v, dim=1)
    action = int(act_v.item())

    The method play_step uses an ϵ-greedy(Q) policy to select actions at every time step. In other words, with the probability epsilon (passed as an argument), we take the random action; otherwise, we use the past model to obtain the Q-values for all possible actions and choose the best.

    play_step方法使用ϵ-greedy(Q)策略在每个时间步选择动作。 换句话说,用概率epsilon (作为参数传递),我们采取了随机动作。 否则,我们将使用过去的模型来获取所有可能动作的Q值,然后选择最佳值。

    After obtaining the action the method performs the step in the Environment to get the next observation: next_state, reward and is_done:

    获得action该方法在环境中执行步骤以获取下一个观察值: next_staterewardis_done

        new_state, reward, is_done, _ = self.env.step(action)
    self.total_reward += reward

    Finally, the method stores the observation in the experience replay buffer, and then handle the end-of-episode situation:

    最后,该方法将观察结果存储在体验重播缓冲区中,然后处理情节结束情况:

        exp = Experience(self.state,action,reward,is_done,new_state)
    self.exp_buffer.append(exp)
    self.state = new_state
    if is_done:
    done_reward = self.total_reward
    self._reset()
    return done_reward

    The result of the function is the total accumulated reward if we have reached the end of the episode with this step, or None if not.

    该函数的结果是总累积奖励,如果我们已经达到了情节的这一步,或最终 None 如果不

    主循环 (Main Loop)

    In the initialization part, we create our environment with all required wrappers applied, the main DQN neural network that we are going to train, and our target network with the same architecture. We also create the experience replay buffer of the required size and pass it to the agent. The last things we do before the training loop are to create an optimizer, a buffer for full episode rewards, a counter of frames and a variable to track the best mean reward reached (because every time the mean reward beats the record, we will save the model in a file):

    在初始化部分,我们创建一个环境,其中应用了所有必需的包装器,将要训练的主要DQN神经网络以及具有相同体系结构的目标网络。 我们还将创建所需大小的体验重播缓冲区,并将其传递给代理。 在训练循环之前,我们要做的最后一件事是创建一个优化器,一个完整剧集奖励的缓冲区,一个帧计数器和一个变量,以跟踪达到的最佳平均奖励(因为每次平均奖励都超过记录时,我们将保存文件中的模型):

    env = make_env(DEFAULT_ENV_NAME)
    net = DQN(env.observation_space.shape,
    env.action_space.n).to(device)
    target_net = DQN(env.observation_space.shape,
    env.action_space.n).to(device)buffer = ExperienceReplay(replay_size)
    agent = Agent(env, buffer)epsilon = eps_startoptimizer = optim.Adam(net.parameters(), lr=learning_rate)
    total_rewards = []
    frame_idx = 0best_mean_reward = None

    At the beginning of the training loop, we count the number of iterations completed and update epsilon as we introduced in the previous post. Next, the Agent makes a single step in the Environment (using as arguments the current neural network and value for epsilon). Remember that this function returns a non-None result only if this step is the final step in the episode. In this case, we report the progress in the console (count of episodes played, mean reward for the last 100 episodes and the current value of epsilon):

    在训练循环的开始,我们计算完成的迭代次数并更新epsilon,正如我们在上一篇文章中介绍的那样 。 接下来,Agent在环境中迈出了第一步(使用当前神经网络和epsilon的值作为参数)。 请记住,仅当此步骤是情节中的最后一步时,此函数才会返回“ 无”结果。 在这种情况下,我们会在控制台中报告进度(播放的剧集数量,最近100集的平均奖励以及epsilon的当前值):

    while True:
    frame_idx += 1
    epsilon = max(epsilon*eps_decay, eps_min)
    reward = agent.play_step(net, epsilon, device=device) if reward is not None:
    total_rewards.append(reward)
    mean_reward = np.mean(total_rewards[-100:])
    print(“%d: %d games, mean reward %.3f, (epsilon %.2f)” %
    (frame_idx, len(total_rewards), mean_reward, epsilon))

    After, every time our mean reward for the last 100 episodes reaches a maximum, we report this in the console and save the current model parameters in a file. Also, if this mean rewards exceed the specified MEAN_REWARD_BOUND ( 19.0 in our case) then we stop training. The third if, helps us to ensure our experience replay buffer is large enough for training:

    之后,每当我们对最近100集的平均奖励达到最大值时,我们将在控制台中报告此情况并将当前模型参数保存在文件中。 另外,如果平均奖励超过指定的MEAN_REWARD_BOUND (在我们的示例中为19.0),我们将停止训练。 第三个条件是否可以帮助我们确保我们的体验重播缓冲区足够用于训练:

    if best_mean_reward is None or 
    best_mean_reward < mean_reward:
    torch.save(net.state_dict(),
    DEFAULT_ENV_NAME + “-best.dat”)
    best_mean_reward = mean_reward
    if best_mean_reward is not None:
    print(“Best mean reward updated %.3f” %
    (best_mean_reward))if mean_reward > MEAN_REWARD_BOUND:
    print(“Solved in %d frames!” % frame_idx)
    breakif len(buffer) < replay_start_size:
    continue

    学习阶段 (Learn phase)

    Now we will start to describe the part of the code, from the main loop, that refers to the phase where the network learn (a portion of the previous pseudocode):

    现在,我们将从主循环开始描述代码的一部分,该部分指的是网络学习的阶段(先前伪代码的一部分):

    Image for post

    The whole code that we wrote for implementing this part is as follows:

    我们为实现此部分而编写的整个代码如下:

    batch = buffer.sample(batch_size) 
    states, actions, rewards, dones, next_states = batchstates_v = torch.tensor(states).to(device)
    next_states_v = torch.tensor(next_states).to(device)
    actions_v = torch.tensor(actions).to(device)
    rewards_v = torch.tensor(rewards).to(device)
    done_mask = torch.ByteTensor(dones).to(device)state_action_values = net(states_v).gather(1,
    actions_v.unsqueeze(-1)).squeeze(-1)
    next_state_values = target_net(next_states_v).max(1)[0]
    next_state_values[done_mask] = 0.0
    next_state_values = next_state_values.detach()expected_state_action_values=next_state_values * gamma + rewards_vloss_t = nn.MSELoss()(state_action_values,
    expected_state_action_values)optimizer.zero_grad()
    loss_t.backward()
    optimizer.step()if frame_idx % sync_target_frames == 0:
    target_net.load_state_dict(net.state_dict())

    We are going to dissect it to facilitate its description since it is probably the most complex part to understand.

    我们将对其进行剖析以便于对其进行描述,因为它可能是最难理解的部分。

    The first thing to do is to sample a random mini-batch of transactions from the replay memory:

    首先要做的是从重播内存中采样一个随机的小批量事务:

    batch = buffer.sample(batch_size) 
    states, actions, rewards, dones, next_states = batch

    Next, the code wraps individual NumPy arrays with batch data in PyTorch tensors and copies them to GPU ( we are assuming that the CUDA device is specified in arguments):

    接下来,代码将带有批处理数据的单个NumPy数组包装在PyTorch张量中,并将它们复制到GPU(我们假设在参数中指定了CUDA设备):

    states_v = torch.tensor(states).to(device)
    next_states_v = torch.tensor(next_states).to(device)
    actions_v = torch.tensor(actions).to(device)
    rewards_v = torch.tensor(rewards).to(device)
    done_mask = torch.ByteTensor(dones).to(device)

    This code inspired by the code of Maxim Lapan. It is written in a form to maximally exploit the capabilities of the GPU by processing (in parallel) all batch samples with vector operations. But explained step by step it can be understood without problems.

    此代码受Maxim Lapan代码的启发。 它以某种形式编写,可以通过使用矢量运算处理(并行)所有批处理样本来最大程度地利用GPU的功能。 但是一步一步地解释它可以毫无问题地理解。

    Then, we pass observations to the first model and extract the specific Q-values for the taken actions using the gather() tensor operation. The first argument to this function call is a dimension index that we want to perform gathering on. In this case, it is equal to 1, because it corresponds to actions dimension:

    然后,我们将观察结果传递给第一个模型,并使用gather()张量操作提取所采取动作的特定Q值。 此函数调用的第一个参数是我们要对其进行收集的维度索引。 在这种情况下,它等于1,因为它对应于动作维度:

    state_action_values = net(states_v).gather(1, 
    actions_v.unsqueeze(-1)).squeeze(-1)

    The second argument is a tensor of indices of elements to be chosen. Here it is a bit more complex to explain the code. Let’s try it!. Maxim Lapan suggest to use the functions unsqueeze() and squeeze(). Because the index should have the same number of dimensions as the data we are processing (2D in our case) it apply a unsqueeze()to the action_v (that is a 1D) to compute the index argument for the gather functions. Finally, to remove the extra dimensions we have created, we will use the squeeze()function. Let’s try to illustrate what a gather does in summary on a simple example case with a batch of four entries and four actions:

    第二个参数是要选择的元素的索引张量。 在这里,解释代码有点复杂。 让我们试试吧! Maxim Lapan建议使用unsqueeze()squeeze()函数。 因为索引应具有与我们正在处理的数据相同的维数(在本例中为2D unsqueeze() ,所以action_v ( unsqueeze()应用于action_v (即1D)以计算action_v函数的index参数。 最后,要删除我们创建的额外尺寸,我们将使用squeeze()函数。 让我们尝试在一个简单的示例案例中总结一下汇总操作,该示例案例包含四个条目和四个操作:

    Image for post

    Note that the result of gather() applied to tensors is a differentiable operation that will keep all gradients with respect to the final loss value.

    请注意,应用于张量的collect()的结果是可微分​​的操作,该操作将相对于最终损耗值保留所有梯度。

    Now that we have calculated the state-action values for every transition in the replay buffer, we need to calculate target “y” for every transition in the replay buffer too. Both vectors are the ones we will use in the loss function. To do this, remember that we must use the target network.

    现在我们已经为重播缓冲区中的每个过渡计算了状态操作值,我们还需要为重播缓冲区中的每个过渡计算目标“ y”。 这两个向量都是我们将在损失函数中使用的向量。 为此,请记住我们必须使用目标网络。

    In the following code, we apply the target network to our next state observations and calculate the maximum Q-value along the same action dimension, 1:

    在下面的代码中,我们将目标网络应用于下一个状态观察,并沿着相同的动作维度计算最大Q值:

    next_state_values = target_net(next_states_v).max(1)[0]

    Function max() returns both maximum values and indices of those values (so it calculates both max and argmax). Because in this case, we are interested only in values, we take the first entry of the result.

    函数max()返回最大值和这些值的索引(因此它同时计算max和argmax)。 因为在这种情况下,我们只对值感兴趣,所以我们将结果的第一项输入。

    Remember that if the transition in the batch is from the last step in the episode, then our value of the action doesn’t have a discounted reward of the next state, as there is no next state from which to gather the reward:

    请记住,如果批次中的过渡是从情节的最后一步开始的,则我们的动作价值不会获得对下一个状态的折扣奖励,因为没有下一个状态可以从中收集奖励:

    next_state_values[done_mask] = 0.0

    Although we cannot go into detail, it is important to highlight that the calculation of the next state value by the target neural network shouldn’t affect gradients. To achieve this, we use thedetach() function of the PyTorch tensor, which makes a copy of it without connection to the parent’s operation, to prevent gradients from flowing into the target network’s graph:

    尽管我们无法详细介绍,但重要的是要强调一点,目标神经网络对下一状态值的​​计算不应影响梯度。 为此,我们使用了PyTorch张量的detach()函数,该函数在不连接父级操作的情况下复制了它,以防止梯度流入目标网络的图形中:

    next_state_values = next_state_values.detach()

    Now, we can calculate the Bellman approximation value for the vector of targets (“y”), that is the vector of the expected state-action value for every transition in the replay buffer:

    现在,我们可以为目标向量(“ y”)计算Bellman近似值,也就是重放缓冲区中每个过渡的预期状态作用值的向量:

    expected_state_action_values=next_state_values * gamma + rewards_v

    We have all the information required to calculate the mean squared error loss:

    我们拥有计算均方误差损失所需的所有信息:

    loss_t = nn.MSELoss()(state_action_values, 
    expected_state_action_values)

    The next piece of the training loop updates the main neural network using the SGD algorithm by minimizing the loss:

    训练循环的下一部分使用SGD算法,通过将损失最小化来更新主神经网络:

    optimizer.zero_grad()
    loss_t.backward()
    optimizer.step()

    Finally, the last line of the code syncs parameters from our main DQN network to the target DQN network every sync_target_frames:

    最后,代码的最后一行每隔sync_target_frames将参数从我们的主要DQN网络同步到目标DQN网络:

    if frame_idx % sync_target_frames == 0:
    target_net.load_state_dict(net.state_dict())

    And so far the code for the main loop!

    到目前为止,主循环的代码!

    接下来是什么? (What is next?)

    This is the second of three posts devoted to present the basics of Deep Q-Network (DQN), in which we present in detail the algorithm. In the next post, we will talk about the performance of the algorithm and also show how we can use it.

    这是专门介绍Deep Q-Network(DQN)基础的三篇文章中的第二篇,我们在其中详细介绍了该算法。 在下一篇文章中 ,我们将讨论该算法的性能,并展示如何使用它。

    翻译自: https://towardsdatascience.com/deep-q-network-dqn-ii-b6bf911b6b2c

    创建dqn的深度神经网络

    展开全文
  • 创建dqn的深度神经网络 深层加固学习介绍— 15 (DEEP REINFORCEMENT LEARNING EXPLAINED — 15) In the previous post, we have presented solution methods that represent the action-values in a small table. We...
  • 图解DQN,DDQN,DDPG网络1. DQN1.1 网络结构1.2 产生experience的过程1.3 Q网络的更新流程2. DDQN2.1 网络结构2.2 产生experience的过程2.3 Q网络的更新流程3. DDPG3.1 网络结构3.2 产生experience的过程3.3 Actor...
  • 前言 对于Q-learning算法,有两点不足之处: 维度灾难;这是由于查找表存储和更新Q值时需要在...DQN应运而生,采用深度神经网络为非线性函数逼近,以表示高维连续状态空间中的Q值函数。, θ即参数化的神经网络。...
  • 基于神经网络DQN方法

    千次阅读 2017-10-05 21:55:32
    需要明白两个概念,一个是Q网络,一个是targrtQ网络,Q网络是我们预测网络,targrt Q网络可以认为是我们的训练网络,训练的目标是找到目标Q值:,这里目标Q值的定义依据时间差分算法(n-step TD,一般采用单步时差...
  • dqn

    千次阅读 2019-05-28 15:58:47
    DL与RL结合的问题 ...DL目标分布固定;RL的分布一直变化,比如你玩一个游戏,一个关卡和下一个关卡的状态分布是不同的,所以训练好了前一个关卡,下一个关卡又要重新训练; 过往的研究表明,使用非线...
  • 然后引入基于深度Q网络的边缘计算方法,以计算任务处理速率加权和为优化目标建立任务卸载模型;最后建立基于 DQN 的车辆终端自主最优任务卸载策略,最大化卸载决策制定模型的长期效用。仿真结果表明,相比Q学习算法...
  • DeepMind技术的研究人员开发了一种称为Deep Q学习网络(DQN) 的方法,该方法受益于深度学习在学习最优策略的抽象表示方面的优势,即以最大化累积奖励总和的期望值的方式选择行动。它是前一个工作的延伸神经拟合Q学习...
  • DQN-深度Q网络

    2018-05-05 18:31:00
    深度Q网络是用深度学习来解决强化中Q学习的问题,可以先了解一下Q学习的过程是一个怎样的过程,实际上就是不断的试错,从试错的经验之中寻找最优解 关于Q学习,我看到一个非常好的例子,另外知乎上面也有相关的讨论...
  • Double DQN

    2020-07-06 14:11:36
    由于深度神经网络提供了灵活的函数逼近与低渐近逼近误差的潜力,DQN 在 Atari 2600 游戏中的带来了更好的性能。但是,DQN有时也会大大高估行动的价值。使用 DQN的改进版本(Double DQN)能够产生更准确的值估计,...
  • Nature DQN与Double DQN

    2020-02-03 09:08:00
    在前面的文章强化学习DQN算法中,介绍了经典的DQN算法,然而DQN也存在一些问题。Nature DQN与Double DQN的提出就是为了解决这些问题,下面笔者将介绍这个两种改进的算法...
  • 理解DQN算法

    万次阅读 2017-08-28 22:14:02
    从Q Learning到DQN网络
  • DQN高级技巧

    2021-08-30 20:26:55
    a)Q^*(s,a)Q∗(s,a)函数,它叫做动作价值函数,它依赖于当前的状态s和动作a,它基于当前状态s给所有的动作a打分,分数反映了动作a的好坏,Agent应该执行分数最高的动作,DQN的意思是使用神经网络来近似Q∗Q^*Q∗函数...
  • 文章目录第八章 深度强化学习-Nature深度Q网络(Nature DQN)8.1 Nature DQN网络模型8.2 Nature DQN算法8.3 实验结果8.3.1 参数设置8.3.2 算法效果8.4 结论参考文献 第八章 深度强化学习-Nature深度Q网络(Nature DQN) ...
  • DQN变体:Nature DQN

    2019-12-16 13:57:14
    这篇文章主要讨论DQN的变体,Nature DQN。... 还记得计算当前目标QQQ值yjy_jyj​的公式是: yj={Rj  is_endj is trueRj+γmaxa′Q(ϕ(Sj′),Aj′,w)  is_endj is false...
  • DQN & Double DQN

    2020-09-26 19:59:43
    Fixed Q-targets:有两个神经网络分别预测Q现实和Q估计 包含: 记忆库(用于重复学习) 神经网络计算Q值 暂时冻结q_target参数(切断相关性,更有效率的收敛) q_target (Q现实)现实中的值 需要建立...
  • 文章目录一、为什么要引入神经网络二、DQN 算法2.1 DQN 约等于 Q-learning + 神经网络2.2 DQN 的两大创新2.2.1 经验回放 Experience replay2.2.2 固定 Q 目标 Fixed Q target2.3 DQN 流程框架图2.4 PARL 的 DQN 框架...
  • 简而言之,DQN用深度神经网络(CNN或DNN)替换了表格,并使用目标网络来执行Bellman方程更新。 为了实现它,使用了一些技巧,例如目标网络和体验重播。 引入目标网络以收敛模型,因为频繁更新会使模型处于不稳定...
  • 本篇介绍三种DQN的变体,分别是从参数更新部分改进的Double DQN,从经验回放部分改进的Prioritized DQN,从神经网络结构部分改进的Dueling DQN。 Double DQN 上一篇提到的DQN是基于Q-learning,更新也是基于贪婪...
  • 文章目录前言第六章 DQN 前言 重读《Deep Reinforcemnet Learning Hands-on》, 常读常新, 极其深入浅出的一本深度强化学习教程。 本文的唯一贡献是对其进行了翻译和提炼, 加一点自己的理解组织成一篇中文笔记。 ...
  • DQN 以及 DQN的扩展

    2017-10-17 11:30:34
    本文主要记录关于DQN(Deep Reinforcement Learning)的相关论文以及loss function 以及 近几年在DQN的基础上进行改进的算法。若要了解强化学习或者DQN本身原理的,可以出门左拐。DQN paper Playing Atari with Deep ...

空空如也

空空如也

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

dqn目标网络