神经网络从基础到改进+源程序

神经网络初步学习总结：（对神经网络的模型有一定的了解，如果从未接触有点看不懂）

第一点：以下是最简单的神经网络模型了

x：  输入参数

a0： 输入偏置

a1： 输入权重

b0： 隐藏层偏置

b1： 隐藏层输入权重

y：  隐藏层输入参数（经过激励函数的输出，下面会讲解激励函数）

Z：  隐藏层输出（经过激励的输出）

 

各个参数的展开式如下：不用介绍了，都很简单的函数，不懂得话去百度一些模型看看

 

 

激励函数：经过sigmoid（）函数之后的数值，这是常见的分类函数。

          如果是用于函数逼近，使用Y = X 作为激励函数即可。

第二点：公式的相关介绍

首先明确梯度下降法：字面的理解是沿着切线的方向，可以更快更准确的找出最小值

                    我们使用这个规则只需要知道，梯度下降=偏导数，其中

                    偏导数=k*变化量  抓住这两个点，这是BP神经网络的核心之一。

                    例如：  ：比例系数，W:权值，E：误差

明白Delta学习规则：有监督的学习，是利用误差作为判断的标准。

                   形式：  y：隐藏层的输出

                                Z：实际输出，t：期望输出（实际值）

                   基于这个学习规则进行BP的反向调整权重，核心之二

结合上面两个公式：Delta规则的误差作为标准，误差利用整体的平方可以减少误差波动的

                  影响。下面为了计算方便多乘以一个1/2，求导之后消去，    

                 没意义只是为了计算方便：BP神经网络的权值和偏置调整就可以利用这

                 个公式，例如：、  等等

 

神经网络的权值和偏置计算：

  因为误差E和隐藏层偏置没有直接关系，

所以需要链式求偏导，返回去看一下模型的参数定义就知道了。

‚  因为误差E和输入层的输入数据没有直接联系，所以需要链式求偏导

，很简单的链式求导，看一下高数就知道的。

剩下的公式大家自己推导吧。。。。这是核心之三

第三点：BP神经网络的改进

1.批量学习：顾名思义批量学习就是梯度成批量的计算， 总梯度的含义

          例如：批量数是10个样本，那就是W1的梯度是十个样本加起来。和一个一个        

          的计算是一样的，这里不过是选几个样本加起来求平均数而已。

2.遍历学习（在线）：本文中使用的改进就是动量法，当前权值的更新需要上一次的和这一次   

          同时作用，达到平滑高效的作用。公式：，注意这

          里的是没有叠加的，因为上面w存在。是有叠加的，因为是所有的w项。核心之四

第四点：BP神经网络的程序

核心算法就是更新权值w和更新偏置b，参考了网上程序，但是基本都是有漏洞，可能没下载到好的程序吧，结合了部分网上历程还有一本书《神经网络在应用科学和工程中的应用-----从基本原理到复杂的模式识别》。我弄了一个星期，就是由于公式编写成代码出现很多问题，多细心一点可以减少很多未知的错误！！！

       BP神经网络下载

注意：看了Ng的视频，Sigmoid函数<tanh函数<ReLu函数<Leak ReLu函数

 

 

CPP文件：

#include "BP.h"

BP_network::BP_network()
{
    srand((unsigned)time(NULL));
    memset(w, 0, sizeof(w));
    memset(b, 0, sizeof(b));
    memset(Yout, 0, sizeof(Yout));
    memset(DataIn, 0, sizeof(DataIn));
    memset(DataOut, 0, sizeof(DataOut));
    memset(dv, 0, sizeof(dv));
    memset(dw, 0, sizeof(dw));
}

BP_network::~BP_network()
{

}

