读书笔记TF038:实现估值网络

TensorFlow Serving https://tensorflow.github.io/serving/ 。

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,比较高初始值,鼓励模型多探索。

范生命周期管理。模型先数据训练,逐步来初步模型,优化模型。模型多重算法试验,生成模型管理。客户端(Client)向TensorFlow
Severing请求模型,TensorFlow Severing返回适当模型给客户端。TensorFlow
Serving、gRPC(谷歌公司从头源高性能、跨语言RPC框架),提供跨语言RPC接口,不同编程语言都得以看模型。

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

TensorFlow Serving代码 https://hithub.com/tensorflow/serving
。源代码Bazel编译安装
https://github.com/tensorflow/serving/blob/master/tensorflow\_serving/g3doc/setup.md
,Docker安装。https://www.tensorflow.org/serving/setup 。结合TensorFlow
Serving,训练好模型,创建Docker镜像,推送至Google Container Registry
https://cloud.google.com/container-registry/docs/
。模型在谷歌云平台(Google Cloud
Platform)运行。Kubernetes成功安排模型服务。Serving Inception Model with
TensorFlow Serving and Kubernetes
https://tensorflow.github.ic/serving/serving\_inception 。Google ML
Engine,全托管TensorFlow平台,训练模型一键转换预测服务。

state of the art DQN
Trick。第一只Trick。DQN引入卷积层。模型通过Atari游戏视频图像了解环境信息并学习策略。DQN需要了解接收图像,具有图像识别能力。卷积神经网络,利用而领空间组织信息卷积层抽取特征。卷积层提取图像中要对象特征污染为后叠举行分类、回归。DQN用卷积层做强化学习训练,根据环境图像输出决策。

TensorFlow Flod https://github.com/tensorflow/fold ,《Deep Learning
with Dynamic Computation Graphs》https://openreview.net/pdf?id=ryrGawqex
。深度上过程,模型训练多少预处理,不同结构数据剪裁成相同维度、尺寸,划分成批,进入训练流程。静态图模型,缺点,输入数据无法一般先处理,模型针对不同输入数据建立不同计算图(computation
graph)分别训练,没有充分利用处理器、内存、高速缓存。
TensorFlow
Fold(现在尚闹了Eager模式,可以对比上),根据不同结构输入数据建立动态计算图(dynamic
computation),根据每个不同输入数据建立不同计算图。动态批处理(dynamic
batching)自动组合计算图,实现输入数据里批处理,批处理单个输入图内不同节点,不同输入数据里面批处理,批处理不同输入图间运算。可插入附加指令以不同批处理操作间移动多少。简化模型训练阶段输入数据预处理过程。CPU模型运行速度提高10倍以上,GPU提高100倍增。

次个Trick。Experience Replay。深度上得大量样本,传统Q-Learning
online
update方法(逐一对新样本学习)不称DQN。增大样本,多单epoch训练,图像反复用。Experience
Replay,储存Agent
Experience样本,每次训练随机抽取部分样书供网络学习。稳定就上任务,避免短视只学习时接触样本,综合反复用过往大量样本学习。创建储存Experience缓存buffer,储存一定量较新样本。容量满了,用新样本替换最老样本,保证大部分样本相近概率被压缩到。不替换旧样本,训练过程为裁减到概率永远比新样本高很多。每次用训练样本,直接从buffer随机抽取一定量被DQN训练,保持样本高利用率,让范学习及比较新样本。

TensorFlow计算加速。GPU设备,XLA
框架融合OP,分布式计算、参数有分布及不同机器,硬件计算,CPU更尖端命令集SSE、AVX,FPGA编写支持TensorFlow计算单元。
CPU加速。pip命令安装,与再广阔机器兼容,TensorFlow默认仅于x86机器使用SSE4.1
SIMD指令。源代码安装可赢得最老性,开启CPU高级指令集支持。bazel
构建只能当融洽机器运行二进制文件。

