大三退隐,安心学习之前总结一下所学的PID知识,备忘
 
PID的数学形式
 
 
PID三个参数的作用
 
   PID控制算法作用是使得输出的实际值尽量稳定快速的接近设定值,并且不需要了解系统本身特性,适用性强
 
  比例控制算法 P
 
      存在偏差时,P成比例的弥补偏差,实际值非不受外界干扰而随时间变化时,P可使得实际值不断逼近设定值,当实际值随外界影响        变化时,此消彼长会使系统出现稳定的偏差,也称为静差.
 
  积分控制算法 I
 
      I用于消除静差.,当系统出现静差时,因为误差存在,积分项会逐渐增大补偿静差,改善系统静态特性
 
  微分控制算法 D
 
     D用于稳定系统的震荡,它根据偏差的变化趋势做出超前调整,加快系统反应速度,减小偏差变化速率,改善系统动态特性
 
PID算法的通俗解释
 
用水缸加水的例子说明(此处是参考别处资料受到的启发,链接见最后)
 
[PI] u=Kp*error
 
水缸水位0.2(实际值), 我们需要它为1(设定值),此时偏差err(1)=1-0.2=0.8
 
取Kp=0.5 单纯P控制
 
t=1 第一时刻 U(1)=Kp*err(1)=0.5*0.8=0.4
 
实际值变为0.6, err(2)=0.4
 
t=2 第二时刻 U(2)=Kp*err(2)=0.5*0.4=0.2
 
实际值变为0.8, err(3)=0.2
 
往复调整,直到err(n)=0 即实际值达到设定值
 
[PI] u=Kp*error+ Ki∗∫ error
 
若上述状况中再使得每个周期时间漏水0.1
 
当实际水位为0.8时
 
P调整为Kp*err=0.5*0.2=0.1
 
刚好与漏水相互抵消,此时系统存在静差0.2
 
此时用I调节,因为稳态时存在静差,I会叠加误差补偿给系统,以此消除静差
 
[PID] u=Kp*error+ Ki∗∫ error+Kd*d err
 
当水位接近设定值时,D会给出反向调节值Ud=Kd*（err（t）-err（t-1））,防止超调,当突然加或者减少大量水时D也会因为变化趋势大而给出较大的负反馈以调节系统动态稳定性
 
PID算法各种形式
 
(1)位置式
 
 
(2)增量式
 
 
(3)积分分离式
 
  普通PID中，引入积分环节的目的主要是为了消除静差，提高控制精度，但是在启动、结束或大幅增减设定时，短时间内系统输出有很大的偏差，会造成PID运算的积分积累，可能导致控制量超过执行机构允许的极限控制量，从而引起较大的超调甚至振荡。
 
        为了克服这一问题，引入了积分分离的概念，其基本思路是当被控量与设定值偏差较大时，取消积分作用；当控制量接近给定值时，引入积分控制以消除静差，提高精度。
 
 (4)抗积分饱和式
 
积分饱和现象是指如果系统存在一个方向的偏差，PID控制器的输出由于积分作用不断累加而加大，从而导致执行机构达到极限位置，若控制器输出继续增大，执行器开度不可能再增大，此时计算机输出控制量超过了正常运行范围而进入饱和区。一旦系统出现反向偏差，u(k)逐渐从饱和区退出。进入饱和区越深则退出饱和区时间越长，在这段时间里，执行机构仍停留在极限位置而不随偏差反向而立即做出相应改变，系统就像失控一样，造成控制系统恶化。
 
        防止积分饱和的方法之一就是抗积分饱和法，该方法思路是在计算u(k)时，先判断上一时刻控制量u(k-1)是否超过了极限，如果是，则只累加反向偏差(或清零处理方法众多)，从而避免控制量长时间停留在饱和区。
 
PID基本代码实例
 
#ifndef __PID_H
#define __PID_H

