神经网络笔记

喜欢ヅ旅行 2022-06-08 12:26 1105阅读 0赞

神经网络总流程  
1.计算分值（分值越高就表明分类结论）  
2.计算损失函数（一般损失函数+正则化惩罚）  
3.正则化惩罚(可以看作是对损失函数的惩罚项，一般有两种方法，L1和L2，W的平方w2，为了惩罚那些虽然分值一样但是，关注的点和实际点有很大出路，例如1,0,0,0和0.25，0.25，0.25，0.25,惩罚越小就越认可，目的也是通过loss值，使得权重更均衡。其实1,0,0,0也是一种过拟合的表现)

将总分值转变为百分比sigmod函数  
使用这个函数可以将分值转变成0-1，而且可以构成分值虽然相差不多，但是百分比却相差很大的表现  
但是这个函数也有很大的缺点，就是当进行sigmoid以后，当接近于1时，梯度很可能就变成0，导致梯度消失,梯度消失也就意味着更新权重w的值为0.

损失函数的作用  
通过损失函数来调整权值W，例如如果W增加，而损失值变小，则继续增加W

反响传播的作用  
1.知道W1对损失值的影响，是-的还是+的，是几倍的关系，然后就去更新W  
2.通过损失值，反向的知道每一层神经层Wx对损失值的影响，最终反应到W1

梯度下降法BGD,SGD,MBGD,Adam  
1. 批量梯度下降法BGD（Batch gradient descent）  
遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习  
2. 随机梯度下降法SGD（stochastic gradient descent）  
每看一个数据就算一下损失函数，然后求梯度更新参数，这个称为随机梯度下降，stochastic gradient descent。这个方法速度比较快，但是收敛性能不太好，可能在最优点附近晃来晃去，hit不到最优点。两次参数的更新也有可能互相抵消掉，造成目标函数震荡的比较剧烈。  
3. 小批量梯度下降法MBGD  
克服两种方法的缺点，现在一般采用的是一种折中手段，mini-batch gradient decent，小批的梯度下降，这种方法把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大。  
基本上现在的梯度下降都是基于mini-batch的，所以Keras的模块中经常会出现batch\_size，就是指这个。  
顺便说一句，Keras中用的优化器SGD是stochastic gradient descent的缩写，但不代表是一个样本就更新一回，还是基于mini-batch的。  
4. Adam是一种可以替代传统随机梯度下降过程的一阶优化算法,自适应时刻估计方法（Adaptive Moment Estimation），能计算每个参数的自适应学习率

学习率  
对每次更新W的幅度不要太大（一般为0.001或者0.0001）

整个神经网络的设计精髓  
为了降低损失值

为啥需要多个神经层：  
因为一个神经层只能做到初略的划分，越复杂的分类，就需要多个神经层来进行组合区分

sigmoid和softmax对应的损失函数  
binary cross-entropy和categorical cross-entropy

SVM和softmax损失函数计算  
svm : lose = max(0,y-y’+1)+max(0,y1-y’+1)，缺点，有时候对结果10，9，9这种不能做到很好的区分，因为计算出来都是0  
softmax: lose = -log(sigmoid(score))缺点：不满足算法，因为lose永远都不会为0，所以都会一直在调整

sigmoid函数  
![这里写图片描述][SouthEast]

tanh函数  
和sigmoid犯的同样的错误，杀死梯度  
![这里写图片描述][SouthEast 1]

ReLu函数  
大值就大更新，小值就小更新，小于0的分值就不更新，记为0，现在这个或者它的变种使用得比较多，多于sigmoid和tanh  
![这里写图片描述][SouthEast 2]

神经网路中的超参数主要包括1. 学习率 η，2. 正则化参数 λ，3. 神经网络的层数 L，4. 每一个隐层中神经元的个数 j，5. 学习的回合数Epoch，6. 小批量数据 minibatch 的大小，7. 输出神经元的编码方式，8. 代价函数的选择，9. 权重初始化的方法，10. 神经元激活函数的种类，11.参加训练模型数据的规模 这十一类超参数。