老三独Trick。用第二个DQN网络帮助训练,target
DQN,辅助计算目标Q值,提供上目标公式里之maxaQ(st+1,a)。两单网络,一个打学习目标,一个事实上训练,让Q-Learning训练目标保持平稳。强化学习
Q-Learning学习目标每次转,学习目标分部是范本身输出,每次换代模型参数会招致学习目标变,更新往往幅度颇,训练过程会那个勿安静、失控,DQN训练会陷于目标Q值与展望Q值反馈循环(陷入震荡发散,难消)。需要安静target
DQN辅助网络计算目标Q值。target
DQN,低频率、缓慢学习,输出目标Q值波动较小,减多少训练过程影响。

bazel build -c opt –copt=-mavx –copt=-mavx2 –copt=-mfma
–copt=-mfpmath=both –copt=-msse4.2 –copt=-cuda -k
//tensorflow/tools/pip_package:build_pip_package
bazel-bin/tensorflow/tools/pip_package/build_pip_package
/tmp/tensorflow_pkg

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

在/tmp/tensorflow_pkg产生whell文件,再就此pip命令安装wheel文件。

第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对环境状态估计能力更胜。

TPU 加速、FPGA加速。
谷歌TensorFlow设计专用集成芯片-张量处理单元(Tensor Processing
Unit,TPU)。CPU逻辑运算(if
else)能力非常强,计算能力比较GPU差,深度上得海量计算。GPU有强有力浮点计算单元,GPU着色器(shader)对相同批数量因相同步调执行同一指令流水。GPU同一时钟周期执行命令数量千级,3000长。CPU同一时钟周期执行令数据几十层。数据交互能力颇为超CPU。GPU逻辑运算能力不同,流水线并行能力(同一时钟周期起执行不一逻辑序列能力)差,需要批数量并调整执行同样逻辑。神经网络需要广大数据交互能力,CNN卷积、矩阵运算操作,通过数据交互大幅提高性能。
GPU出厂后搭固定,硬件原生支持指令固定。如神经网络有GPU不支持指令,无法直接硬件实现,只能软件模拟。FPGA加速,开发者在FPGA里编程,改变FPGA硬件结构。FPGA体系布局不同,不是冯·诺伊曼结构,是代码描述逻辑电路。只要片及逻辑门、引脚够多,全部输入、运算、输出都以一个时钟周期内形成。FPGA一个时钟周期执行同一次等全体发热好电路,一个模块就同句超复杂“指令”,不同模块不同逻辑序列,序列里就是一样漫长指令。不同运算单元硬件直连,数据交互、流水线并行共存(GPU流水线并行能力约0),浮点运算能力不使GPU。适合低顺延预测推理,每批大小比较小。
TPU,专用集成电路(application specific integrated
circuit,ASIC),硬件逻辑一旦烧写不可再编程,专门为TensorFlow做深上开发。TPU目前本不克完全运作TensorFlow功能,高效预测推理,不干训练。

贯彻带Trick DQN。任务环境
GridWorld导航类水言纟工。GridWorld包含一个hero,4只goal,2独fire。控制hero移动,每次向上、下、左、右方向运动一步,多触碰goal(奖励值1),避开fire(奖励值-1)。游戏目标,限度步数内用到无限多分。Agent
直接通过GridWorld图像上决定hero移动最优质政策。

机械上评测系统。

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

人脸识别性能指标。
分辨性能,是否鉴别准确。Top-K识别率,给有前K个结果包含对结果概率。错误拒绝辨识率(FNIR),注册用户给网错误辩识为其它注册用户比重。错误受辩识率(FPIR),非注册用户给系统识别为有注册用户比重。
证性能,验证人脸模型是否足够好。误识率(False Accept
Rate,FAR),将其他人误作指定人员概率。拒识率(False Reject
Rate,FRR),将点名人员误作其他人员概率。识别速度,识别一符合人脸图像时、识别一个口日子。注册速度,注册一个总人口时。

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

