学习笔记TF038:实现估值网络

Q-Learning，学习Action对应期望值(Expected Utility)。1989年，Watkins提出。收敛性，1992年，Watkins和Dayan共同证明。学习期望价值，从当前一步到所有后续步骤，总期望获取最大价值(Q值、Value)。Action->Q函数，最佳策略，在每个state下，选择Q值最高的Action。不依赖环境模型。有限马尔科夫决策过程(Markov Dectision Process) ,Q-Learning被证明最终可以找到最优策略。

Q-Learning目标，求解函数Q(st,at),根据当前环境状态，估算Action期望价值。Q-Learning训练模型，以(状态、行为、奖励、下一状态)构成元组(st,at,rt+1,st+1)样本训练，st当前状态，at当前状态下执行action，rt+1执行Action后获得奖励，st+1下一状态，(当前状态，行动，奖励，下一状态)。特征(st,at)。学习目标(期望价值) rt+1+γ·maxaQ(st+1,a)，当前Action获得Reward，加下一步可获得最大期望价值，当前状态行动奖励，加下一状态行动最大期望价值。学习目标包含Q-Learning函数本身，递归求解。下一步可获最大期望价值乘γ(衰减系数discount factor)，未来奖励的学习权重。discount factor 0,模型学习不到任何未来奖励信息，变短视，只关注当前利益。discount factor >= 1,算法可能无法收敛，期望价值不断累加没有衰减(discount)，期望价值发散。discount factor一般比1稍小。Qnew(st,at)<-(1-α)·Qold(st,at)+α·(rt+1+γ·maxaQ(st+1,a))，Q-Learning学习过程式子。旧Q-Learning函数Qold(st,at)，向学习目标(当前获得Reward加下一步可获得最大期望价值)，按较小学习速率α学习，得到新Q-Learning函数Qnew(st,at)。学习速率决定新获取样本信息覆盖率前掌握到信息比率，通常设较小值，保证学习过程稳定，确保最后收敛性。Q-Learning需要初始值Q0,比较高初始值，鼓励模型多探索。

学习Q-Learning模型用神经网络，得到模型是估值网络。用比较深的神经网络，就是DQN。Google DeepMind，《Nature》论文，《Human-level control through deep reinforcement learning》提出。DeepMind用DQN创建达到人类专家水平玩Atari2600系列游戏Agent。

state of the art DQN Trick。第一个Trick。DQN引入卷积层。模型通过Atari游戏视频图像了解环境信息并学习策略。DQN需要理解接收图像，具有图像识别能力。卷积神经网络，利用可提取空间结构信息卷积层抽取特征。卷积层提取图像中重要目标特征传给后层做分类、回归。DQN用卷积层做强化学习训练，根据环境图像输出决策。

第二个Trick。Experience Replay。深度学习需要大量样本，传统Q-Learning online update方法(逐一对新样本学习)不适合DQN。增大样本，多个epoch训练，图像反复利用。Experience Replay，储存Agent Experience样本，每次训练随机抽取部分样本供网络学习。稳定完成学习任务，避免短视只学习最新接触样本，综合反复利用过往大量样本学习。创建储存Experience缓存buffer，储存一定量较新样本。容量满了，用新样本替换最旧样本，保证大部分样本相近概率被抽到。不替换旧样本，训练过程被抽到概率永远比新样本高很多。每次需要训练样本，直接从buffer随机抽取一定量给DQN训练，保持样本高利用率，让模型学习到较新样本。

第三个Trick。用第二个DQN网络辅助训练，target DQN，辅助计算目标Q值，提供学习目标公式里的maxaQ(st+1,a)。两个网络，一个制造学习目标，一个实际训练，让Q-Learning训练目标保持平稳。强化学习 Q-Learning学习目标每次变化，学习目标分部是模型本身输出，每次更新模型参数会导致学习目标变化，更新频繁幅度大，训练过程会非常不稳定、失控，DQN训练会陷入目标Q值与预测Q值反馈循环(陷入震荡发散，难收敛)。需要稳定target DQN辅助网络计算目标Q值。target DQN，低频率、缓慢学习，输出目标Q值波动较小，减小训练过程影响。