数据预处理  
1.以0为中心  
2.归一化操作(将x和Y的长度一样，更规则)

权重W初始化  
1.不能用0值  
2.使用随机初始化w=0.01\*np.random.randn(D,H), D,H\[0,1\]  
3.最常用的是高斯初始化

Drop-out  
1.就是随机选择一部分神经元杀死(不工作)，不使用全链接（一般只用60%）  
2.目的就是不让神经网络过于复杂，并且提高神经网络的泛化能力，一定程度上防止过拟合  
理论基础在于假设:生物在识别图像的时候，对图像的理解只需要处理局部的数据即可，不需要全面分析全部图像后才能进行处理。这一假设在图像处理领域得到了广泛应用，证明其简单有效。

卷积神经网络（CNN,Convolution Neural Net）：  
1.输入层input  
2.卷积层conv（输出特征图，即原始矩阵上的代表）  
3.激活函数  
4.池化层（压缩特征图，一个pooling过程和卷积差不多，也是使用一个filter，一个步长stride进行压缩,一般有两种方法mean和max，而且计算的时候W权重参数）  
5.全链接层

卷积：  
为什么叫卷积:因为我们使用一个filter在一张n\*n图像上以stride=1一步一步平移，每移一步就做一个计算，所以这个移动又计算的过程就称为卷积。  
就是通过将原矩阵，然后按一小块一小块划分后，在每小块中提取概括特征作为一个代表，然后得到一个特征图  
例如，32\*32\*3 而小区域划分filter可为5\*5\*3  
注意：可以使用多个filter，然后提取多个不相干的不同的特征图，  
例如，32\*32\*3通过6个fiter就可以得到6个不同的特征图，28\*1,28\*1,28\*1,28\*1,28\*1,28\*1,28\*1,28\*1,然后这六张图叠在一起就成卷积了  
卷积不一定只能在输入层上做卷积，还可以卷积一次后再做一次卷积都可以，也可以看做是一步一步浓缩的过程

filter是如何定义的，为啥是4\*4\*3  
深度3是深度固定了  
4\*4是通过对原矩阵按步长(stride)来划分的，步长可以2,3,4。。。,为啥不是1,因为太影响效率，得不偿失，但如果选择太大，会有遗漏的情况  
按filter分块以后会出现矩阵边缘元素利用比中间元素少的情况（中的点可能会计算多次，而边缘的计算1次），这时引入一个pad的标志  
pad=1表示在原有矩阵5\*5\*3，向外扩展1，填充0，变成7\*7\*3  
计算公式：输出矩阵大小高，宽都是同个公式 h =（hi - filtersize + 2pad）/步长 +1

权重共享特性：  
1.原矩阵（32\*32\*3），filter(5\*5\*3),得到（32\*32\*3输出矩阵）  
2.这样子会有75（5\*5\*3）个点来决定一个输出矩阵点，如果假设有1000个神经元，这样的计算就太过复杂了，所以采用权重共享  
3.让特征图上所有的点来一起共用一个权重W，这样就可以避免过多的运算  
比如按照上述的情况，就会有760个参数  
也就是说x1,x2,x3 假设有4个神经元，则有  
\[x1,x2,x3\]\*\[w11,w12,w13,w4\] 变成->  
\[w11,w12.w13,w14\] \[w11,w12.w13,w14\]  
\[w21,w22,w23,w24\] -> \[w11,w12.w13,w14\]  
\[w31,w32,w33,w34\] \[w11,w12.w13,w14\]

池化层pooling  
压缩特征图  
在一般pooling中  
比如有224\*224特征图 经过pooling后变成 112\*112，那么本来224\*224应该包含更多的信息，那为啥要进行压缩呢？  
1.便于网络进行计算，更快的收敛  
如何弥补pooling之后特征图的损失？  
一般在卷积conv过后，都会有个深度C，那么就对这个深度C进行翻倍，也就说filter的个数翻倍  
比如卷积过后深度为C1=56，pooling后，再进行卷积变为112,其实这个在AlexNet等经典网络中都有体现，由原来的96->256->384  
bins，对应conv的filter，在pooling不叫filter叫bins，有大小，有个数