typedef struct
{
	float SetValue;
	float ActualValue;
	
	float Kp;
	float Ki;
	float Kd;
	
	float last_err;
	float curr_err;
	
	float P;
	float I;
	float D;
	
	float I_MAX;  //防止积分饱和
	
}
PID_TypeDef;

float PID_CALC(PID_TypeDef* pid, float ActualValue);

#endif
 
#include "pid.h"

float PID_CALC(PID_TypeDef* pid, float ActualValue)
{
	pid->ActualValue=ActualValue;
	
	pid->curr_err=pid->SetValue-pid->ActualValue;
	
	pid->P =  pid->Kp * pid->curr_err;
	pid->I += pid->Ki * pid->curr_err;
	pid->D =  pid->Kd * (pid->curr_err - pid->last_err);
	
	pid->last_err = pid->curr_err;
	
	/*******************参数修正********************/
    //防积分饱和处理
	if(pid->I >= pid->I_MAX)
	{
		pid->I = pid->I_MAX;
	}
	if(pid->I <= -pid->I_MAX)
	{
		pid->I = -pid->I_MAX;
	}
	/***********************************************/
	return pid->P + pid->I + pid->D;
}
 
串级PID简介
 
以电机调试为例
 
其角度环为外环
 
角速度环为内环
 
角度环的PID输出作为角速度环的SetPoint
 
角度环的PID调整值越大角速度环的SetPoint越大
 
即角度差的越多 角速度期望值越大 运动越快 补偿越迅速
 
先调整速度环 电机稳 阻力大
 
后调整角度环 迅速到达指定位置
 
先内后外,一般而言,内环稳定后,外环只P调节即可满足要求
 
PID参数整定方法
 
网络上有系统成体系的方法,此处为个人经验
 
还是以电机调试为例子
 
先整定内环P直到系统刚开始震荡,此时P较大,响应快又不至于发散,电机角速度正负变化(此时外环给内环的期望为0)
再给D减缓之前的震荡
最后适当给I消除可能存在的静差
内环稳定后表现为,角速度保持为0,手强加一个角速度,速度越快阻力越大
最后给外环一个合适的P使得给定角度后电机可以快速稳定地响应到位
PID闲话
 
P   调控现在 是系统对当前误差的调整能力
 
I    纠正过去 是系统消除静差的手段
 
D  把握未来 是系统对未来的预测,抑制超调
 
人生有时不就如此吗? 远方再见咯.去稳定,快速且准确地响应自己的setpoint吧!
 
参考资料
 
参考资料
 
https://blog.csdn.net/xiaoshuai537/article/details/78034794
 
//各类PID算法
 
https://zhuanlan.zhihu.com/p/39573490

一、单个神经元
 
神经网络算法，是使用计算机模拟生物神经系统，来模拟人类思维方式的算法。它的基本单位就是人工神经元。通过相互连接形成一张神经网络。
 
 
生物神经网络中，每个神经元与其他神经元连接，当它“激活”时，会传递化学物质到相连的神经元，改变其他神经元的电位，当电位达到一定“阈值”，那么这个神经元也会被激活。
 
单个人工神经元的计算公式：
 
 
其中：
 
  为输入参数向量，表示其他神经元输入的信号。
 
  为每个输入参数的权重值，表示对应神经元信号的权重。
 
θ为阈值或者偏差值，是指该激活神经元的难易程度。
 
y为神经元的输出值，表示该神经元是否被激活。
 
Act()为激活函数，理想的激活函数是下图（a）中的跃阶函数，“1”为神经元兴奋，“0”为神经元抑制，但由于跃阶函数具有不是连续可导等不好的性质，因此一般采用下图（b）的Sigmoid函数作为激活函数。
 
 
 
 
二、全连接神经网络结构
 
我们来定义一个全连接神经网络：
 
 
全连接神经网络，就是指每一层的每个神经元都和下一层的每个神经元相连接。
 
Layer：0为输入层，
 
Layer：L为输出层
 
其他L-1个Layer为隐层
 
输入x
 
 
 
我们称一个输入值x为一个样本
 