第4个Trick。Double DQN。DeepMind 《Deep Reinforcement Learning with Double Q-Learning》。传统DQN高估Action Q值，高估不均匀，导致次优Action被高估超过最优Action。target DQN 负责生成目标Q值，先产生Q(st+1,a)，再通过maxa选择最大Q值。Double DQN，在主DQN上通过最大Q值选择Action，再获取Action在target DQN Q值。主网选择Action，targetDQN生成Action Q值。被选择Q值，不一定总是最大，避免被高估次优Action总是超过最优Action，导致发现不了真正最好Action。学习目标公式：Target=rt+1+γ·Qtarget(st+1,argmaxa(Qmain(st+1,a)))。

第5个Trick。Dueling DQN。Google 《Dueling Network Architectures for Deep Reinforcement Learning》。Dueling DQN，Q值函数Q(st,at)拆分，一部分静态环境状态具有价值V(st)，Value；另一部分动态选择Action额外带来价值A(at)，Advantage。公式，Q(st,at)=V(st)+A(at)。网络分别计算环境Value和选择Action Advantage。Advantage，Action与其他Action比较，零均值。网络最后，不再直接输出Action数量Q值，输出一个Value，及Action数量 Advantage值。V值分别加到每个Advantage值上，得最后结果。让DQN学习目标更明确，如果当前期望价值主要由环境状态决定，Value值大，所有Advantage波动不大；如果期望价值主要由Action决定，Value值小，Advantage波动大。分解让学习目标更稳定、精确，DQN对环境状态估计能力更强。

实现带Trick DQN。任务环境 GridWorld导航类水言纟工。GridWorld包含一个hero，4个goal，2个fire。控制hero移动，每次向上、下、左、右方向移动一步，多触碰goal(奖励值1)，避开fire(奖励值-1)。游戏目标，限度步数内拿到最多分数。Agent 直接通过GridWorld图像学习控制hero移动最优策略。

创建GridWorld任务环境。载入依赖库，itertools迭代操作，scipy.misc、matplotlib.pyplot绘图，训练时间长，os定期储存模型文件。

创建环境内物体对象class。环境物体属性，coordinates(x,y坐标)、size(尺寸)、intensity(亮度值)、channel(RGB颜色通道)、reward(奖励值)、name(名称)。

创建GridWorld环境class，初始化方法只传入参数环境size。环境长、宽为输入size，环境Action Space设4,初始化环境物体对象列表。self.reset()方法重置环境，得到初始observation(GridWorld图像)，plt.imshow展示observation。

定义环境reset方法。创建所有GridWorld物体，1个hero(用户控制对象)、4个goal(reward 1)、2个fire(reward -1)，添加到物体对象列表self.objects。self.newPosition()创建物体位置，随机选择没有被占用新位置。物有物体size、intensity 1,hero channel 2(蓝色),goal channel 1(绿色)，fire channel 0(红色)。self.renderEnv()绘制GridWorld图像，state。

实现移动英雄角色方法，传入值0､1､2､3四个数字，分别代表上、下、左、右。函数根据输入操作英雄移动。如果移动该方向会导致英雄出界，不会进行任何移动。

定义newPosition方法，选择一个跟现有物体不冲突位置。itertools.product方法得到几个变量所有组合，创建环境size允许所有位置集合points，获取目前所有物体位置集合currentPositions，从points去掉currentPositions，剩下可用位置。np.random.choice随机抽取一个可用位置返回。

定义checkGoal函数。检查hero是否触碰goal、fire。从objects获取hero，其他物体对象放到others列表。编历others列表，如果物体和坐标与hero完全一致，判定触碰。根据触碰物体销毁，self.newPosition()方法在随机位置重新生成物体，返回物体reward值(goal 1,fire -1)。