为什么要堆叠小的卷积conv?  
堆叠conv后，最后形成的特征点对原始图像的感受野（Receptive Field）  
比如说进行一个3层的conv：  
conv1(3\*3 filter)->conv2(3\*3 filter)->conv3(3\*3 filter)->  
3\*3 5\*5 7\*7  
则最后出来的特征图上的点对原始图像的感受眼为7\*7(包含了原始图像7\*7的特征)  
但这样回想过来，为什么不直接对原始图像用一个7\*7的filter呢？  
1.因为权重参数的个数问题，参数少就不容易发生过拟合现象  
计算参数个数，比如input H\*W\*C  
对于一个直接使用7\*7 filter 进行conv,权重参数为C\*(7\*7\*C)=49 C的平方 个  
而对于一个3\*3 -> 3\*3 -> 3\*3 的3层卷积 参数为3\*C（3\*3\*C）=27 C的平方 个  
2.使用3层卷积比一层卷积具有更强的非线性  
因为一般我们在卷积后都会跟上激活函数，所以非线性更强  
那既然3层3\*3比1层7\*7更好，那为啥不用1\*1呢？  
其实在ResNet中就有用到1\*1 的bottleneck convolution

为什么要堆叠1\*1 64或者256 filter的卷积？  
为了使输入输出具有相同的维数，比方用在残差结构中，进行卷积池化的计算会改变原来x的filter的个数，这和同等映射x的层数不一样，就使用该1\*1 64或者256 filter结构进行修改，1\*1也意味着每一特征点都使用到。

dense的意思  
在keras里面，dense就是全连接层的意思  
在densenet里面，是一种比较复杂的网络结构

Inception结构  
为什么需要Inception结构  
1.参数太多，容易过拟合，若训练数据集有限；  
2.网络越大计算复杂度越大，难以应用；  
3.网络越深，梯度越往后穿越容易消失（梯度弥散），难以优化模型  
解决上述问题的方法当然就是增加网络深度和宽度的同时减少参数，Inception就是在这样的情况下应运而生  
转：[GoogleNet的Inception\_v1、Inception\_v2、Inception\_v3、Inception\_v4(整理)][GoogleNet_Inception_v1_Inception_v2_Inception_v3_Inception_v4]

对于卷积神经网络，有两个经典问题  
classification 和 location  
classification指对样本进行分类  
location 指对样本里面的内容进行定位，比如说人在这图片中的什么位置，也是基于回归来做的。  
对于训练过程主要以框为单位，就是说计算output的框和实际的框直接的差距，计算出损失值loss L2

经典的卷积网络模型  
1.Lenet，1986年  
由两个卷积层，两个池化层，以及两个全连接层组成。 卷积都是5\*5的模板，stride=1，池化都是MAX  
2.Alexnet，2012年  
这个model的意义比后面那些model都大很多，首先它证明了CNN在复杂模型下的有效性，然后GPU实现使得训练在可接受的时间范围内得到结果，确实让CNN和GPU都大火了一把，顺便推动了有监督DL的发展。  
只有寥寥八层（不算input层），但是它有60M以上的参数总量，事实上在参数量上比后面的网络都大。  
（1）con - relu - pooling - LRN  
（2）conv - relu - pool - LRN  
（3）conv - relu  
（4）conv-relu  
（5）conv - relu - pool  
（6）fc - relu - dropout  
（7）fc - relu - dropout  
（8）fc - softmax  
3.GoogleNet，2014年  
这个model证明了一件事：用更多的卷积，更深的层次可以得到更好的结构。  
基本上构成部件和alexnet差不多，不过中间有好几个inception的结构。  
4.VGG，2014年  
VGG有很多个版本，也算是比较稳定和经典的model。它的特点也是连续conv多，计算量巨大（比前面几个都大很多）。  
而且和alexnet很大的差别在于conv的filter都是3\*3，pooling都是2\*2，比alexnet小得多  
5.Deep Residual Learning（ResNet 深度残差网络），2015年  
进一步将conv进行到底，其特殊之处在于设计了“bottleneck”形式的block（有跨越几层的直连）。最深的model采用的152层。  
6.SqueezeNet 2016  
SqueezeNet设计目标不是为了得到最佳的CNN识别精度，而是希望简化网络复杂度，同时达到public网络的识别精度。所以SqueezeNet主要是为了降低CNN模型参数数量而设计的

