各个一样仅仅宠物,都是命中注定的敏锐性

若果一个口一如既往龙举行的10项事中,有1码是能够带动被协调快的,那他的生活就是会见全盘无一样。

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值波动较小,减多少训练过程影响。

拉来我家那天非常寒冷,一放到地下,冻得咕咕叫着寻找妈妈。我无暇用来有点衣服被它过上,一会儿,拉拉摇摇晃晃地服到处找食。问尽公才知道,这奶狗才28天,刚断奶。

第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,创建5×5万分小GridWorld环境,每次创建GridWorld环境随机变化。小尺寸环境相对好学,大尺寸较难以,训练时间重新丰富。

杀在心中之石块终于诞生,我开了销魂之铲屎官的活着。从上马半夜起来喂食到每天花心机给其举行营养餐;从用零食诱导上洗手间及每日带她出去晒太阳运动;从总兴奋地拖在自奔向到任意在坝子边陪自己同跑;从本人躲闪着街坊各种奇异的眼力,到自家带在些许狗快乐地动自己的的路程,让旁人说去。我以等候在她自从死神到天使的变动。

计划DQN(Deep
Q-Network)网络。使用卷积层,可以一直打环境原始像素学习策略。输入scalarInput,扁平化长为84x84x3=21168朝量,恢复成[-1,84,84,3]尺寸图片ImageIn。tf.contrib.layers.convolution2d开立第1独卷积层,卷积核尺寸8×8,步长4×4,输出通道数(filter数量)32,padding模型VALID,bias初始化器空。用4×4升幅和VALID模型padding,第1重合卷积输出维度20x20x32。第2重叠卷积尺寸4×4,步长2×2,输出通道数64,输出维度9x9x64。第3交汇卷积尺寸3×3,步长1×1,输出通道数64,输出维度7x7x64。第4重合卷积尺寸7×7,步长1×1,输出通道数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

去年新春佳节,哥哥出门二十几近天,拉拉天天闷闷不乐地以老伴到齐他老大哥回,我与拉拉说:哥哥去东莞了,你绝不当他了,他从来不那么尽快回来的。

无我么说,拉拉中心就是肯定:家里还来只亲属没回去,我如果赶他回去了。

截至一个绚烂的下午,我任性地对拉说:一会哥哥便回了,你以女人当,我跟耙耙去送货。

恰恰出来没多久,就收取楼下五金店之业主打来电话,说我家的星星点点单单狗出去了,跑至街道上。

自身同样听,惨,家里没有人,难道是拉拉会自己开门出去了?万同样发生意外怎么惩罚?心中不断祈祷……

回去小区,谢天谢地,黄咪咪小朋友以于小区我的电动车及,黄拉拉于楼梯口,五金店之翠红阿姨陪在边。

咦,总算平安无事。

翠红兴奋地告知我,你家拉拉多聪明,刚才本人在公寓里,拉拉跑上店来,着急向本人摇尾巴咕咕叫,一会便映入眼帘一只有些狗冲了街道,发现凡是咪咪,我远远叫咪咪回来,咪咪不纵,我走过去将它得到回,拉拉就无敢跑,然后她还累及正本人及楼去你家。

我倒及拉拉前边,拉拉知道遇到损了,拢拉在耳朵,蹲坐在,不歇伸腿要和自己掌握手求饶。

哟,气死我了,这家伙肯定是听到哥哥要回,自己打开门,生性胆小的拉拉于大胆的喵带领一起走出去寻找哥哥的。

啊可能今天太兴奋,第一不良学会了初步大门。

就算当上个月底一个冰凉的夜晚,我带来拉拉去花园散步归来,头起头晕,我坐于铺上,一阵天旋地转后上马胃部翻滚,拉拉着急又忐忑地扣押正在自我,眼睛写满了令人担忧。

我盛地一阵呕吐,等自我呕完,处理干净后,摸摸它的腔,对其说:没事,别担心。

拉长深呼一人口暴,慢慢放松下来,摇着尾巴用头紧紧地贴住我。

亚上清晨,我打算去看医生,拉拉追自己只要出,我本着她说:你以太太,我失去押医生,等自身回还带来您去花园。

关押了晚,我回小区停车,忽然楼梯口一团影子冲过来,转身才看清黄拉拉卡在平等仅仅爱之玩意儿飞奔下来,它快地过起来抱住自家,仿佛在游说:你怎么才回到,担心生我了。然后嗷嗷叫地吃着拉我上楼。

还要同样不好让她的情深意切所动,仿佛在告诉我:世界老大老,我只有你,我会直接陪同和看在你的。

合计自己,经常坐忙或懒惰把它们丢在单方面,而她可直接无偏离不弃地陪伴我左右。

拽,它只是是一致单休极端尊重的拉布拉多拧,然而其以是本人的家人,是敏感,我用很小爱对它,它也就此无穷的易来报我。

谢谢拉拉小聪,因为碰到,触及了自心头最柔软的真情实意,让自身学会了易,学会了满足常乐,很庆幸此生遇见它。

咱们所救的
,终将拯救我们。
当即是《一条狗底沉重》里之经典台词,是呀,原以为自己多么巨大拯救了人家,实际上更温馨心灵的救赎,是于援救自己。

尘世有的宠物都是命中注定的机智,请不要还伤。愿就世界多同卖好,珍惜人民吧!