神經網絡從基礎到改進+源程序

神經網絡初步學習總結：（對神經網絡的模型有一定的了解，如果從未接觸有點看不懂）

第一點：以下是最簡單的神經網絡模型了

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\n", data1, data2);
        data1 = data1 * data2;
        fprintf(fp2,"%lf \n", 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;
}