创建长宛size+2､颜色通道数 3 图片。初始值全1,代表全白色。最外圈内部像素颜色值全部赋0,代表黑色。遍历物体对象列表self.objects，设置物体亮度值。scipy.misc.imresize将图像从原始大小resize 84x84x3尺寸，正常游戏图像尺寸。

定义GridWorld环境执行一步Action方法。输入参数Action，self.moveChart(action)移动hero位置，self.checkGoal()检测hero是否触碰物体，得到reward、done标记。self.renderEnv获取环境图像state，返回state、reward、done。

调用gameEnv类初始化方法，设置size 5,创建5x5大小GridWorld环境，每次创建GridWorld环境随机生成。小尺寸环境相对容易学习，大尺寸较难，训练时间更长。

设计DQN(Deep Q-Network)网络。使用卷积层，可以直接从环境原始像素学习策略。输入scalarInput，扁平化长为84x84x3=21168向量，恢复成[-1,84,84,3]尺寸图片ImageIn。tf.contrib.layers.convolution2d创建第1个卷积层，卷积核尺寸8x8,步长4x4,输出通道数(filter数量)32,padding模型VALID，bias初始化器空。用4x4步长和VALID模型padding，第1层卷积输出维度20x20x32。第2层卷积尺寸4x4,步长2x2,输出通道数64,输出维度9x9x64。第3层卷积尺寸3x3,步长1x1,输出通道数64,输出维度7x7x64。第4层卷积尺寸7x7,步长1x1,输出通道数512,空间尺寸只允许在一个位置卷积，,输出维度1x1x512。

tf.split()，第4个卷积层输出conv4平均拆分两段，streamAC、streamVC，Dueling DQN Advantage Function(Action带来的价值)和Value Function(环境本身价值)。tf.split函数第2参数代表要拆分成几段。第3参数代表要拆分几个维度。tf.contrib.layers.flatten将streamAC和streamVC转遍平的steamA和steamV。创建streamA和streamV线性全连接层参数AW和VW。tf.random_normal初始化权重，tf.matmul做全连接层矩阵乘法，得到self.Advantage和self.Value。Advantage针对Action，输出数量为Action数量。Value针对环境统一的，输出数量 1。Q值由Value、advantage复合成，Value加上减少均值Advantage。Advantage减去均值操作 tf.subtract，均值计算tf.reduce_mean函数(reduce_indices 1,代表Action数量维度)。最后输出Action，Q值最大Action，tf.argmax。

定义Double DQN目标Q值targetQ输入placeholder，Agent动作actions输入placeholder。计算目标Q值，action由主DQN选择，Q值由辅助target DQN生成。计算预测Q值，scalar形式actions转onehot编码形式，主DQN生成的Qout乘以actions_onehot，得预测Q值(Qout和actions都来自主DQN)。

定义loss，tf.square、tf.reduce_mean计算targetQ和Q均方误差，学习速率1e-4 Adam优化器优化预测Q值和目标Q值偏差。

实现Experience Replay策略。定义experience_buffer class。初始化定义buffer_size存储样本最大容量，创建buffer列表。定义向经buffer添加元素方法。如果超过buffer最大容量，清空最早样本，列表末尾添加新元素。定义样本抽样方法，用random.sample()函数随机抽取一定数量样本。

定义84x84x3 states扁平化 1维向量函数processState，方便后面堆叠样本。

updateTargetGraph函数，更新target DQN模型参数(主DQN用DQN class self.updateModel方法更新模型参数)。输入变量tfVars，TensorFlow Graph全部参数。tau，target DQN向主DQN学习的速率。函数updateTargetGraph取tfVars前一半参数，主DQN模型参数。再令辅助targetDQN参数朝向主DQN参数前进很小比例(tau,0.001)，target DQN缓慢学习主DQN。训练时，目标Q值不能在几次迭代间波动太大，训练非常不稳定、失控，陷入目标Q值和预测Q值反馈循环。需要稳定目标Q值训练网络，缓慢学习target DQN网络输出目标Q值，主网络优化目标Q值和预测Q值间loss，target DQN跟随主DQN缓慢学习。函数updateTargetGraph创建更新target DQN模型参数操作，函数updateTarget执行操作。