其它的模型:  
Overfeat  
DeepPose  
R-CNN

fine tune（翻译过来也就是微调的意思）  
就是说从网上把别人训练好的的模型搞过来（模型的参数已经训练好了)，然后基于别人的模型进行自己的训练  
也就说要下载别人的训练数据，还有模型，其实也就是把别人训练好的参数当作我们模型的初始化，比如之前我们权重使用的高斯初始化  
还有一种就是把别人softmax全链接层前的模型拿过来，然后加上自己的softmax层，也就是可能别人分类1000类，我们只想分100类，就可以这样做

Sliding window  
滑动窗口，就是说对一张图片进行一个n\*n的一个窗口滑动，然后期间也可以对滑动窗口进行一个scale的一个变动，比如变成2\*2或者5\*5

TOP5  
意思就是说一个模型计算出的概率值取前5个，如果正确的label值在这5个里面就算对了，经常用于评估模型

（1）batchsize：批大小。在深度学习中，一般采用SGD训练，即每次训练在训练集中取batchsize个样本训练；  
（2）iteration：1个iteration等于使用batchsize个样本训练一次；  
（3）epoch：1个epoch等于使用训练集中的全部样本训练一次；

举个例子，训练集有1000个样本，batchsize=10，那么：  
训练完整个样本集需要：

100次iteration，1次epoch。

transfer learning（迁移学习）  
对于相似的数据集  
就是说当数据集达不到一定数量的时候，那么就要先去拿别人训练好的模型（比如各种训练好的参数），然后只改变最后的全连接层和输出层  
如果你的数据集数量还行，比如10000这样，那么就是可以只拿别人的一部分，然后加上自己的一些网络结构，  
小贴士:如果别人的模型的学习率为0.01，那么在使用别人的模型的时候把学习率改为0.001

RNN循环神经网络  
比如有  
输入xt  
输出ht  
则ht = fw(ht-1,xt),也就是说现在结果ht需要根据上一次的结果ht-1和当前输入xt结果得到  
这样的结构有什么问题？  
就是在计算ht的时候，把前面的ht-1,ht-2等等都同等对待了。

LSTM结构  
既然原始的RNN有一些问题，所以需要改进  
改进点:  
对前面ht-1,ht-2…都分别进行不同对待(也就是说用权重来衡量)，甚至选择遗忘最前的一些输出h  
LSTM有三个门  
1.忘记门  
其实就是使用sigmod函数，sigmod(w(ht-1,xt)+b)  
sigmod范围为\[0,1\],0表示完全遗忘，1表示完全保留，0-1之间表示保留多少。  
2.输入门  
3.输出门

RNN可以用来做二进制加法，比如只给2个二进制和结果，然后通过RNN，就可以让神经网络学习到二进制加法

faster R-CNN算法（可以用来做location）  
以前做location的时候是这样的  
比如一张600\*600的图片，然后我们就用千把个框框来框出图片里面的内容，然后再进行分类，这样有什么弊端呢？  
1.找框的算法很麻烦，而且框很多  
2.对每个框进行分类，然后某一个框正确率达到80%的时候就算正确了  
3.复杂的计算达不到实时检测location

faster R-CNN提出一种找框的新算法，找出几百个框，然后再使用这几百个框一起去做分类任务（通过一个共享的卷积网络来做），而不是一个一个框去做分类。  
传统的找框模式:  
1.变换图片的大小，比如将图片变换成50\*50,100\*500等等，然后用固定大小的框分别在这些图片上框出。  
2.在卷积中使用不同大小的filter，变换感受野  
3.。。。。

faster R-CNN如何找框  
1.在大量的conv-pooling后(比如VGG16后)，得出来了一张特征图(feature map)，我们知道特征图对应的每一个点都有它对应感受野(比如经过了4次pooling，这感受野为2的次方=16，即16\*16的感受野)  
2.对特征图上的每个点，产生9种不同的框(k anchor，论文中k=9，即框有128,256，512，然后分别再有比例有1:1，1:2，2:1,所有有3\*3=9个)(精髓所在，这样可以使用一张图，然后共享整个卷积，而不是每个框，都有自己的卷积)，即Region Propsal Network  
也就是说input->vgg->feature map -> proposals层（faster R-CNN核心，RPN net）->RoI pooling -> classifier  
其中这个proposals层不仅输出多个框，还输出每个框对于分类的得分值score

找到框后该怎么做（RoI pooling）  
1.一般我们输入的都是相同大小的图片，比如50\*50，而不能改变图片大小，不仅如此，对于不同大小的输入，也会导致conv和pooling之后输出也不一样，这样跟后面的全连接层也无法匹配计算。  
那么在proposal后得到不同大小的框，该如何进行卷积或者别的计算呢，这使用就用到RoI pooling，  
也就是说RoI pooling可以将不同大小的框得到经过RoI pooling输出到固定相同大小，然后就可以跟后面的全连接层了  
2.就是说RoI pooling能自适应输入框的大小。

如何训练这样一个网络  
1.label标签怎么给出，就是图上的物体给出框的坐标大小，然后当使用prososals输出的框来一个一个比较的时候，只要框符合百分之70就算对了  
2.如何调整框，那就通过loss值来调整。

人脸识别  
目前存在的问题  
1.人脸比如做了一些变换，摆个pose啥的，识别起来有问题  
2.识别的速度过慢，CNN确实存在这样的问题  
论文A Convolutional Neural Network Cascade for Face Detection提出了解决方案  
论文提出:在CPU的情况下可以达到14FPS，GPU达到100FPS  
Cascade思想  
1.把一个大输入resize变成一个小的，不是大小变化256\*256变成48\*48，而是采用级联的形式  
2.采用12-net,25-net,48-net的形式  
3.比如先采用12-net，基于faster R-CNN对每个特征点对应的感受野，进行框的扫描，然后应用分类快速的过滤掉基本没用的区域，然后再对留下来的区域进行甄别  
4.24-net也是做这样的操作，12-net -> 24-net -> 48-net

ResNet

残差网络  
不是要简简单单的去堆叠卷积，而是:  
比方有输入x,经过两层卷积后输出F(x),这个F(x)在ReLu之后会使得training error增高，那么为了不使得training error增高，就使用了同等映射x  
即.H(x) = F(x)+x后再进行Relu,当F(x)使training error下降的时候，就将F(x)中的权重设置为0的时候，这样至少training error和当前一样，不会降低

Batch Normalization(BN)  
就是在卷积和ReLu之间，加一层归一化，即对卷积后的输出进行一次归一化再Relu使得收敛更快

Prisma图像风格转换APP  
输入一张日常生活照(content)，和一张风格图片(style)，然后将两张图片进行融合，日常生活照就带有风格图片的风格色彩  
如何做到？  
1.使用别人训练好的能够对物体检测的VGG网络  
2.两张图片如何融合？  
首先随机生成一张噪音图像x  
输入x ->w（w固定，已经训练好了）->x1  
不更新w,而是更新x,使其变成x1,那么lost值是lost\_total = a\*lost\_content + b \* lost\_style,其中a和b为系数，可以a/b可以尝试不同的比例；其实也就是说  
一张随机噪音图像x,经过卷积后，同时和content和style对比计算lost值后回去更新x,最后生成x1  
3.为啥使用别人训练好的物体检测VGG  
这是为了更好的识别物体然后效果更好