闲聊机器人性能指标。
回应正确率、任务完成率、对话回合数、对话时、系统平均响应时间、错误信息率。评价为主单元,单轮对话。人机对话过程,连续经过。http://sanwen.net/a/hkhptbo.html
《中国人工智能学会通讯》2016年第6窝第1盼。聊天机器人,机器人答句和用户问句应该语义一致,语法正确,逻辑是。机器人答句以有趣、多样,不是一直有安全应对。机器人应该个性表达相同,年龄、身份、出生地基本背景信息、爱好、语言风险当相同,能想象成一个名列前茅人。

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

机械翻译评价方法。
BLEU(bilingual evaluation
understudy)方法,2002年,IBM沃森研究中心提出。机器翻译语句与人类专业翻译语句越接近越好。下人工评价高度相关。正确句子作参照译文(reference)、正确句子(golden
sentence),测试句子作候选译文(candidate)。适用测试语料具有多单参考译文。比较参考译文与候选译文相同片段数量,参考译文连续出现N元组(N个单词或字)与候选译文N元组比较,n单位有的(n-gram)比较。计算了配合N元组个数与参考译文N元组总个数比例。与岗位无关。匹配片段数越多,候选译文质量更好。
METEOR,不仅要求候选译文在合句子上,在句子分段级别达到,都如和参考译文更接近。https://en.wikipedia.org/wiki/METEOR\#Algorithm
。在得评字符串与参考文符串间创造平面图。待评翻每个一元组必须映射到参考翻译1单或0单一元组。选择映射交叉数据较少的。

概念环境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。

常用通用评价指标。
准确率、召回率、F值、ROC、AUC、AP、mAP。
ROC(Receiver Operating Characteristic,受试者工作特色曲线)、AUC(Area
Under roc Curve,曲线下面积),评价分类器指标。ROC曲线横坐标FPR(False
positive rate),纵为标TPR(True positive
rate)。ROC曲线越接近左上角,分类器性能进一步好。AUC,ROC曲线下端积大小。ROC曲线处于y=x直线上,AUC值介于0.5~1.0。AUC值更怪表示性能更好。专门AUC计算工具
http://mark.goadrich.com/programs/AUC/ 。
AP(average precision,平均准确性)、mAP(mean average
precision,平均准确性平均)。计算机视觉,分类问题,AP模型分类能力主要指标。只用P(precision
rate, 准确率)和R(recall
rate,召回率)评价,组成PR曲线趋势召回率越强准确率越低。AP曲线下面积,等于对召回率做积分。mAP对具备品类取平均,每个接近作同样糟糕第二分拣任务。图像分类论文基本用mAP标准。

落实活动敢角色方法,传入值0、1、2、3季个数字,分别表示及、下、左、右。函数根据输入操作英雄移动。如果运动该方向会招致英雄出界,不见面开展其它活动。

当着数据集。

概念newPosition方法,选择一个同现有物体不闯位置。itertools.product方法得到几独变量所有结成,创建环境size允许持有职位集合points,获取目前持有物体位置集合currentPositions,从points去掉currentPositions,剩下可用位置。np.random.choice随机抽取一个可用位置返回。

图数集。
ImageNet http://www.image-net.org/
。世界最酷图像识别数据集,14197122布置图像,斯坦福大学视觉实验室终身教授李飞飞创立。每年ImageNet大赛是国际计算机视觉顶级赛事。
COCO http://mscoco.org/
。微软开创,分割、加字幕标注数据集。目标划分,通过上下文进行甄别,每个图像包含多单对象靶,超过300000图像,超过2000000实例,80种植对象,每个图像包含5个字幕,包含100000单人口第一点。
CIFAR(Canada Institude For Advanced Research) https://www.cifar.ca/
。加拿大先进技术研究院收集。8000万聊图数集。包含CIFAR-10、CIFAR-100两单数据集。CIFAR-10,60000布置32×32
RGB彩色图片,共10独品类,50000摆设训练,10000摆测试(交叉验证)。CIFAR-100,60000摆放图像,100只品种,每个项目600摆设图像,500摆设训练,100摆测试。20单特别类,每个图像包含小类、大项目两个号。

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