输出 y
 
 
变量的上标（0）（L），表示该变量处于神经网络的哪一层。
 
 表示第L层编号为i的神经元。 表示第L层的神经元数量。
 
更好的理解神经网络，可观看此视频：https://www.bilibili.com/video/av15532370
 
 
 
三、反向传播算法（BP算法）
 
下面来说明如何调整一个神经网络的参数，也就是误差反向传播算法（BP算法）。以得到一个能够根据输入，预测正确输出的模型。
 
1、首先我们要了解优化的目标
 
根据人工神经元的定义，有以下三个公式：
 
 
其中，Act()是激活函数，之前已经说过。
 
 
根据公式(2)和公式(3)，可以得出各个神经元之间的通用计算公式，如下所示：
 
 
公式(4)是人工神经网络正向传播的核心公式。
 
 
 
那么，我们根据什么来调整神经网络的参数，以得到一个能够正确预测结果的模型呢？请看下面的公式：
 
 
公式(5)用来计算我们期望的输出和实际输出的“差别”，其中cost()叫做损失函数。我们的期望是损失值达到最小。
 
但是，只根据一次输出的损失值，对参数进行调整，无法使模型适应所有输入样本。我们需要的是，调整参数，使得所有输入样本，得到输出的总损失值最小，而不是只让其中一个样本的损失值最小，导致其他样本损失值增大。因此有如下公式：
 
 
公式(6)表示一个batch的所有样本输出的总损失值的平均值。其中，bn表示一个batch中样本的数量。
 
为什么不用所有的样本计算损失值，而将所有样本分成一个个的batch呢？因为所有的训练样本数量太大了，可能有数以百万计，将所有的样本损失值都一起进行运算，计算量过于庞大，大大降低了模型计算的速度。
 
公式(6)中计算总的损失值C，其实是一个以所有的连接权值ω和所有的阈值θ未为变量的多元函数。我们想要的模型就是求得C最小时，所有ω和θ的值。直接计算显然是不可能的，因为对于一个大的深度神经网络，所有的参数变量，可能数以万计。
 
在这里我们使用梯度下降算法来逐步逼近C的最小值，也就是先随机得到一组参数变量的值，然后计算参数变量当前的梯度，向梯度的反方向，也就是C变小最快的方向，逐步调整参数值，最终得到C的最小值，或者近似最小值。
 
而将所有样本，随机分成一个个固定长度的batch，以得到近似的梯度方向，叫做随机梯度下降算法。
 
更好理解梯度下降算法，逐步求得最优的参数值，可观看此视频：https://www.bilibili.com/video/av16144388
 
 
 
2、开始求梯度
 
那么，根据梯度的定义，接下来的任务，就是求取各个参数变量相对于C的偏导数。我们将使用误差反向传播算法来求取各个参数变量的偏导数。
 
这里先剧透一下，求取参数偏导数的方法，和神经网络正向传播（根据样本计算输出值）的方式类似，也是逐层求解，只是方向正好相反，从最后一层开始，逐层向前。
 
更好的理解误差反向传播算法，可观看此视频：https://www.bilibili.com/video/av16577449
 
首先，我们先求神经网络最后一层，也就是输出层的相关参数的偏导数。为了降低推导的复杂性，我们只计算相对于一个样本的损失值函数Cbi的偏导数，因为相对于总损失值函数C的偏导数值，也不过是把某个参数的所有相对于Cbi偏导数值加起来而已。
 
根据公式(2)、公式(3)、公式(5)，以及“复合函数求导法则”，可以得到输出层（L层）某个神经元的权值参数ω的偏导数，计算公式如下：
 
 
根据公式(5)可以得到：
 
 
根据公式(2)可以得到：
 
 
根据公式(3)可以得到：
 
 
将公式(8)(9)(10)，带入公式(7)，可以得到：
 
 
 
 
我们令：
 
 
根据公式(8)(9)则有：
 
 
将公式(13)，带入公式(11)，可以得到：
 
 
这样我们就得到了输出层L相关的权值参数ω的偏导数计算公式！
 
接下来，同理可得输出层L相关的阈值θ的偏导数计算公式为：
 
 
而根据公式(3)可以得到：
 
 
将公式(16)带入公式(15)可以得到：
 
 
这就是输出层L相关的阈值θ的偏导数计算公式！
 
 
 
3、根据L层，求前一层参数的偏导函数
 
由公式(3)可知，一个权值参数ω只影响一个L-1层的神经元，因此有：
 
 
根据公式(3)可以得到：
 
 
将公式(19)带入公式(18)可以得到：
 
 
根据公式(12)可以得到：
 
 
将公式(21)带入公式(20)可以得到：
 
 
同理，我们可以得到：
 
 
根据公式(3)可以得到：
 
 
将公式(24)带入公式(23)可以得到：
 
 
这样我们就得到了L-1层神经元相关参数的计算公式！
 
 
 
下面，我们还需要推导一下 之间的关系，根据公式(2)可以得到：
 
 
同样根据公式(2)可以得到：
 
 
将公式(27)带入公式(26)可以得到：
 
 
由公式(3)可知，一个权值参数ω只影响一个L-1层的神经元，但这个L-1层神经元影响了所有L层的神经元。因此，根据“多元复合函数求导法则”有：
 
 
根据公式(12)可以得到：
 
 
将公式(27)带入公式(26)可以得到：
 
 
根据公式(3)可以得到：
 
 
将公式(32)带入到公式(31)可以得到：
 
 
将公式(33)带入公式(28)可以得到：
 
 
这样我们就得到了反向传播，逐层推导的通用公式：
 
 
 
 
 
在这里，ω和z都是正向传播过程中，已经算好的常数，而   可以从L层开始逐层向前推导，直到第1层，第0层是输入层，不需要调整参数。而第L层的   可参考公式(13)。
 
 
 
下面是全连接神经网络的python实现代码：
 
#coding=utf-8
import numpy as np
import matplotlib.pylab as plt
import random

class NeuralNetwork(object):
    def __init__(self, sizes, act, act_derivative, cost_derivative):
        #sizes表示神经网络各层的神经元个数，第一层为输入层，最后一层为输出层
        #act为神经元的激活函数
        #act_derivative为激活函数的导数
        #cost_derivative为损失函数的导数
        self.num_layers = len(sizes)
        self.sizes = sizes
        self.biases = [np.random.randn(nueron_num, 1) for nueron_num in sizes[1:]]
        self.weights = [np.random.randn(next_layer_nueron_num, nueron_num)
            for nueron_num, next_layer_nueron_num in zip(sizes[:-1], sizes[1:])]
        self.act=act
        self.act_derivative=act_derivative
        self.cost_derivative=cost_derivative

    #前向反馈（正向传播）
    def feedforward(self, a):
        #逐层计算神经元的激活值，公式(4)
        for b, w in zip(self.biases, self.weights):
            a = self.act(np.dot(w, a)+b)
        return a

    #随机梯度下降算法
    def SGD(self, training_data, epochs, batch_size, learning_rate):
        #将训练样本training_data随机分为若干个长度为batch_size的batch
        #使用各个batch的数据不断调整参数，学习率为learning_rate
        #迭代epochs次
        n = len(training_data)
        for j in range(epochs):
            random.shuffle(training_data)
            batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
            for batch in batches:
                self.update_batch(batch, learning_rate)
            print("Epoch {0} complete".format(j))

    def update_batch(self, batch, learning_rate):
        #根据一个batch中的训练样本，调整各个参数值
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        for x, y in batch:
            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
            nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
            nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
        #计算梯度，并调整各个参数值
        self.weights = [w-(learning_rate/len(batch))*nw for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b-(learning_rate/len(batch))*nb for b, nb in zip(self.biases, nabla_b)]

    #反向传播
    def backprop(self, x, y):
        #保存b和w的偏导数值
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        #正向传播
        activation = x
        #保存每一层神经元的激活值
        activations = [x]
        #保存每一层神经元的z值
        zs = []
        for b, w in zip(self.biases, self.weights):
            z = np.dot(w, activation)+b
            zs.append(z)
            activation = self.act(z)
            activations.append(activation)
        #反向传播得到各个参数的偏导数值
        #公式(13)
        d = self.cost_derivative(activations[-1], y) * self.act_derivative(zs[-1])
        #公式(17)
        nabla_b[-1] = d
        #公式(14)
        nabla_w[-1] = np.dot(d, activations[-2].transpose())
        #反向逐层计算
        for l in range(2, self.num_layers):
            z = zs[-l]
            sp = self.act_derivative(z)
            #公式(36)，反向逐层求参数偏导
            d = np.dot(self.weights[-l+1].transpose(), d) * sp
            #公式(38)
            nabla_b[-l] = d
            #公式(37)
            nabla_w[-l] = np.dot(d, activations[-l-1].transpose())
        return (nabla_b, nabla_w)

#距离函数的偏导数
def distance_derivative(output_activations, y):
    #损失函数的偏导数
    return 2*(output_activations-y)

# sigmoid函数
def sigmoid(z):
    return 1.0/(1.0+np.exp(-z))

# sigmoid函数的导数
def sigmoid_derivative(z):
    return sigmoid(z)*(1-sigmoid(z))

if __name__ == "__main__":
    #创建一个5层的全连接神经网络，每层的神经元个数为1，8，5，3，1
    #其中第一层为输入层，最后一层为输出层
    network=NeuralNetwork([1,8,5,3,1],sigmoid,sigmoid_derivative,distance_derivative)

    #训练集样本
    x = np.array([np.linspace(-7, 7, 200)]).T
    #训练集结果，由于使用了sigmoid作为激活函数，需保证其结果落在(0,1)区间内
    y = (np.cos(x)+1)/2

    #使用随机梯度下降算法（SGD）对模型进行训练
    #迭代5000次；每次随机抽取40个样本作为一个batch；学习率设为0.1
    training_data=[(np.array([x_value]),np.array([y_value])) for x_value,y_value in zip(x,y)]
    network.SGD(training_data,5000,40,0.1)

    #测试集样本
    x_test = np.array([np.linspace(-9, 9, 120)])
    #测试集结果
    y_predict = network.feedforward(x_test)

    #图示对比训练集和测试集数据
    plt.plot(x,y,'r',x_test.T,y_predict.T,'*')
    plt.show()
 
 

BP神经网络应该是所有神经网络里面的比较简单易懂的一种。
 
当然，python是有BP神经网络的库，但是我这次要给的代码，是我自己根据网上大佬的案例，自己手动编写的一个隐含层的一个神经网络模型。
 
代码的流程如下：
 1.读取train训练集数据，读取test测试集数据。
 2.对数据进行归一化处理。
 3.初始化其中的w（权值），b（偏置）。
 4.随机选取一个训练集数据，进行正向传播，h = wi*xi + …. + b1
 5.得到答案与正确期望值进行对比。得到误差值。
 6.通过误差值进行反向传播。修正各个权值数值以及偏置的数值。
 7.进行一轮测试集的测试，测试该模型的识别率。
 8.如果识别率低于80%，则重复步骤4
 9.输出当前的准确率
 
有关于优化，或者改良：
 关于学习率：我在隐含层到输出层的学习率统一设置的是0.5，而在输入层到隐含层的学习率统一设置的是0.2.因为这两者对于最终结果的影响并不一样大，所以权值设置的不一样。
 关于识别率：我在识别率上做出了一定的妥协，本来出现的三个数据要超过0.90的数据出现我才判断正确。但是在之后的调试中，我将其改成了0.75。但是这并没有使得正确率变得更高。所以我认为这应该是隐含层的层数不足导致的。
 我的隐含层只有一层，且只有4个节点。我认为这是影响识别率的一个关键问题。
 
