BP神经网络

BP神经网络模型拓扑结构包括输入层（input）、隐层(hide layer)和输出层(output layer)。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP网络模型处理信息的基本原理是：输入信号Xi通过中间节点（隐层点）作用于输出节点，经过非线形变换，产生输出信号Yk，网络训练的每个样本包括输入向量X和期望输出量t，网络输出值Y与期望输出值t之间的偏差，通过调整输入节点与隐层节点的联接强度取值W_ij和隐层节点与输出节点之间的联接强度T_jk以及阈值，使误差沿梯度方向下降，经过反复学习训练，确定与最小误差相对应的网络参数（权值和阈值），训练即告停止。此时经过训练的神经网络即能对类似样本的输入信息，自行处理输出误差最小的经过非线形转换的信息。

算法步骤

第一步：创建网络

第二步：随机初始化

第三步：重复下述过程直到收敛：

                （1）对N个样本，从k=1到N

                正向过程计算：计算中间层各神经单元的激活值、输出值，输出层各单元的的激活值、输出值

                反向过程：依次从输出层到中间层，中间层到输入层计算校正误差

                （2）修正权值

样本预处理

样本输入应当归一化处理,数据归一化，就是将数据映射到[0,1]或[-1,1]区间或更小的区间,尽量使输入向量不相关,以确保各权值的收敛速度大致相同。

为什么要归一化处理？ 


<1>输入数据的单位不一样，有些数据的范围可能特别大，导致的结果是神经网络收敛慢、训练时间长。


<2>数据范围大的输入在模式分类中的作用可能会偏大，而数据范围小的输入作用就可能会偏小。


<3>由于神经网络输出层的激活函数的值域是有限制的，因此需要将网络训练的目标数据映射到激活函数的值域。例如神经网络的输出层若采用S形激活函数，由于S形函数的值域限制在(0,1)，也就是说神经网络的输出只能限制在(0,1)，所以训练数据的输出就要归一化到[0,1]区间。


<4>S形激活函数在(0,1)区间以外区域很平缓，区分度太小。例如S形函数f(X)在参数a=1时，f(100)与f(5)只相差0.0067。


归一化算法 


　　一种简单而快速的归一化算法是线性转换算法。线性转换算法常见有两种形式：


       <1>


y = ( x - min )/( max - min )


　　其中min为x的最小值，max为x的最大值，输入向量为x，归一化后的输出向量为y 。上式将数据归一化到 [ 0 , 1 ]区间，当激活函数采用S形函数时（值域为(0,1)）时这条式子适用。


       <2>


y = 2 * ( x - min ) / ( max - min ) - 1


       这条公式将数据归一化到 [ -1 , 1 ] 区间。当激活函数采用双极S形函数（值域为(-1,1)）时这条式子适用。

关于随机初始化

既保证各神经元得输入值较小,工作在激励函数斜率变化最大的区域,也防止某些权值的绝对值多次学习后不合理的无限增长。一般取初始值为(-1,1)之间的随机数。
不同初值可能会对性能造成影响，而事先又难以预测较好地初值，所以干脆使用随机值。不能将所有的参数用相同的值作为初始值，那样的话所有的隐藏单元会得到与输入值有关的、相同的函数，随机初始化的目的是使对称失效。

学习率的选取

权值在每次循环学习中的变化受到学习率的影响较大。学习率小,学习时间长,收敛速度慢,不过能保证网络的误差值可以达到最终的极小点。系统的稳定性在学习率较大时可能会较差。通常我们倾向于选取较小的学习速率,其选取范围一般为 0.001 到 0.10之间以保证系统的稳定性。

采用变步长法根据输出误差大小自动调整学习因子，来减少迭代次数和加快收敛速度。

h =h +a×(E _p(n)- E _p(n-1))/ E _p(n)

a为调整步长，0~1之间取值 

隐层节点数的优化

隐节点数的多少对网络性能的影响较大，当隐节点数太多时，会导致网络学习时间过长，甚至不能收敛；而当隐节点数过小时，网络的容错能力差。利用逐步回归分析法并进行参数的显著性检验来动态删除一些线形相关的隐节点，节点删除标准：当由该节点出发指向下一层节点的所有权值和阈值均落于死区（通常取±0.1、±0.05等区间）之中，则该节点可删除。最佳隐节点数L可参考下面公式计算：

L=(m+n)^1/2+c

m-输入节点数；n-输出节点数；c-介于1～10的常数。

算法推导

参数的求取

（1）正向传播时

中间层各神经元的激活值Sj

Wij是输入层到中间层的连接权，θj是中间层的阈值，θj在学习过程中也会不断被修正，p是中间层单元数。

中间层各神经元的输出值（采用S型函数）

输出层t个神经元的激活值Ot

Wjt是中间层到输出层的权值，θt是输出层各单元的阈值

输出层各神经元的输出值（采用S型函数）

（2）反向传播时

直接引用ufldl tutorial里的反向传导，讲得很清楚。

假设我们有一个固定样本集 ，它包含  个样例。我们可以用批量梯度下降法来求解神经网络。具体来讲，对于单个样例 ，其代价函数为：

这是一个（二分之一的）方差代价函数。给定一个包含  个样例的数据集，我们可以定义整体代价函数为：

以上公式中的第一项  是一个均方差项。第二项是一个规则化项（也叫权重衰减项），其目的是减小权重的幅度，防止过度拟合。

[注：通常权重衰减的计算并不使用偏置项 ，比如我们在  的定义中就没有使用。一般来说，将偏置项包含在权重衰减项中只会对最终的神经网络产生很小的影响。如果你在斯坦福选修过CS229（机器学习）课程，或者在YouTube上看过课程视频，你会发现这个权重衰减实际上是课上提到的贝叶斯规则化方法的变种。在贝叶斯规则化方法中，我们将高斯先验概率引入到参数中计算MAP（极大后验）估计（而不是极大似然估计）。]

权重衰减参数  用于控制公式中两项的相对重要性。在此重申一下这两个复杂函数的含义： 是针对单个样例计算得到的方差代价函数； 是整体样本代价函数，它包含权重衰减项。

以上的代价函数经常被用于分类和回归问题。在分类问题中，我们用  或 ，来代表两种类型的标签（回想一下，这是因为 sigmoid激活函数的值域为 ；如果我们使用双曲正切型激活函数，那么应该选用  和 作为标签）。对于回归问题，我们首先要变换输出值域（译者注：也就是 ），以保证其范围为  （同样地，如果我们使用双曲正切型激活函数，要使输出值域为 ）。

我们的目标是针对参数  和  来求其函数  的最小值。为了求解神经网络，我们需要将每一个参数  和  初始化为一个很小的、接近零的随机值（比如说，使用正态分布  生成的随机值，其中  设置为  ），之后对目标函数使用诸如批量梯度下降法的最优化算法。因为  是一个非凸函数，梯度下降法很可能会收敛到局部最优解；但是在实际应用中，梯度下降法通常能得到令人满意的结果。最后，需要再次强调的是，要将参数进行随机初始化，而不是全部置为 。如果所有参数都用相同的值作为初始值，那么所有隐藏层单元最终会得到与输入值有关的、相同的函数（也就是说，对于所有 ，都会取相同的值，那么对于任何输入  都会有： ）。随机初始化的目的是使对称失效。

梯度下降法中每一次迭代都按照如下公式对参数  和 进行更新：

其中  是学习速率。其中关键步骤是计算偏导数。我们现在来讲一下反向传播算法，它是计算偏导数的一种有效方法。

我们首先来讲一下如何使用反向传播算法来计算  和 ，这两项是单个样例  的代价函数  的偏导数。一旦我们求出该偏导数，就可以推导出整体代价函数  的偏导数：

以上两行公式稍有不同，第一行比第二行多出一项，是因为权重衰减是作用于  而不是 。

反向传播算法的思路如下：给定一个样例 ，我们首先进行“前向传导”运算，计算出网络中所有的激活值，包括  的输出值。之后，针对第  层的每一个节点 ，我们计算出其“残差” ，该残差表明了该节点对最终输出值的残差产生了多少影响。对于最终的输出节点，我们可以直接算出网络产生的激活值与实际值之间的差距，我们将这个差距定义为  （第  层表示输出层）。对于隐藏单元我们如何处理呢？我们将基于节点（译者注：第  层节点）残差的加权平均值计算 ，这些节点以  作为输入。下面将给出反向传导算法的细节：

1. 进行前馈传导计算，利用前向传导公式，得到  直到输出层  的激活值。
2. 对于第  层（输出层）的每个输出单元 ，我们根据以下公式计算残差：

   

   [译者注：

   

   ]
3. 对  的各个层，第  层的第  个节点的残差计算方法如下：

   

   {译者注：
   将上式中的与的关系替换为与的关系，就可以得到：

   

   以上逐次从后向前求导的过程即为“反向传导”的本意所在。 ]
4. 计算我们需要的偏导数，计算方法如下：

   

最后，我们用矩阵-向量表示法重写以上算法。我们使用“” 表示向量乘积运算符（在Matlab或Octave里用“.*”表示，也称作阿达马乘积）。若 ，则 。在上一个教程中我们扩展了  的定义，使其包含向量运算，这里我们也对偏导数  也做了同样的处理（于是又有  ）。

那么，反向传播算法可表示为以下几个步骤：

1. 进行前馈传导计算，利用前向传导公式，得到 直到输出层  的激活值。
2. 对输出层（第  层），计算：

   

3. 对于  的各层，计算：

   

4. 计算最终需要的偏导数值：

   

实现中应注意：在以上的第2步和第3步中，我们需要为每一个  值计算其 。假设  是sigmoid函数，并且我们已经在前向传导运算中得到了 。那么，使用我们早先推导出的 表达式，就可以计算得到 。

最后，我们将对梯度下降算法做个全面总结。在下面的伪代码中， 是一个与矩阵  维度相同的矩阵， 是一个与  维度相同的向量。注意这里“”是一个矩阵，而不是“ 与  相乘”。下面，我们实现批量梯度下降法中的一次迭代：

1. 对于所有 ，令  ,  （设置为全零矩阵或全零向量）
2. 对于  到 ，
   1. 使用反向传播算法计算  和 。
   2. 计算 。
   3. 计算 。
3. 更新权重参数：

   

现在，我们可以重复梯度下降法的迭代步骤来减小代价函数  的值，进而求解我们的神经网络。

算法优化

利用GA遗传算法搜索参数

由于BP算法采用的是剃度下降法，因而易陷于局部最小并且训练时间较长。用基于生物免疫机制地既能全局搜索又能避免未成熟收敛的免疫遗传算法GA取代传统BP算法来克服此缺点。

动量BP算法

标准BP算法在调整权值时，只是按t时刻误差的梯度方向调整，而没有考虑t时刻以前的梯度方向，从而使训练过程发生振荡，收敛缓慢，为了提高网络训练速度，可在调整公式中增加一动量项。该方法是在反向传播法的基础上在每一个权值的变化上加上一项正比于前次权值变化量的值，并根据反向传播法来产生新的权值变化。它的实质就是改变学习率η来提高网络性能，其网络连接权的迭代关系式由传统BP算法

变为

其中α为动量因子，0<α<1。动量项的作用在于记忆上一时刻的连接权的变化方向（即变化量的值），这样就可以用较大的学习速率系数η以提高学习速度。附加动量项利用其“惯性效应”来抑制网络训练中可能出现的振荡，起到了缓冲平滑的作用。

学习率可变

该方法被认为是一种最简单最有效的方法。在BP算法中，连接权的调整决定于学习速率和梯度，但是，在基本BP算法中，学习速率是不变的。实际上学习速率对收敛速度的影响也很大，通过对它的在线调整，可以大大提高收敛速度。   
学习速率的调整原则上是使它在每一步保持尽可能大的值，而又不致使学习过程失去稳定性。学习速率可以根据误差变化的信息和误差函数对连接权梯度变化的信息进行启发式调整，也可以根据误差函数对学习速率的梯度直接进行调整。
对于批处理可以根据总误差变化的信息进行启发式调整，其规则是：
（1）若总误差E减小，则学习率增加。
（2）若总误差E增加，则学习率减小。当新误差与老误差之比超过一定值（例如1.04），则学习率快速下降（例如将实际值乘以因子b=0.7）.
上述规则可用如下迭代方程来描述：     

其中参数的典型值为：a=1.05，b=0.7，k=1.04。上述方法可以在学习过程的每一步进行学习率的调整。

共轭梯度法

用共轭梯度法替代梯度下降法。与梯度下降法不同，基于数值优化的算法不仅利用了目标函数的一阶导数信息，而且往往利用了目标函数的二阶导数信息。具体可参见我博客关于共轭梯度法的介绍。

BP神经网络的优点

(1)并行分布处理方法:结构上的并行,使得网络的各节点可以同时进行类似的处理过程。

(2)非线性映射能力:在建模过程中遇到的许多问题均具有高度的非线性。而 BP网络能以任意精度对任一非线性连续函数逼近,具有较强的建模能力。

(3)容错性:全局的学习训练或识别不会因为少量局部的神经元的影响而失去作用。系统在发生局部损伤时仍可以继续正常工作。当网络中的某一个节点或者某几个节点受到破坏后,由于信息在几乎整个网络中被分布式存放,信息仍然可以被存取。

(4)自学习、自适应性:每两个神经元之间的连接矩阵能够被改变,通过学习可以在输入信号中提取特征,这些特征人类可能无法直接理解,将这些特征通过写入网络的连接矩阵与偏置进行记忆,使得网络系统可以更加一般的进行使用,网络的学习也可以是逐个样本逐次学习的在线学习方式。

(5)泛化能力:可以充分逼近任意复杂的非线性关系,学习好的网络模型实际使用时仍可以达到较好的效果。

BP神经网络的缺点

主要表现在学习过程的不定性上,具体如下:


(1)学习时间较长,遇到部分问题时,可能需要运行几个小时甚至更久。

(2)容易陷入局部极小值。

(3)完全无法学习,激活函数由于权值调整过大而进入饱和区域,最终网络权值的调节陷入停滞。

(4)喜新厌旧。训练过程中,学习新样本时有一定可能将旧样本遗忘掉

<span style="font-size:18px;">#include<iostream>
#include<cmath>
using namespace std;

#define  innode 3  //输入结点数
#define  hidenode 10//隐含结点数
#define  outnode 1 //输出结点数
#define  trainsample 8//BP训练样本数
class BpNet
{
public:
    void train(double p[trainsample][innode ],double t[trainsample][outnode]);//Bp训练
    double p[trainsample][innode];     //输入的样本
    double t[trainsample][outnode];    //样本要输出的

    double *recognize(double *p);//Bp识别

    void writetrain(); //写训练完的权值
    void readtrain(); //读训练好的权值，这使的不用每次去训练了，只要把训练最好的权值存下来就OK

    BpNet();
    virtual ~BpNet();

public:
    void init();
    double w[innode][hidenode];//隐含结点权值
    double w1[hidenode][outnode];//输出结点权值
    double b1[hidenode];//隐含结点阀值
    double b2[outnode];//输出结点阀值

    double rate_w; //权值学习率（输入层-隐含层)
    double rate_w1;//权值学习率 (隐含层-输出层)
    double rate_b1;//隐含层阀值学习率
    double rate_b2;//输出层阀值学习率

    double e;//误差计算
    double error;//允许的最大误差
    double result[outnode];// Bp输出
};

BpNet::BpNet()
{
    error=1.0;
    e=0.0;

    rate_w=0.9;  //权值学习率（输入层--隐含层)
    rate_w1=0.9; //权值学习率 (隐含层--输出层)
    rate_b1=0.9; //隐含层阀值学习率
    rate_b2=0.9; //输出层阀值学习率
}

BpNet::~BpNet()
{

}

void winit(double w[],int n) //权值初始化
{
  for(int i=0;i<n;i++)
    w[i]=(2.0*(double)rand()/RAND_MAX)-1;
}

void BpNet::init()
{
    winit((double*)w,innode*hidenode);
    winit((double*)w1,hidenode*outnode);
    winit(b1,hidenode);
    winit(b2,outnode);
}

void BpNet::train(double p[trainsample][innode],double t[trainsample][outnode])
{
    double pp[hidenode];//隐含结点的校正误差
    double qq[outnode];//希望输出值与实际输出值的偏差
    double yd[outnode];//希望输出值

    double x[innode]; //输入向量
    double x1[hidenode];//隐含结点状态值
    double x2[outnode];//输出结点状态值
    double o1[hidenode];//隐含层激活值
    double o2[hidenode];//输出层激活值

    for(int isamp=0;isamp<trainsample;isamp++)//循环训练一次样品
    {
        for(int i=0;i<innode;i++)
            x[i]=p[isamp][i]; //输入的样本
        for(int i=0;i<outnode;i++)
            yd[i]=t[isamp][i]; //期望输出的样本

        //构造每个样品的输入和输出标准
        for(int j=0;j<hidenode;j++)
        {
            o1[j]=0.0;
            for(int i=0;i<innode;i++)
                o1[j]=o1[j]+w[i][j]*x[i];//隐含层各单元输入激活值
            x1[j]=1.0/(1+exp(-o1[j]-b1[j]));//隐含层各单元的输出
            //    if(o1[j]+b1[j]>0) x1[j]=1;
            //else x1[j]=0;
        }

        for(int k=0;k<outnode;k++)
        {
            o2[k]=0.0;
            for(int j=0;j<hidenode;j++)
                o2[k]=o2[k]+w1[j][k]*x1[j]; //输出层各单元输入激活值
            x2[k]=1.0/(1.0+exp(-o2[k]-b2[k])); //输出层各单元输出
            //    if(o2[k]+b2[k]>0) x2[k]=1;
            //    else x2[k]=0;
        }

        for(int k=0;k<outnode;k++)
        {
            qq[k]=(yd[k]-x2[k])*x2[k]*(1-x2[k]); //输出层的校正误差
            for(int j=0;j<hidenode;j++)
                w1[j][k]+=rate_w1*qq[k]*x1[j];  //下一次的隐含层和输出层之间的新连接权
        }

        for(int j=0;j<hidenode;j++)
        {
            pp[j]=0.0;
            for(int k=0;k<outnode;k++)
                pp[j]=pp[j]+qq[k]*w1[j][k];
            pp[j]=pp[j]*x1[j]*(1-x1[j]); //隐含层的校正误差

            for(int i=0;i<innode;i++)
                w[i][j]+=rate_w*pp[j]*x[i]; //下一次的输入层和隐含层之间的新连接权
        }

        for(int k=0;k<outnode;k++)
        {
            e+=fabs(yd[k]-x2[k])*fabs(yd[k]-x2[k]); //计算均方差
        }
        error=e/2.0;

        for(int k=0;k<outnode;k++)
            b2[k]=b2[k]+rate_b2*qq[k]; //下一次的隐含层和输出层之间的新阈值
        for(int j=0;j<hidenode;j++)
            b1[j]=b1[j]+rate_b1*pp[j]; //下一次的输入层和隐含层之间的新阈值
    }
}

double *BpNet::recognize(double *p)
{
    double x[innode]; //输入向量
    double x1[hidenode]; //隐含结点状态值
    double x2[outnode]; //输出结点状态值
    double o1[hidenode]; //隐含层激活值
    double o2[hidenode]; //输出层激活值

    for(int i=0;i<innode;i++)
        x[i]=p[i];

    for(int j=0;j<hidenode;j++)
    {
        o1[j]=0.0;
        for(int i=0;i<innode;i++)
            o1[j]=o1[j]+w[i][j]*x[i]; //隐含层各单元激活值
        x1[j]=1.0/(1.0+exp(-o1[j]-b1[j])); //隐含层各单元输出
        //if(o1[j]+b1[j]>0) x1[j]=1;
        //    else x1[j]=0;
    }

    for(int k=0;k<outnode;k++)
    {
        o2[k]=0.0;
        for(int j=0;j<hidenode;j++)
            o2[k]=o2[k]+w1[j][k]*x1[j];//输出层各单元激活值
        x2[k]=1.0/(1.0+exp(-o2[k]-b2[k]));//输出层各单元输出
        //if(o2[k]+b2[k]>0) x2[k]=1;
        //else x2[k]=0;
    }

    for(int k=0;k<outnode;k++)
    {
        result[k]=x2[k];
    }
    return result;
}

void BpNet::writetrain()
{
    FILE *stream0;
    FILE *stream1;
    FILE *stream2;
    FILE *stream3;
    int i,j;
    //隐含结点权值写入
    if(( stream0 = fopen("w.txt", "w+" ))==NULL)
    {
        cout<<"创建文件失败!";
        exit(1);
    }
    for(i=0;i<innode;i++)
    {
        for(j=0;j<hidenode;j++)
        {
            fprintf(stream0, "%f\n", w[i][j]);
        }
    }
    fclose(stream0);

    //输出结点权值写入
    if(( stream1 = fopen("w1.txt", "w+" ))==NULL)
    {
        cout<<"创建文件失败!";
        exit(1);
    }
    for(i=0;i<hidenode;i++)
    {
        for(j=0;j<outnode;j++)
        {
            fprintf(stream1, "%f\n",w1[i][j]);
        }
    }
    fclose(stream1);

    //隐含结点阀值写入
    if(( stream2 = fopen("b1.txt", "w+" ))==NULL)
    {
        cout<<"创建文件失败!";
        exit(1);
    }
    for(i=0;i<hidenode;i++)
        fprintf(stream2, "%f\n",b1[i]);
    fclose(stream2);

    //输出结点阀值写入
    if(( stream3 = fopen("b2.txt", "w+" ))==NULL)
    {
        cout<<"创建文件失败!";
        exit(1);
    }
    for(i=0;i<outnode;i++)
        fprintf(stream3, "%f\n",b2[i]);
    fclose(stream3);

}

void BpNet::readtrain()
{
    FILE *stream0;
    FILE *stream1;
    FILE *stream2;
    FILE *stream3;
    int i,j;

    //隐含结点权值读出
    if(( stream0 = fopen("w.txt", "r" ))==NULL)
    {
        cout<<"打开文件失败!";
        exit(1);
    }
    float  wx[innode][hidenode];
    for(i=0;i<innode;i++)
    {
        for(j=0;j<hidenode;j++)
        {
            fscanf(stream0, "%f", &wx[i][j]);
            w[i][j]=wx[i][j];
        }
    }
    fclose(stream0);

    //输出结点权值读出
    if(( stream1 = fopen("w1.txt", "r" ))==NULL)
    {
        cout<<"打开文件失败!";
        exit(1);
    }
    float  wx1[hidenode][outnode];
    for(i=0;i<hidenode;i++)
    {
        for(j=0;j<outnode;j++)
        {
            fscanf(stream1, "%f", &wx1[i][j]);
            w1[i][j]=wx1[i][j];
        }
    }
    fclose(stream1);

    //隐含结点阀值读出
    if(( stream2 = fopen("b1.txt", "r" ))==NULL)
    {
        cout<<"打开文件失败!";
        exit(1);
    }
    float xb1[hidenode];
    for(i=0;i<hidenode;i++)
    {
        fscanf(stream2, "%f",&xb1[i]);
        b1[i]=xb1[i];
    }
    fclose(stream2);

    //输出结点阀值读出
    if(( stream3 = fopen("b2.txt", "r" ))==NULL)
    {
        cout<<"打开文件失败!";
        exit(1);
    }
    float xb2[outnode];
    for(i=0;i<outnode;i++)
    {
        fscanf(stream3, "%f",&xb2[i]);
        b2[i]=xb2[i];
    }
    fclose(stream3);
}


</span>

bp网络增量式学习

bp网络增量式学习时数据归一化的处理

参考资料：http://blog.csdn.net/celerychen2009/article/details/8964753