如何从0开始训练好一个网络？  
1.简化数据量，只拿20%的数据集  
2.逐渐增加网络的层数和神经元的个数，比如从10个开始慢慢往上加  
3.将loss值和正确率accuracy打印出来  
4.可以先调整学习率的数量级(0.1,0.01)，然后查看loss值和正确率  
5.提前停止，就是说在正确率在就近的20个epoch一直保持不变，就停止训练了  
6.正则惩罚项参数优化。（1）首先loss函数不包含正则项，只是先确定学习率(2)当学习率训练好以后，再用验证集来选择正则惩罚项参数(3)搞定正则化惩罚项参数以后，再重新返回调学习率  
7.一个batch的大小怎么设置好，一般为32,64,128，2的次方

Data Augmentation（数据增强）

比如:输入一张图片，我们要对图片进行变换，一般变化个10倍左右

1.Horizontal flips（水平翻转）  
2.Random crops/scales（随机裁剪和压缩），  
Random crops  
一张图片本来比如800\*600，然后我们对它进行裁剪，变成300\*300，然后裁剪很多张。  
问题:裁剪出来的图片有时候不成样，会不会误导模型？  
不会，因为就是每次模型的输入都不是标准的图片(比如说就是完整的一只猫)，而实际很可能就只有猫头，或者各种别的角度拍摄，遮蔽现象等，所以进行裁剪还是有利于识别的  
Random scales  
对图片进行缩放，有时候scales以后还会再进行crops  
ResNet都会做，看看代码  
3.Random mix/combinations（随机混淆或者排列）  
translation(对图像里面的内容进行移动，比如把图片中的狗，移到别的位置)  
ritation(角度变换，比如对图片进行小范围的旋转)  
stretching(延伸)  
shearing(修剪)  
Color shifting(颜色偏移)，就是说图片由RGB3通道颜色，采用PCA color augmentation，即假如一个图片的R和G成分较多，那么该算法则会相应的减少R,G的值，而增加B的值

但是一般实际再操作的时候不是每个方法弄出2张图片，而是每一变换，都包含了这些操作，比如crops，scales，Horizontal flips一起用

强化学习  
对于阿法狗的机制，对于当前的状态，我的旗子落在哪里得到的奖励值最大  
和传统机器学习对比  
1.不会像传统的机器学习一样分类以后，被告知应该做出什么行为，而是在尝试了以后，才能发现哪些行为会导致奖励的最大化  
2.当前的行为不仅仅会影响及时奖励，还会影响下一步的奖励以及后续所有的奖励

强化学习基本概念  
1.智能体(agent)  
就是一个可以操控的目标，比如阿法狗的棋盘，吃豆游戏的吃豆者，也就是说是一个训练体  
2.状态(state)  
就是当前的状态，环境，比如棋盘上有多少黑子和白子等  
3.行为(action)  
下一步的动作或行为  
4.奖励(reward)  
对行为进行一个衡量，比如这句棋你赢了就是一个奖励  
5.策略(policy)  
在已知状态下可能产生动作的概率分布

每一个动作action都能影响将来的状态state,然后通过一个奖励reward来衡量成功  
目标，选择一系列的动作来最大未来的奖励

马尔科夫决策要求  
1.能够检测到理想状态  
2.可以多次尝试  
3.系统的下个状态只与当前状态信息有关，而与更早之前的状态无关，在决策过程中还和当前采取的动作有关

马尔科夫决策过程5个元素构成  
S:状态集（有限集合，且有一个停止状态）  
A:一组动作（有限集合，比如吃土豆的上下左右）  
P:状态转移概率，当前状态转移到其他状态的一个概率  
R:奖励函数，表示agent采取某个动作后的及时奖励  
Y:折扣的系数,意味着当下的reward比未来反馈reward的更重要

价值函数：  
t时刻的状态s能获得的未来回报的期望  
当前状态的奖励和下一步的价值两部分组成  
既然有价值函数，那么就会有最优价值函数

bellman方程：  
当前状态的价值和下一步的价值即当前的奖励有关  
即当前状态得分值Q = R（s,a）当前得分值+r折扣系数\*sum(R(s1,a1))下一个所有得分状态的和

