您的位置:澳门新葡萄京最大平台 > 动作小游戏 > 学习笔记TF038

学习笔记TF038

发布时间:2019-09-14 14:49编辑:动作小游戏浏览(103)

    落实移动英豪剧中人物方法,传入值0、1、2、3八个数字,分别表示上、下、左、右。函数依据输入操作大侠移动。即使运动该方向会导致英雄出界,不会实行另外活动。

    概念84x84x3 states扁平化 1维向量函数processState,方便前边堆放样本。

    读书Q-Learning模型用神经网络,得到模型是估价网络。用比较深的神经网络,便是DQN。GoogleDeepMind,《Nature》故事集,《Human-level control through deep reinforcement learning》提出。DeepMind用DQN创立达到规定的规范人类专家水平玩Atari2600种类游戏Agent。

    概念情况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。

    其五个Trick。用第2个DQN互联网帮忙磨练,target DQN,协助总计指标Q值,提供就学指标公式里的maxaQ(st+1,a)。三个互联网,四个构建学习目的,三个实在演习,让Q-Learning陶冶指标保持平静。强化学习 Q-Learning学习目的每一遍改动,学习指标分部是模型本人输出,每一回换代模型参数会促成学习目的转移,更新往往幅度大,陶冶进程会特别不安定、失控,DQN磨炼会陷入目的Q值与预测Q值反馈循环(陷入震荡发散,难消失)。供给安静target DQN辅助互联网总括目的Q值。target DQN,低频率、缓慢学习,输出指标Q值波动非常小,减小陶冶进程影响。

    tf.split(),首个卷积层输出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。

    创制GridWorld情形class,伊始化方法只传入参数蒙受size。情况长、宽为输入size,情状Action Space设4,开始化情状物体对象列表。self.reset()方法重新初始化蒙受,获得开端observation(GridWorld图像),plt.imshow体现observation。

    概念newPosition方法,选用二个跟现成物体不冲突地方。itertools.product方法获得多少个变量全数结成,成立遇到size允许持有地点会集points,获取近日全体物体位置集结currentPositions,从points去掉currentPositions,剩下可用地点。np.random.choice随机抽出四个可用地点重返。

    概念GridWorld情状进行一步Action方法。输入参数Action,self.moveChart(action)移动hero地点,self.checkGoal()检查测验hero是不是触碰物体,得到reward、done标识。self.renderEnv获取碰着图像state,再次回到state、reward、done。

    experience_buffer创立experience replay class,设置当前随机Action概率e,总结e每一步衰减值stepDrop。开始化积攒各个episode的reward列表rList,总步数total_steps。成立模型陶冶保存器(Saver)检查保存目录是或不是留存。

    开创景况内物体对象class。意况物体属性,coordinates(x,y坐标)、size(尺寸)、intensity(亮度值)、channel(奥德赛GB颜色通道)、reward(奖励值)、name(名称)。

    成立GridWorld职责境遇。载入重视库,itertools迭代操作,scipy.misc、matplotlib.pyplot绘图,磨练时间长,os按期储存模型文件。

    第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对情状景况测度技能越来越强。

    应接付费咨询(150元每时辰),笔者的微信:qingxingfengzi

    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,相比较高开首值,鼓舞模型多探寻。

    布署DQN(Deep Q-Network)网络。使用卷积层,能够平素从境遇原始像素学习计谋。输入scalarInput,扁平化长为84x84x3=21168向量,恢复生机成[-1,84,84,3]尺寸图片ImageIn。tf.contrib.layers.convolution2d创制首个卷积层,卷积核尺寸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。

    概念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)。

    参照他事他说加以考察资料:
    动作小游戏,《TensorFlow实战》

    state of the art DQN Trick。第三个Trick。DQN引入卷积层。模型通过Atari游戏录制图像了然遭受音讯并学习攻略。DQN需求精晓接收图像,具备图像识别技能。卷积神经互联网,利用可领到空间协会音讯卷积层收取特征。卷积层提取图像中重视对象特征传给后层做分类、回归。DQN用卷积层做强化学习磨练,依照情形图像输出决策。

    实现Experience Replay策略。定义experience_buffer class。起头化定义buffer_size存款和储蓄样本最大容积,创立buffer列表。定义向经buffer添英镑素方法。假使越过buffer最大体积,清空最初样本,列表末尾加多新成分。定义样本抽样格局,用random.sample()函数随机收取一定数额样本。

    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学习速率。

        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)
    

    第四个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)))。

    定义checkGoal函数。检查hero是还是不是触碰goal、fire。从objects获取hero,别的实体对象放置others列表。编历others列表,假设物体和坐标与hero完全一致,判断触碰。依据触碰物体销毁,self.newPosition()方法在大肆地方再度生成物体,重回物体reward值(goal 1,fire -1)。

    总步数当先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平均reward,plt.plot显示reward变化趋势。从第一千个episode开头,reward飞速升高,到第六千个episode基本实现高峰,前边进去平台期,升高相当的小。

    开始200个episode内,完全随机Action的前10000步内,平均能够获得reward在2周围,基础baseline。

    开创长宛size+2、颜色通道数 3 图片。初叶值全1,代表全鲜黄。最外面内部像素颜色值全体赋0,代表淡白紫。遍历物体对象列表self.objects,设置物体亮度值。scipy.misc.imresize将图像从原有大小resize 84x84x3尺寸,不荒谬游玩图像尺寸。

    Q-Learning,学习Action对应期望值(Expected Utility)。1990年,沃特kins提议。收敛性,1994年,沃特kins和Dayan共同验证。学习期望价值,从当前一步到具备继续手续,总希望获取最大价值(Q值、Value)。Action->Q函数,最好战术,在各样state下,选拔Q值最高的Action。不信赖意况模型。有限马尔科夫决策过程(马克ov Dectision Process) ,Q-Learning被证实最后得以找到最优政策。

    episode内部episodeBuffer增添到myBuffer,作今后磨炼抽样数据集。当前episode reward增多到rList。每二十八个episode体现平均reward值。每一千个episode或任何磨练完结,保存当前模型。

    陶冶最终episode输出,平均reward 22,比很大升高。

     

    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实行操作。

    落到实处带Trick DQN。职责环境GridWorld导航类水言纟工。GridWorld包蕴四个hero,4个goal,2个fire。调控hero移动,每一遍向上、下、左、右方向移动一步,多触碰goal(奖赏值1),避开fire(嘉勉值-1)。游戏目的,限度步数内获得最多分数。Agent 直接通过GridWorld图像学习决定hero移动最优政策。

    调用gameEnv类起先化方法,设置size 5,创立5x5大小GridWorld情形,每趟创制GridWorld遭逢随机变化。小尺寸情状相对容命理术数习,大尺寸较难,陶冶时间越来越长。

    Qnetwork类开头化mainQN和协理targetQN。初步化全数模型参数。trainables获取具备可陶冶参数。updateTargetGraph创制革新target DQN模型参数操作。

    其次个Trick。Experience Replay。深度学习供给多量样本,守旧Q-Learning online update方法(逐个对新样本学习)不相符DQN。增大样本,多个epoch操练,图像每每使用。Experience Replay,积存Agent Experience样本,每一回练习随机收取部分样书供网络学习。稳定产生学习任务,防止短视只学习最新接触样本,综合每每使用过往大批量样本学习。创设积累Experience缓存buffer,积攒一定量较新样本。体积满了,用新样本替换最旧样本,保险超越一半样本周围可能率被抽到。不替换旧样本,操练进程被抽到可能率恒久比新样本高相当多。每便须要操练样本,直接从buffer随机抽出一定量给DQN演练,保持样本高利用率,让模型学习到较新样本。

    开创暗中认可Session,若是load_model标记True,检查模型文件路线checkpoint,读取载入已封存模型。实施参数伊始化操作,推行更新targetQN模型参数操作。创制GridWorld试验循环,创立各种episode内部experience_buffer,内部buffer不参与当前迭代练习,练习只行使在此之前episode样本。初阶化碰到得第3个情况音讯s,processState()函数扁平化。开端化暗中同意done标识d、episode内总reward值rAll、episode内步数j。

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

    创办内层循环,每一次迭代实践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存储。

    本文由澳门新葡萄京最大平台发布于动作小游戏,转载请注明出处:学习笔记TF038

    关键词: