精华内容
下载资源
问答
  • 基于反向传播神经网络的闽台ML震级偏差分析与修正.pdf
  • PID简介

    千次阅读 多人点赞 2019-10-30 12:42:29
    大三退隐,安心学习之前总结一下所学的PID知识,备忘 ... 存在偏差时,P成比例的弥补偏差,实际值非不受外界干扰而随时间变化时,P可使得实际值不断逼近设定值,当实际值随外界影响 变化时,此消彼长会使...

    大三退隐,安心学习之前总结一下所学的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)位置式

    https://img-blog.csdn.net/20170919214419621?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGlhb3NodWFpNTM3/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center

    (2)增量式

    https://img-blog.csdn.net/20170919214247695?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGlhb3NodWFpNTM3/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center

    (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”为神经元抑制,但由于跃...

    一、单个神经元

    神经网络算法,是使用计算机模拟生物神经系统,来模拟人类思维方式的算法。它的基本单位就是人工神经元。通过相互连接形成一张神经网络。

    生物神经网络中,每个神经元与其他神经元连接,当它“激活”时,会传递化学物质到相连的神经元,改变其他神经元的电位,当电位达到一定“阈值”,那么这个神经元也会被激活。

    单个人工神经元的计算公式:

    其中:

     为输入参数向量,表示其他神经元输入的信号。

     为每个输入参数的权重值,表示对应神经元信号的权重。

    θ为阈值或者偏差值,是指该激活神经元的难易程度。

    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神经网络

    千次阅读 2019-05-29 14:35:20
    6.通过误差值进行反向传播。修正各个权值数值以及偏置的数值。 7.进行一轮测试集的测试,测试该模型的识别率。 8.如果识别率低于80%,则重复步骤4 9.输出当前的准确率 有关于优化,或者改良: 关于学习率:我...

    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
    
    展开全文
  • Adam优化器偏差矫正的理解

    千次阅读 2020-06-23 20:22:18
    2、偏差校正后的, 3、Adam的参数更新公式 重点来了 第二部偏差矫正的公式是怎么等到的??? 论文中的推导 但是不知道是怎么变化来的,下面是我的理解 第一次迭代 初始化为0,则 对上式左右求...

    1、adam优化器公式

    包括动量项和过去梯度平方的指数衰减平均

    2、偏差校正后的\hat{w_t}\hat{v_t}

    3、Adam的参数更新公式

    重点来了

    第二部偏差矫正的公式是怎么等到的???

    论文中的推导

    但是不知道v_t是怎么变化来的,下面是我的理解

    第一次迭代

    v_1=\beta_2v_0+(1-\beta_2)\cdot g_1^2

    v_0初始化为0,则v_1=(1-\beta_2)\cdot g_1^2

    对上式左右求期望

    这里对vt展开了,直接套用期望的性质,那个没有搞懂。。。

    这样就推出来那个公式了

    展开全文
  • 本篇文章,本来计划再进一步完善对CNN卷积神经网络的理解,但在对卷积层反向传播算法的理解中,越发觉得之前对于BP反向传播算法的理解是不到位的。小白近日觉得,对于深度神经网络,"反向传播"的思想是灵魂。因此,...
  • 基于LSTM的股票预测模型_python实现_超详细

    万次阅读 多人点赞 2019-07-05 22:25:13
    RNN模型的结构如图: 2、LSTM模型 长短期记忆模型(long-short term memory)是一种特殊的RNN模型,是为了解决反向传播过程中存在梯度消失和梯度爆炸现象,通过引入门(gate)机制,解决了RNN模型不具备的长记忆性...
  • 基于S函数的BP神经网络PID控制器及simulink仿真

    万次阅读 多人点赞 2019-12-05 13:51:58
    最后,根据反向传播算法进行权值的调整 %隐含层至输出层的权值调整 dyu=sign((u(3)-u(2))/(u(7)-u(6)+0.0001)); for j=1:1:3 dK(j)=2/(exp(K1(j))+exp(-K1(j)))^2; %输出层的输出的一阶导 end for i=1:1:3 ...
  • 本文通篇讨论的方法是信用分配过程,首先关注更新权重和偏差群智能,然后使用网络评估粒子的适应度。 通过适当调整 SI-BPN 过程,所提出的方法可以在架构空间内针对特定问题开发最佳网络。 此外,它还提供了所有...
  • 电流调节器的输出 ud 和 uq 作为弱磁调节器的输入量,并于逆变器所能输出的最大电压 Umax比较,二者的偏差作为弱磁环节的PI调节器的输入,PI调节器输出超前角来调节 iq 和 id 的给定。 由于采用的时SVPWM调制, ,...
  • 深度学习-反向传播

    2021-02-03 17:40:15
    反向传播算法:计算输出层结果与真实值之间的偏差来进行逐层调节参数(逐层条件参数一般用到梯度下降算法) 首先我们得明白神经网络的参数训练是一个不断迭代的过程 当网络结构已知时,参数训练的过程如下: 通过...
  • 反向传播的数学推导

    千次阅读 2018-02-07 16:57:12
    前一篇手写识别的博文《深度学习数学基础—反向传播》中已经简单分析和推导过反向传播的原理,但是基于特定的场景给出的推导过程,现在我们再来系统的加深下神经网络反向传播的算法理解。 首先定义几个变量。...
  • 是谁在耳边,说“信号正向传播,误差反向传播” ? 梦回遥远大三的计算智能课,三年前我可想不到居然有朝一日会重新"预习"它...... 每一堂课、一本书,当时只道是寻常,如今不经意想起,忽怀念这些瞬间。所谓成长...
  • TensorFlow实现反向传播

    千次阅读 2018-02-05 11:47:28
    使用TensorFlow的一个优势是,它可以维护操作状态和基于反向传播自动地更新模型变量。 TensorFlow通过计算图来更新变量和最小化损失函数来反向传播误差的。这步将通过声明优化函数(optimization function)来实现...
  • 反向传播算法详解

    千次阅读 2020-03-14 19:02:44
    什么是反向传播? 反向传播是如何工作的? 损失函数 为什么我们需要反向传播? 前馈网络 反向传播的类型 案例研究 在典型的编程中,我们输入数据,执行处理逻辑并接收输出。 如果输出数据可以某种方式影响处理逻辑...
  • 正向传播、反向传播和计算图

    千次阅读 2019-06-14 23:29:46
    正向传播、反向传播和计算图 前面几节里我们使用了小批量随机梯度下降的优化算法来训练模型。在实现中,我们只提供了模型的正向传播(forward propagation)的计算,即对输入计算模型输出,然后通过autograd模块来...
  • 反向传播算法的理解

    千次阅读 2018-04-13 18:40:55
    BP(Backpropagation Algorithm,反向传播算法)在神经...文中如有理解偏差,请各位指正。 就反向传播的字面理解是将数据从后(输出)向前(输入)传递,数据的具体形式是代价函数对其超参数(权重(W)和偏置(b))的偏导数,...
  •  getwb - 将它作为一个单一向量中的所有网络权值和偏差。 noloop - 删除神经网络的开放和关闭反馈回路。 开环 - 转换神经网络反馈,打开封闭的反馈循环。 removedelay - 删除延迟神经网络的反应。 separatewb -...
  • BP神经网络原理以及demo示例

    千次阅读 2017-04-02 14:23:09
    θi为神经元的阀值,vi为经偏差调整过的值,称为神经元的局部感应区。f(.)是激励函数,yi是神经元i的输出 我个人认为,BP神经网络的算法核心是让全局网络误差达到最小,当误差为0的时候也就是模型最准确的时候,...
  • Deep_Learning之反向传播

    2019-10-18 22:30:38
    在上一章中,我们看到了神经网络如何使用梯度下降算法来学习它们的权值和偏差。然而,在我们的解释中有一个缺口:我们没有讨论如何计算成本函数的梯度。在这一章中,我将解释一种计算这种梯度的快速算法,一种称为...
  • 【一些基础概念】 误差反向传播(Error Back Propagation, BP)算法 1、BP算法的基本思想是:学习过程由信号的正向...第二步:加权后的输入求和,加上一个偏差b(绿色) 第三步:这个结果传递给一个激活函数f(x.
  • 本文提供粒子群算法简介和一个算法举例,提供粒子群算法仿真PID的M文件代码及simulink仿真。另外,本文还提供了一种动态simulink仿真方法,可以让M文件和simulink文件之间互相交换数据,实现仿真与程序的反馈,增加...
  • 吴恩达机器学习与深度学习作业目录 [图片已修复]

    万次阅读 多人点赞 2018-10-23 10:03:59
    吴恩达机器学习作业目录 1 吴恩达机器学习作业Python实现(一):线性回归 2 吴恩达机器学习作业Python实现(二):logistic回归 ...5 吴恩达机器学习作业Python实现(五):偏差和方差 6 吴恩达机器学习作业Py...
  • 6、反向传播

    2018-07-17 12:47:23
    6、反向传播 内容列表: 6.1简介 6.2简单表达式和理解梯度 6.3复合表达式,链式法则,反向传播 6.4直观理解反向传播 6.5模块:Sigmoid例子 6.6反向传播实践:分段计算 6.7回传流中的模式 6.8用户向量化操作...
  • 什么是反向竞价?有哪些优劣势

    千次阅读 2020-11-26 11:37:25
    反向竞价是由采购方和供应商通过互联网络共同完成的一种采购方式。在反向竞价中,采购员发出服务请求,然后由供应商之间以竞争方式决定最优惠的价格和提供最好的交易。 由于反向竞价的性质,反向竞价只能使用电子...
  •   写这个文章主要是因为学习了吴恩达老师的机器学习视频,在神经网络的反向传播算法(Back Propagation)的公式推导有些模糊,所以自己也查阅了很多资料,才基本搞明白其中的原理。所以希望通过写一下文章来进行...
  • 代价函数(神经网络在分类问题中的应用) 分类问题为多元分类和二元分类 反向传播算法 delta是没有1层的,因为第一层是我们的观测值,没有误差 经过后面的推导,忽略了λ(正则项),就会得到左下角代价函数的偏导项...
  • 【CS231n】斯坦福大学李飞飞视觉识别课程笔记 由官方授权的CS231n课程笔记翻译知乎专栏——智能单元,比较详细地翻译了课程笔记,我这里...【CS231n】斯坦福大学李飞飞视觉识别课程笔记(十一):反向传播笔记 ...
  • 前向传播和反向传播 从一个简单的数学表达式开始 1+2=31+2=31+2=3 把常量换成变量,如下 x+y=zx+y=zx+y=z 这是数学表达式的方式 我们再换种计算图的方式,如下 前向传播 反向传播 这是加法,左边是前向传播,右边是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,905
精华内容 7,162
关键字:

反向偏差