DQN网络训练过程参数。batch_size，每次从experience buffer获取样本数，32。更新频率update_freq，每隔多少step执行一次模型参数更新，4。Q值衰减系数(discount factor)γ，0.99。startE起始执行随机Action概率。endE最终执行随机Action概率。anneling_steps从初始随机概率降到最终随机概率所需步数。num_episodes总共多少次GridWorld环境试验。pre_train_steps正式用DQN选择Action前进行多少步随机Action测试。max_epLength每个episode进行多少步Action。load_model是否读取之前训练模型。path模型储存路径。h_size是DQN网络最后全连接层隐含节点数。tau是target DQN向主DQN学习速率。

Qnetwork类初始化mainQN和辅助targetQN。初始化所有模型参数。trainables获取所有可训练参数。updateTargetGraph创建更新target DQN模型参数操作。

experience_buffer创建experience replay class，设置当前随机Action概率e，计算e每一步衰减值stepDrop。初始化储存每个episode的reward列表rList，总步数total_steps。创建模型训练保存器(Saver)检查保存目录是否存在。

创建默认Session，如果load_model标志True，检查模型文件路径checkpoint，读取载入已保存模型。执行参数初始化操作，执行更新targetQN模型参数操作。创建GridWorld试验循环，创建每个episode内部experience_buffer，内部buffer不参与当前迭代训练，训练只使用之前episode样本。初始化环境得第一个环境信息s，processState()函数扁平化。初始化默认done标记d、episode内总reward值rAll、episode内步数j。

创建内层循环，每次迭代执行Action。总步数小于pre_train_steps，强制用随机Action，只从随机Action学习，不强化过程。达到pre_train_steps，保留较小概率随机选择Action。不随机选择Action，传入当前状态s给主DQN，预测得到应该执行Action。env.step()执行一步Action，得到接下来状态s1､reward、done标记。processState对s1扁平化处理，s、a、r、s1､d传入episodeBuffer存储。

总步数超过pre_train_steps，持续降低随机选择Action概率e，直到最低值endE。每当总步数达到update_freq整数部，进行一次训练，模型参数更新。从myBuffer中sample出一个batch_size样本。训练样本第3列信息，下一状态s1,传入mainQN，执行main.predict，得到主模型选择Action。s1传入辅助targetQN，得到s1状态下所有Action的Q值。mainQN输出Action ,选择targetQN输出Q，得到doubleQ。两个DQN网络把选择Action和输出Q值两个操作分隔开，Double DQN。训练样本第2列信息，当前reward，加doubleQ乘以衰减系数γ，得到学习目标targetQ。传入当前状态s，学习目标targetQ和实际采取Action，执行updateTarget函数，执行targetQN模型参数更新(缓慢向mainQN学习)。完整完成一次训练过程。每个step结束，累计当前这步获取reward，更新当前状态为下一步试验做准备。如果done标记为True，直接中断episode试验。

episode内部episodeBuffer添加到myBuffer，作以后训练抽样数据集。当前episode reward添加到rList。每25个episode展示平均reward值。每1000个episode或全部训练完成，保存当前模型。

初始200个episode内，完全随机Action的前10000步内，平均可以获得reward在2附近，基础baseline。

训练最后episode输出，平均reward 22,非常大提升。