人脸数据集。
AFLW(Annotated Facial Landmarks in the Wild)
http://lrs.icg.tugraz.at/research/aflw/
,从Flickr收集带标注面部图像大规模wyskwgk,各种姿态、表情、光照、种族、性别、年龄因素影响图片,25000万手工标注人脸图片,每个人脸标注21只特征点,大多数多彩,59%阴,41%阳。非常适合人脸识别、人脸检测、人脸对旅。
LFW(Labeled Faces in the Wild Home) http://vis-www.cs.umass.edu/lfw/
。美国马萨诸塞大学阿姆斯特分校计算机视觉实验室整理。13233布置图片,5749丁,4096总人口就来一样摆图,1680单多被同一摆放。用于研究不受限情形人脸识别问题。人脸外形不安静,面部表情、观察角度、光照条件、室内室外、遮盖物(口罩、眼镜、帽子)、年龄影响。为文化界评价识别性标准(benchmark)。
GENKI http://mplab.ucsd.edu
,加利福尼亚大学搜集。包含GENKI-R2009a、GENKI-4K、GENKI-SZSL。GENKI-R2009a,11159图。GENKI-4K,4000图形,笑与不笑两像样,每个图片人脸姿势、头转动标注角度,专用笑脸识别。GENKI-SZSL,3500图像,广泛背景、光照条件、地理位置、个人身份、种族。
VGG Face http://www.robots.ox.ac.uk/~vgg/data/vgg\_face/
。2622单不等人,每个人1000摆图纸,训练人脸识别大数据集。
CelebA(Large-scale CelebFaces Atributes,大规模名人人脸标注数据集)
http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html
。10177只名人,202599摆名人图像,每张图像40个属性标注。

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

视频数据集。
YouTube-8M https://research.google.com/youtube8m/
。800万只YouTube视频URL,50万钟头长度视频,带有视频标注。

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

问答数据集。
MS MARCO(Microsoft Machine Reading Comprehension) http://www.msmarco.org
。微软颁发,10万单问题及答案数据集。创建像人类同看、回答问题系统。基于匿名真实数据构建。
康奈尔大学影视对白数据集
https://www.cs.cornell.edu/~cristian/Cornell\_Movie-Dialogs\_Corpus.html
。600管好莱坞影片对白。

调用gameEnv类初始化方法,设置size
5,创建5×5深小GridWorld环境,每次创建GridWorld环境随机生成。小尺寸环境相对容易学,大尺寸较难以,训练日又增长。

电动开数据集。
法国国家信息与自动化研究所旅客数据集(INRIA Person Dataset)
http://pascal.inrialpes.fr/data/human/
。作为图像以及视频中直立人检测研究工作有搜集。图片两栽格式,一存有相应注释文件原始图像,二兼有老图像经过正规处理64×128像素正像。图片分止生车、只有人、有车有人、无车无论人4单项目。
KITTI(Karlsruhe Institute of Technology and Toyota Technological
Institute) http://www.cvlibs.net/datasets/kitti/
。车辆数据集,7481个教练图片、7518单测试图。标注车辆档次、是否截断、遮挡情况、角度值、二维和三维框、位置、旋转角度。

计划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。

年纪、性别数据集。
Adience 数据集 http://www.openu.ac.il/home/hassner/Adience/data.html
。来源Flickr相册。用户用智能手机设备拍摄,2284种类,26580布置图。保留光照、姿势、噪声影响。性别、年龄估计、人脸检测。

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。

参考资料:
《TensorFlow技术解析和实战》

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

迎推荐上海机上工作时,我之微信:qingxingfengzi

定义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