训练集和测试集数据链接：
 链接：https://pan.baidu.com/s/1O1Zvn4eNii3DJDSn03v43w
 提取码：25eh
 
import random
import math
#该实验设置4个隐含层节点，3个输出层节点
#每个隐含层节点都有4个输出，3个输出
#权值都放在W中，其中
#共计有w0-w15作为输入层权值，w16-27是作为输出层权值
#阈值的初始值设置为1
#每一个隐含层节点都储存在独立的数组h中
#每层都有一个偏置数组
x = []#训练数据储存
w = []#hi权值的存放（28）
h = []#隐含层数组
out = []#输出层数组
b1 = []#偏置
b2 = []#偏置
y = []#测试集数据储存

def putin(w,a,j,b1):#计算输出层到隐含层的函数,w为权值数组，a为训练数组中元素，j为第几个中间隐含层
	sum = 0
	yin = b1[j]
	j = j * 4
	for n in range(0,4):
		sum = sum + a[n]*w[j]
		j = j + 1
	sum = sum + yin
	return sum

def putout(h,w,j,b2):#计算隐含层到输出层的函数
	sum = 0
	yin = b2[j]
	j = j + 16 + j * 3
	for n in range(0,3):
		sum = sum + h[n]*w[j]
		j = j + 1
	sum = sum + yin
	return sum

def back2w(O,out,h,i,j):#i为第几个输出层元素，j为隐含层的输入
	val = 0.0
	val = - 2/3 * (O[i] - out[i])
	val =  val * (out[i] * (1- out[i]) * h[j])
	return val

def back2b(O,out,h,i,j):#i为第几个输出层元素，j为隐含层的输入
	val = 0.0
	val = - 2/3 * (O[i] - out[i])
	val =  val * out[i] * (1- out[i])
	return val

def back1w(O,out,w,j):#i为第几个输出层元素，w[j]为权值
	sum = 0
	for i in range(3):
		val = 0.0
		val = - 2/3 * (O[i] - out[i])
		val =  val * (out[i] * (1- out[i]) * w[16 + j])
		sum = sum + val
		j = j + 4
	return sum

def sigmoid(h):#翻新隐含层数组
	for i in range(0,len(h)):
		AS = round(-h[i],6)
		y = 1/(math.exp(AS)+1)
		y = round(y,4)
		h[i] = y

def acc(O,out):
	max = out[0]
	max_v = 0
	for i in range(3):
		if out[i] > max:
			max = out[i]
			max_v = i
	if max >= 0.75:
		for i in range(3):
			if O[i] == 0.95:
				if max_v == i:
					return 1
	return 0

reload = 200 #最大学习次数为50次
f = open('iris-data-training.txt')
char = f.readline()
while char:#输入训练模型的数据
	char1 = char.split( )
	x1 = float(char1[0])
	x2 = float(char1[1])
	x3 = float(char1[2])
	x4 = float(char1[3])
	x5 = int(char1[4])
	char2 = [x1,x2,x3,x4,x5]
	x.append(char2)
	char = f.readline()
f.close()
x_max = []
x_min = []
for j in range(0,4):#x变量归一化
	max = 0
	min = 0
	for i in range(0,len(x)):
		if x[i][j] > max:
			max = x[i][j]
		if x[i][j] < min:
			min = x[i][j]
	x_max.append(max)
	x_min.append(min)
	for i in range(0,len(x)):
		x[i][j] = round(((x[i][j] - min)/(max-min)),4)
for i in range(0,len(x)):
	if x[i][4] == 1:
		x[i].append(0)
		x[i].append(0)
	if x[i][4] == 2:
		x[i][4] = 0
		x[i].append(1)
		x[i].append(0)
	if x[i][4] == 3:
		x[i][4] = 0
		x[i].append(0)
		x[i].append(1)