double BP_network::Random()
{
    double Rand;
    Rand = (1.0*rand()) / (RAND_MAX + 1);
    return Rand;
}
//--------------写入数据-------------------//
void BP_network::FwriteData()
{
    FILE *fp1, *fp2;
    double data1 = 0.0, data2;
    if ((fp1 = fopen("G:\in.txt", "w")) == NULL) printf("can't open in.txt");
    if ((fp2 = fopen("G:\out.txt", "w")) == NULL) printf("can't open out.txt");
    for (int i = 0; i < SampleCount; i++)
    {
        //data1 = Random() % 1000 / 100;
        data1 = double(int(Random() * 1000) % 1000) / 100;
        data2 = double(int(Random() * 1000) % 1000) / 100;
        fprintf(fp1,"%lf %lf
", data1, data2);
        data1 = data1 * data2;
        fprintf(fp2,"%lf 
", data1);
    }
    fclose(fp1);
    fclose(fp2);
}
//--------------读入数据-------------------//
void BP_network::FreadData()
{
    FILE *fp1, *fp2;
    if (((fp1 = fopen("G:\in.txt", "r")) == NULL))
        printf("can't open in.txt");
    if((fp2 = fopen("G:\out.txt", "r")) == NULL)
        printf("can't open in.txt");;
    for (int i = 0; i < SampleCount; i++)
    {
        for (int j = 0; j < InCount; j++)
        {
            fscanf(fp1, "%lf", &DataIn[i][j]);
        }
        fscanf(fp2, "%lf", &DataOut[i][0]);
    }
    fclose(fp1);
    fclose(fp2);
}
//---------归一化输入和输出的数值，随机化权值和偏置的值---------//
//****************   对于隐藏层->输出层=w[i][j][k]     *************//
//------------------  i:层数，j:输出层个数，k:隐藏层个数    ------//
void BP_network::Init_network()
{
    double InMax, InMin, OutMax, OutMin;
    InMax = DataIn[0][0];
    InMin = DataIn[0][0];
    OutMax = DataOut[0][0];
    OutMin = DataOut[0][0];

    for (int i = 0; i < SampleCount; i++)
    {
        for (int j = 0; j < InCount; j++)
        {
            InMax = InMax > DataIn[i][j] ? InMax : DataIn[i][j];
            InMin = InMin < DataIn[i][j] ? InMin : DataIn[i][j];
        }
        OutMax = OutMax > DataOut[i][0] ? OutMax : DataOut[i][0];
        OutMin = OutMin < DataOut[i][0] ? OutMin : DataOut[i][0];
    }
    for (int i = 0; i < SampleCount; i++)
    {
        for (int j = 0; j < InCount; j++)
        {
            DataIn[i][j] = (DataIn[i][j] - InMin + 1) / (InMax - InMin + 1);
        }
        DataOut[i][0] = (DataOut[i][0] - OutMin + 1) / (OutMax - OutMin + 1);
    }
    for (int j = 0; j < HiddenCount; j++)
    {
        //----------随机化W和B的值------------//
        for (int i = 0; i < LayerCount - 1; i++)
        {
            if (i == 0)//第一层
            {
                for (int k = 0; k < InCount; k++)  w[i][k][j] = 2 * (0.5 - Random());
            }
            if (i == 1)//第二层
            {
                w[i][j][0] = 2 * (0.5 - Random());
            }
        }
        b[0][j] = 1;//由于数比较少，不需要做循环，直接赋值
        b[1][0] = 1;
    }    
    inMax = InMax;
    inMin = InMin;
    outMax = OutMax;
    outMin = OutMin;
}
//---------激励函数输出----------//
void BP_network::DrivingOut(int m)
{
    Yout[1][0] = 0.0;//!!!!!!!!!!!!!注释:未能清除数据，导致检查两天!!!!!!!!!!!!!!!!!!!!!
    for (int j = 0; j < HiddenCount; j++)
    {
        Yout[0][j] = 0.0;
        for (int k = 0; k < 2; k++)
        {
            Yout[0][j] += DataIn[m][k] * w[0][k][j];    
        }
        Yout[0][j] += b[0][j];
        Yout[0][j] = Sigmoid(Yout[0][j]);
        Yout[1][0] += Yout[0][j] * w[1][j][0];
    }
    Yout[1][0] += b[1][0];
    Yout[1][0] = Sigmoid(Yout[1][0]);
}
//-----------对W和B进行调整---------------//
void BP_network::BackAdjust(int m)
{
#if 1//加动量法
    double StudyRate = 0.0, f = 0.0;
    double Sum = 0.0;
    StudyRate = (Yout[1][0] - DataOut[m][0]) * Yout[1][0] * (1 - Yout[1][0]);
    db0[1][0] = U1*db0[1][0] + (1 - U1)*B_Rate*StudyRate;
    b[1][0] -= db0[1][0];
    for (int i = 0; i < HiddenCount; i++)
    {
        dv[0][i] = U1*dv[0][i] + (1 - U1)*W_Rate * StudyRate * Yout[0][i];
        w[1][i][0] -= dv[0][i];
    }
    for (int i = 0; i < HiddenCount; i++)
    {
        f = 0.0;
        f = StudyRate * w[1][i][0] * Yout[0][i] * (1 - Yout[0][i]);//改正之后
        for (int j = 0; j < InCount; j++)
        {
            dw[j][i] = U1*dw[j][i] + (1 - U1)*W_Rate * f * DataIn[m][j];
            w[0][j][i] -= dw[j][i];
        }
        db1[0][i] = U1*db0[0][i] + (1 - U1)*B_Rate*f;
        b[0][i] -= db1[0][i];
    }
#endif
#if 0//网上找到的加了一点动量，但是程序不稳定
    int i, j;
    double t;
    for (i = 0; i < HiddenCount; ++i)
    {
        t = 0;
        for (j = 0; j < OutCount; ++j) {
            t += (Yout[1][j] - DataOut[m][j])*w[1][i][j];
            dv[i][j] = U1*dv[i][j] + (1-U1)*W_Rate*(Yout[1][j] - DataOut[m][j])*Yout[0][i];
            w[1][i][j] -= dv[i][j];
        }
        for (j = 0; j < InCount; ++j) {
            dw[j][i] = U1*dw[j][i] + (1 - U1)*W_Rate*t*Yout[0][i] * (1 - Yout[0][i])*DataIn[m][j];
            w[0][j][i] -= dw[j][i];
        }
}
#endif
#if 0//未加动量法
    double StudyRate = 0.0, f = 0.0;
    double Sum = 0.0;
    StudyRate = ( Yout[1][0] - DataOut[m][0]) * Yout[1][0] * (1 - Yout[1][0]);
    b[1][0] -= ETA_W*StudyRate;
    for (int i = 0; i < HiddenCount; i++)  
        w[1][i][0] -= W_Rate * StudyRate * Yout[0][i];
    for (int i = 0; i < HiddenCount; i++)
    {        
        f = 0.0;
        f = StudyRate * w[1][i][0] * Yout[0][i] * (1 - Yout[0][i]);//改正之后
        for (int j = 0; j < InCount; j++)
        {
            w[0][j][i] -= W_Rate* f *DataIn[m][j];
        }
       b[0][i] -= ETA_B * f;
    }
#endif
}
//-----------训练神经网络-----------------//
void BP_network::Train_network()
{
    int Tcount = 0;
    double e = 1.0;
    while (Tcount<TrainCount && e>Accuracy)
    {
        e = 0;
        for (int i = 0; i < SampleCount; i++)
        {
            DrivingOut(i);
            e += fabs((Yout[1][0]-DataOut[i][0])/ DataOut[i][0]);
            BackAdjust(i);
        }
        Tcount++;
        e = e / SampleCount;
        cout << "第" << Tcount << "代精度为：" << e << endl;
    }
}

double BP_network::Calculate(double x, double y)
{
    x = (x - inMin + 1) / (inMax - inMin + 1);
    y = (y - inMin + 1) / (inMax - inMin + 1);
#if true
    double sum = 0.0, Tout = 0.0;
    for (int i = 0; i < HiddenCount; i++)
    {
        Yout[0][i] = w[0][0][i] * x + w[0][1][i] * y + b[0][i];
        Yout[0][i] = Sigmoid(Yout[0][i]);
        Tout += Yout[0][i] * w[1][i][0];
    }
    Tout += b[1][0];
    Tout = Sigmoid(Tout);
    return (Tout * (outMax - outMin + 1) + outMin - 1);
#endif
}

double BP_network::Sigmoid(double t)
{
    double sum;
    sum = 1.0 / (1.0+exp(-t));
    return sum;
}

 

H文件：

#pragma once
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector>
#include "time.h"
#include "math.h"

using namespace std;

const int SampleCount = 820;//定义样本个数
const int InCount = 2;//输入神经元个数
const int OutCount = 1;//输出神经元个数
const int HiddenCount = 45;//隐藏层神经元个数
const int TrainCount = 6000;//训练次数
const int LayerCount = 3;//神经网络层数
const int NeuronMax = 45;//每层最多的神经元个数(也可以直接定义个数)

const double U0 = 0.15;
const double U1 = 0.0;//0.15
const double W_Rate = 0.8;//权值调整率//0.8
const double B_Rate = 0.8;//阈值调整率
const double Accuracy = 0.01;

#define ETA_W 0.2
#define ETA_B 0.1

class BP_network
{
public:
    BP_network();
    ~BP_network();    
    void FwriteData();
    void FreadData();
    void Init_network();
    void Train_network();
    double Calculate(double x, double y);
private:
    double DataIn[SampleCount][InCount];//输入的数据
    double DataOut[SampleCount][OutCount];//输出的数据
    double w[LayerCount-1][HiddenCount][HiddenCount];//权值(定义的是最大范围，为了移植方便，用不完)
    double b[LayerCount-1][NeuronMax];//偏置(第几层，第几个神经元，对应的下一的神经元)
    double Yout[LayerCount-1][NeuronMax];//经过激励函数的输出
    double inMax, outMax, inMin, outMin;
    double dv[HiddenCount][HiddenCount], dw[HiddenCount][HiddenCount];
    double db0[2][2], db1[HiddenCount][HiddenCount];


    double Sigmoid(double t);
    void DrivingOut(int i);
    void BackAdjust(int t);
    double Random();
};

main文件：

#include "BP.h"

int main(int argc, char*argv)
{
    BP_network test;
    test.FwriteData();
    test.FreadData();
    test.Init_network();
    test.Train_network();
    cout << test.Calculate(5,5);
    while (1);return 0;
}

不训练直接使用文件：

注：这是没有经过测试，可能程序有点小Bug，主题思路是没问题的！

//----@InData:    输入为一维的数据 
//----@Weight:    权重
//                []        :层数, 
//                            [0]:      输入层到隐藏层的权重
//                            [1]:      隐藏层到输出层的权重
//                [][]    :每层个数
//                            [0][i]:      输入层的个数
//                            [1][h]:      隐藏层个数
//                [][][]    :每层个数        
//                            [0][i][h]:隐藏层个数        
//                            [1][h][o]:输出层个数
//----@Bias:    偏置
//                [0][h]    :隐藏层偏置
//                [1][o]    :输出层偏置
//----@OutData:    输出为一维数据                        
void Calculate(double* InData,double*** Weight,double* Bias ,char* OutData)
{
    double HidData[HiddenCount][OutCount],HidData_Temp=0;//HidData:存放临时隐藏层到输出层的数据，HidData_Temp:存放临时输入层到隐藏层的单个数据
    unsigned char flag = 1;//加输出层偏置
    for (char h = 0; h < HiddenCount; h++)
    {
        for(unsigned char i=0; i<sizeof(InData)/sizeof(double); i++)//单个隐藏层的输出
        {
            HidData_Temp += Weight[0][i][h] *InData[i];
        }
        HidData_Temp += Bias[0][h];
        HidData_Temp = Sigmoid(HidData_Temp);
        for(unsigned char o=0; o<sizeof(OutData)/sizeof(char); o++)//单个隐藏层对输出层的输出
        {
            HidData[h][o] = Weight[1][h][o]*HidData_Temp;
            OutData[o] += HidData[h][o];
            //OutData[o] = flag==1?(OutData[o]+Bias[1][o]):OutData[o];
            if(flag) OutData[o]+=Bias[1][o];//只能加一次偏置，顾用标志位
        }
        flag=0;
    }
}
//----@InData:    输入为一维的数据 
//----@MinMax:    数据最值
//                [0] :Maximun data
//                [1]    :Minimun data
//----@OutData:    输出为一维数据    
void Normlize(double* InDta,double* MinMax,double* OutData)
{
    for(unsigned char i=0;i<sizeof(InData)/sizeof(double);i++)
    {
        OutData[i] = (InDta[i] - MinMax[0] + 1) / (MinMax[1] - MinMax[0] + 1);
    }
}
//----Sigmoid函数
double Sigmoid(double t)
{
    double sum;
    sum = 1.0 / (1.0+exp(-t));
    return sum;
}