Q-learning  
通过一个state-action矩阵表示惩罚R(有点像混淆矩阵)  
\-1 -1 -1 0 -1  
\-1 -1 -1 0 100  
\-1 -1 -1 0 -1  
\-1 0 0 -1 -1  
\-1 0 -1 0 100  
表示2->5 ,5->5为100奖励,不存在为-1，存在为0  
Q（3,1）表示在状态为3的情况下往1走的得分值为多少  
即当前状态得分值Q = R（s,a）当前得分值+r折扣系数\*max(R(s1,a1))下一个所有得分状态的最大值  
最后训练出来一个Qtable，然后使用的时候就直接用Qtable进行决策  
比如说一个Qtable  
0 50 100  
100 20 100  
10 59 30  
当我假设s=1的时候，则下一步我会往0这个上跳因为100=100>20  
这样的贪婪，是不是有一个问题就是，我永远会选择前面的一个100而不会选第2个  
为了解决这个问题,引入了  
exploration(探索) VS Exploitation(开发)  
开发就是说按上述的说法，一直使用贪心选择  
探索就是说当我有10%的概率会去走的路线，不会一直走最大分值的路线

episode  
表示从一个状态开始到结束的过程  
1.随机选择一个初始的状态s  
2.假设没有达到目标状态，则进行一下步骤  
(1)在当前状态s的所有可能行为中选取一下个行为a  
(2)利用a,得到下一个状态s1  
(3)按照Q(s,a)计算得分值  
(3)然后另s=s1  
直到到达结束状态

Deep Q Network  
就是将Q-learing加到神经网络来  
比如一个游戏，怎么来定义state和action  
对于state  
我们就定义一个state等于一个batch,然后一个batch由连续4帧图像组成，假设颜色有256种，84\*84，则那这样状态的种类有256的84\*84\*4次方，这样构建的Qtable就太大了  
那该怎么办？这时候就要使用神经网络，也就是Deep Q Network的核心点  
不构造Qtable,直接将(s,a)->network->Q-value值  
0.数据集是怎么来的  
也就经过当前状态s,r然后拿去下一个行为a1,然后再得到s1,r1,over（游戏是否结束）,然后再将这些值组合成一个集合然后存在队列中，这样就可以形成数据集了，然后就可以在  
这个数据集里面划分子集的batch,比如这里说的4帧为一个batch  
1.具体的神经网络输入是啥  
比如：  
s = \[0,1,2,3\]这前面4帧  
s1 = \[1,2,3,4\]下一个状态的4帧  
2.如何确定下一步怎么走a1？  
就按上述描述探索和开发  
3.然后根据拿到下一步行为a1，拿到下一帧，也就拿到下一个状态s1，r1,over，  
4.根据这个s1经过神经网络，得出一个下一步的得分值R(s1,a1)  
5.然后取就可以取当前最大的得分Q = R(s,a)+max(R(s1,a1)),这个就是下一步理应达到的最好奖励状态  
6.再根据当前状态状态s经过神经网络预测下一步动作的各个得分值readout，然后\*\[actions\]，就可以得到当前状态s执行下一个行为a的得分值readout\_action  
7.再经过损失函数lost = Q-readout\_action就可以计算出偏差,然后就反向传播调整权重

其实也就式说：当前的4帧状态经过神经网络计算出acitons个的得分值，然后再\*\[action\]就可以得出s和a1的一个得分值Q，然后再拿下一个状态s1,经过神经网络计算，再  
根据maxR得分值Q1 ，经过损失函数lost = Q1-Q就可以反响传播了  
图像处理工具 opencv  
gym  
pygame

[SouthEast]: /images/20220608/43bdad015567463ebf65fb95aa8c511a.png
[SouthEast 1]: /images/20220608/091c3c881f50498bbfcede9fb5b18740.png
[SouthEast 2]: /images/20220608/2181983e593d47a7a38af147e511beda.png
[GoogleNet_Inception_v1_Inception_v2_Inception_v3_Inception_v4]: https://blog.csdn.net/langb2014/article/details/52787095