f = open('iris-data-testing.txt')
char = f.readline()
while char:#输入训练模型的数据
	char1 = char.split( )
	x1 = float(char1[0])
	x2 = float(char1[1])
	x3 = float(char1[2])
	x4 = float(char1[3])
	x5 = int(char1[4])
	char2 = [x1,x2,x3,x4,x5]
	y.append(char2)
	char = f.readline()
f.close()
for i in range(0,len(y)):
	for j in range(0,4):
		y[i][j] = round(((y[i][j] - x_min[j])/( x_max[j]- x_min[j])),4)
for i in range(0,len(y)):
	if y[i][4] == 1:
		y[i].append(0)
		y[i].append(0)
	if y[i][4] == 2:
		y[i][4] = 0
		y[i].append(1)
		y[i].append(0)
	if y[i][4] == 3:
		y[i][4] = 0
		y[i].append(0)
		y[i].append(1)

for j in range(0,28):#w初始化
	rand = random.uniform(-1,1)
	rand = round(rand,2)
	w.append(rand)
for i in range(0,4):#偏置初始化
	rand = random.uniform(-0.5,0.5)
	rand = round(rand,2)
	b1.append(rand)
for i in range(0,3):#偏置初始化
	rand = random.uniform(-0.5,0.5)
	rand = round(rand,2)
	b2.append(rand)
while(1):
	a = []
	O = []
	a_a = int(random.uniform(0,len(x)))
	for i in range(0,7):
		a.append(x[a_a][i])
		if x[a_a][i] == 1:
			if i == 4:
				O = [0.95,0.025,0.025]
			if i == 5:
				O = [0.025,0.95,0.025]
			if i == 6:
				O = [0.025,0.025,0.95]
	for i in range(100):
		#随机选取一个x内的元素作为训练集
		h = []
		out = []


		for i in range(0,4):
			h.append(putin(w,a,i,b1))
		sigmoid(h)
		for i in range(0,3):
			out.append(putout(h,w,i,b2))
		sigmoid(out)
		e = []
		e_total = 0
		for i in range(0,3):#得到偏差
			K = 1/3*((O[i] - out[i])**2)
			e.append(K)
			e_total = e_total + K


		for i in range(3):#修正隐含层到输出层的权值
			for j in range(4):
				w[16+(4*i)+j] = w[16+(4*i)+j] - 0.5 * back2w(O,out,h,i,j)

		for j in range(3):#修正隐含层到输出层的偏置值
			b2[j] = b2[j] - 0.5 * back2b(O,out,h,i,j)

		for i in range(4):
			for j in range(4):
				w[(4*i)+j] = w[(4*i)+j] - 0.2 *(back1w(O, out, w, j) * h[i] * a[i])
		for j in range(4):
			b1[j] = b1[j] - 0.2 *(back1w(O, out, w, j) * h[i])


	sum = 0#测试精确度
	for j in range(len(y)):
		b = []
		O = []
		bb = j
		for i in range(0, 7):
			b.append(y[bb][i])
			if y[bb][i] == 1:
				if i == 4:
					O = [0.95, 0.025, 0.025]
				if i == 5:
					O = [0.025, 0.95, 0.025]
				if i == 6:
					O = [0.025, 0.025, 0.95]
		h = []
		out = []
		for i in range(0,4):
			h.append(putin(w,b,i,b1))
		sigmoid(h)
		for i in range(0,3):
			out.append(putout(h,w,i,b2))
		sigmoid(out)
		sum = sum + acc(O,out)
	print(sum)
	if sum/len(y) >= 0.80:
		break

1、adam优化器公式
 
包括动量项和过去梯度平方的指数衰减平均
 
 
2、偏差校正后的, 
 
 
3、Adam的参数更新公式
 
 
重点来了
 
第二部偏差矫正的公式是怎么等到的？？？
 
论文中的推导
 
 
 
但是不知道是怎么变化来的，下面是我的理解
 
第一次迭代
 
 
初始化为0，则
 
 
对上式左右求期望
 
这里对vt展开了，直接套用期望的性质，那个没有搞懂。。。
 
 
这样就推出来那个公式了