计算每100个episode平均reward,plt.plot展示reward变化趋势。从第1000个episode开始，reward快速提升，到第4000个episode基本达到高峰，后面进入平台期，提升不大。

    import numpy as np
    import random
    import tensorflow as tf
    import os
    %matplotlib inline
    from gridworld import gameEnv
    env = gameEnv(size=5)
    class Qnetwork():
        def __init__(self,h_size):
            #The network recieves a frame from the game, flattened into an array.
            #It then resizes it and processes it through four convolutional layers.
            self.scalarInput =  tf.placeholder(shape=[None,21168],dtype=tf.float32)
            self.imageIn = tf.reshape(self.scalarInput,shape=[-1,84,84,3])
            self.conv1 = tf.contrib.layers.convolution2d( \
                inputs=self.imageIn,num_outputs=32,kernel_size=[8,8],stride=[4,4],padding='VALID', biases_initializer=None)
            self.conv2 = tf.contrib.layers.convolution2d( \
                inputs=self.conv1,num_outputs=64,kernel_size=[4,4],stride=[2,2],padding='VALID', biases_initializer=None)
            self.conv3 = tf.contrib.layers.convolution2d( \
                inputs=self.conv2,num_outputs=64,kernel_size=[3,3],stride=[1,1],padding='VALID', biases_initializer=None)
            self.conv4 = tf.contrib.layers.convolution2d( \
                inputs=self.conv3,num_outputs=512,kernel_size=[7,7],stride=[1,1],padding='VALID', biases_initializer=None)

            #We take the output from the final convolutional layer and split it into separate advantage and value streams.
            self.streamAC,self.streamVC = tf.split(self.conv4,2,3)
            self.streamA = tf.contrib.layers.flatten(self.streamAC)
            self.streamV = tf.contrib.layers.flatten(self.streamVC)
            self.AW = tf.Variable(tf.random_normal([h_size//2,env.actions]))
            self.VW = tf.Variable(tf.random_normal([h_size//2,1]))
            self.Advantage = tf.matmul(self.streamA,self.AW)
            self.Value = tf.matmul(self.streamV,self.VW)

            #Then combine them together to get our final Q-values.
            self.Qout = self.Value + tf.subtract(self.Advantage,tf.reduce_mean(self.Advantage,reduction_indices=1,keep_dims=True))
            self.predict = tf.argmax(self.Qout,1)

            #Below we obtain the loss by taking the sum of squares difference between the target and prediction Q values.
            self.targetQ = tf.placeholder(shape=[None],dtype=tf.float32)
            self.actions = tf.placeholder(shape=[None],dtype=tf.int32)
            self.actions_onehot = tf.one_hot(self.actions,env.actions,dtype=tf.float32)

            self.Q = tf.reduce_sum(tf.multiply(self.Qout, self.actions_onehot), reduction_indices=1)

            self.td_error = tf.square(self.targetQ - self.Q)
            self.loss = tf.reduce_mean(self.td_error)
            self.trainer = tf.train.AdamOptimizer(learning_rate=0.0001)
            self.updateModel = self.trainer.minimize(self.loss)

    class experience_buffer():
        def __init__(self, buffer_size = 50000):
            self.buffer = []
            self.buffer_size = buffer_size

        def add(self,experience):
            if len(self.buffer) + len(experience) >= self.buffer_size:
                self.buffer[0:(len(experience)+len(self.buffer))-self.buffer_size] = []
            self.buffer.extend(experience)

        def sample(self,size):
            return np.reshape(np.array(random.sample(self.buffer,size)),[size,5])

    def processState(states):
        return np.reshape(states,[21168])

    def updateTargetGraph(tfVars,tau):
        total_vars = len(tfVars)
        op_holder = []
        for idx,var in enumerate(tfVars[0:total_vars//2]):
            op_holder.append(tfVars[idx+total_vars//2].assign((var.value()*tau) + ((1-tau)*tfVars[idx+total_vars//2].value())))
        return op_holder
    def updateTarget(op_holder,sess):
        for op in op_holder:
            sess.run(op)
    batch_size = 32 #How many experiences to use for each training step.
    update_freq = 4 #How often to perform a training step.
    y = .99 #Discount factor on the target Q-values
    startE = 1 #Starting chance of random action
    endE = 0.1 #Final chance of random action
    anneling_steps = 10000. #How many steps of training to reduce startE to endE.
    num_episodes = 10000#How many episodes of game environment to train network with.
    pre_train_steps = 10000 #How many steps of random actions before training begins.
    max_epLength = 50 #The max allowed length of our episode.
    load_model = False #Whether to load a saved model.
    path = "./dqn" #The path to save our model to.
    h_size = 512 #The size of the final convolutional layer before splitting it into Advantage and Value streams.
    tau = 0.001 #Rate to update target network toward primary network
    tf.reset_default_graph()
    mainQN = Qnetwork(h_size)
    targetQN = Qnetwork(h_size)
    init = tf.global_variables_initializer()
    trainables = tf.trainable_variables()
    targetOps = updateTargetGraph(trainables,tau)
    myBuffer = experience_buffer()
    #Set the rate of random action decrease.
    e = startE
    stepDrop = (startE - endE)/anneling_steps
    #create lists to contain total rewards and steps per episode
    rList = []
    total_steps = 0
    #Make a path for our model to be saved in.
    saver = tf.train.Saver()
    if not os.path.exists(path):
        os.makedirs(path)
    #%%
    with tf.Session() as sess:
        if load_model == True:
            print('Loading Model...')
            ckpt = tf.train.get_checkpoint_state(path)
            saver.restore(sess,ckpt.model_checkpoint_path)
        sess.run(init)
        updateTarget(targetOps,sess) #Set the target network to be equal to the primary network.
        for i in range(num_episodes+1):
            episodeBuffer = experience_buffer()
            #Reset environment and get first new observation
            s = env.reset()
            s = processState(s)
            d = False
            rAll = 0
            j = 0
            #The Q-Network
            while j < max_epLength: #If the agent takes longer than 200 moves to reach either of the blocks, end the trial.
                j+=1
                #Choose an action by greedily (with e chance of random action) from the Q-network
                if np.random.rand(1) < e or total_steps < pre_train_steps:
                    a = np.random.randint(0,4)
                else:
                    a = sess.run(mainQN.predict,feed_dict={mainQN.scalarInput:[s]})[0]
                s1,r,d = env.step(a)
                s1 = processState(s1)
                total_steps += 1
                episodeBuffer.add(np.reshape(np.array([s,a,r,s1,d]),[1,5])) #Save the experience to our episode buffer.

                if total_steps > pre_train_steps:
                    if e > endE:
                        e -= stepDrop

                    if total_steps % (update_freq) == 0:
                        trainBatch = myBuffer.sample(batch_size) #Get a random batch of experiences.
                        #Below we perform the Double-DQN update to the target Q-values
                        A = sess.run(mainQN.predict,feed_dict={mainQN.scalarInput:np.vstack(trainBatch[:,3])})
                        Q = sess.run(targetQN.Qout,feed_dict={targetQN.scalarInput:np.vstack(trainBatch[:,3])})
                        doubleQ = Q[range(batch_size),A]
                        targetQ = trainBatch[:,2] + y*doubleQ
                        #Update the network with our target values.
                        _ = sess.run(mainQN.updateModel, \
                            feed_dict={mainQN.scalarInput:np.vstack(trainBatch[:,0]),mainQN.targetQ:targetQ, mainQN.actions:trainBatch[:,1]})

                        updateTarget(targetOps,sess) #Set the target network to be equal to the primary network.
                rAll += r
                s = s1

                if d == True:
                    break

            #Get all experiences from this episode and discount their rewards.
            myBuffer.add(episodeBuffer.buffer)
            rList.append(rAll)
            #Periodically save the model.
            if i>0 and i % 25 == 0:
                print('episode',i,', average reward of last 25 episode',np.mean(rList[-25:]))
            if i>0 and i % 1000 == 0:
                saver.save(sess,path+'/model-'+str(i)+'.cptk')
                print("Saved Model")
        saver.save(sess,path+'/model-'+str(i)+'.cptk')
    #%%
    rMat = np.resize(np.array(rList),[len(rList)//100,100])
    rMean = np.average(rMat,1)
    plt.plot(rMean)

参考资料：
《TensorFlow实战》

欢迎付费咨询(150元每小时)，我的微信：qingxingfengzi