Neural Network based on Eorr Back Propagation典型BP网络c++实现

参考资料：人工神经网络－韩力群PPT

   

    看了一些关于基于神经网络的语言模型, 与传统语言模型相比, 除了计算量让人有点不满意之外, 不需要额外的平滑算法, 感觉它们的效果让人惊讶。 这些网络里面都能看到BP的影子, 可以说BP网络是最基本的, 掌握扎实了, 对其他结构理解会更深刻， 于是早在学习语言模型之前我自己曾经用c++写过一个简单的BP网络，虽然功能简单，只有最基本的三层结构，但让自己对误差反传理解的更深刻。那个时候自己还没开始写博客， 现在把以前的代码放上来吧， 那个时候写代码没考虑任何优化，达到功能即可，所以很多模块没有做成函数，也没有考虑如何加速网络，比如矩阵相乘，我用的就是最老实的多重循环来计算。最后利用这个网络给了一个简单的例子——用这个BP网络来计算异或运算。这样更容易理解，网络先进行训练，由人为给定异或运算的样本规则，然后让其自行学习，最后是测试模块（那个时候我写的函数叫work，当时不知道准确的叫法应该是test）.

    本文不对BP网络做推导，因为网上随便一搜就很多，下面是一个典型的三层结构，图来自人工神经网络－韩力群PPT

下面是代码，代码组织方式是按照标准的公式推导的，以前写这个代码时参照了网上的，但现在确实找不到是哪儿的了，就没办法引用了。下面直接上代码，因为注释的非常详细，所以过程就不做解释了。

首先BP网络的结构定义在BpNet.h，内容如下：

#include <iostream>  
#include <fstream>  
#include <ctime>  
#include <cmath>  
  
using namespace std;  
  
/*常量区域*/  
#define N 4                                         //样本的个数  
#define IN 2                                        //输入层神经元个数  
#define HN 2                                        //隐层神经元个数  
#define ON 1                                        //输出层神经元个数  
  
//定义存放学习样本的结构  
class StudyData  
{  
public:  
    float input[IN];                                //输入样本  
    float teach[ON];                                //期望输出(教师信号)  
      
    StudyData();  
    virtual ~StudyData();  
};  
  
//定义BP神经网络的类结构  
class BpNet    
{  
public:  
    void GetOutput();                                   //从键盘输入数据，输出进行保存  
    void Work(char *weight, char *threshold);           //将训练好的数据进行工作  
    double GetSumErr();                                 //得到总误差  
                                                        //进行训练  
    void Train(char *sampleFileName, char *weight, char *threshold);  
    void ReadWeight(char *weight, char *threshold);     //读取权值阈值到神经网络中  
    void SaveBpNet(char *weight, char *threshold);      //保存权值  
    void UpdateWeight(int m);                           //更新权值  
    void ErrorSignal(int m);                            //算误差信号  
    void NetInputOutput(int m);                         //算各层输出输入  
    void GetTrainingData(char *sampleFileName);         //从外存获取样本集  
    void StartShow(void);                                 
  
    StudyData studyData[N];                             //存放多组学习样本的数组  
    float W[HN][IN];                                    //输入层到隐层权值数组  
    float V[ON][HN];                                    //隐层到输出层权值数组  
    float HU_HN[HN];                                    //隐层神经元阈值数组  
    float HU_ON[ON];                                    //输出层神经元阈值数组  
    float IN_HN[HN];                                    //隐层的输入  
    float OUT_HN[HN];                                   //隐层的输出  
    float IN_ON[ON];                                    //输出层的输入  
    float OUT_ON[ON];                                   //输出层的输出  
    float E[N];                                         //样本组误差数组,每个分量为一组样本的误差  
    float stuRate1;                                     //输出层至隐层学习效率  
    float stuRate2;                                     //隐层至输入层学习效率  
    float errSignalON[ON];                              //δk,输出层的误差信号数组  
    float errSignalHN[HN];                              //δj,隐层的误差信号数组  
  
    BpNet();  
    virtual ~BpNet();  
};  

其次是BpNet.h的实现，如下：

#include "stdafx.h"  
#include "BpNet.h"  
  
//////////////////////////////////////////////////////////////////////  
// Construction/Destruction  
//////////////////////////////////////////////////////////////////////  
                                  
/*BpNet构造函数，对变量进行初始化*/  
BpNet::BpNet()  
{  
    srand(time(NULL));                                  //随机数种子  
  
    int i, j;  
    for (i=0; i<HN; i++)                             //输入层到隐层权值初始化为0附近的小数  
    {     
        for (j=0; j<IN; j++)  
        {  
            W[i][j] = (float)(((rand()/32767.0)*2-1)/2);  
        }  
    }  
  
    for (i=0; i<ON; i++)                             //隐层到输出层权值初始化为0附近的小数  
    {     
        for (j=0; j<HN; j++)  
        {  
            V[i][j] = (float)(((rand()/32767.0)*2-1)/2);  
        }  
    }  
  
    for (i=0; i<HN; i++)                             //阈值初始化  
    {  
        HU_HN[i] = 1.0;  
    }  
  
    for (i=0; i<ON; i++)                             //阈值初始化  
    {  
        HU_ON[i] = 1.0;  
    }  
  
    stuRate1 = 0.5;                                     //输出层到隐层的学习率初始化  
    stuRate2 = 0.5;                                     //隐层到输入层的学习率初始化  
  
    //测试权值的输出  
/* 
    for (i=0; i<HN; i++) 
    { 
        for (j=0; j<IN; j++) 
        { 
            cout << W[i][j] << " "; 
        } 
        cout << endl; 
    } 
 
    cout << endl; 
    for (i=0; i<ON; i++) 
    { 
        for (j=0; j<HN; j++) 
        { 
            cout << V[i][j] << " "; 
        } 
        cout << endl; 
    }*/  
}  
  
/*BpNet析构函数,对动态申请内存进行释放*/  
BpNet::~BpNet()  
{  
  
}  
  
/*程序开始*/  
void BpNet::StartShow()  
{  
    cout << endl;  
    cout << "*************BP算法的使用程序(C++版)********" << endl << endl;  
}  
  
/**从文件中读取样本, 并显示到屏幕上以便于进行核对**/  
void BpNet::GetTrainingData(char *sampleFileName)  
{  
    ifstream infile(sampleFileName, ios::in);           //打开样本文件  
    if (!infile)                                        //如果打开失败  
    {  
        cerr << "打开样本文件出错" << endl;  
        exit(1);  
    }  
      
    int i, j;                                           //循环下标  
  
    float temp;  
      
    for (i=0; i<N; i++)                                  //i表示每一趟读取一个样本  
    {  
        for (j=0; j<IN+ON; j++)            
        {  
            if (!(infile >> temp))                        //从文件读入一个数  
            {  
                cerr << "读入文件元素过程中出错,或以达到文件结尾" << endl;  
            }  
  
            if (j > (IN-1))                              //读入教师信号  
            {             
                studyData[i].teach[j-IN] = temp;  
            }  
            else                                        //读入样本输入  
            {  
                studyData[i].input[j] = temp;  
            }  
        }  
    }  
  
    infile.close();                                     //关闭文件  
  
    /*文件中的样本信息输出到屏幕*/  
    cout << "从指定文件中成功载入"   
         << N * (IN + ON)  
         << "个数据,显示如下:" << endl << endl;  
  
    for (i=0; i<IN; i++)                             //进行排版  
    {  
        cout << "输入值" << "   ";  
    }  
    for (i=0; i<ON; i++)  
    {  
        cout << "期望值" << "   ";  
    }  
    cout << endl;  
    for (i=0; i<N; i++)  
    {  
        for (j=0; j<IN+ON; j++)  
        {  
            if (j > (IN-1))                              //输出教师信号  
            {             
                cout <<studyData[i].teach[j-IN] << "         ";  
            }  
            else                                        //输出样本输入  
            {  
                cout <<studyData[i].input[j] << "        ";  
            }  
        }  
        cout << endl;  
    }  
}  
  
StudyData::StudyData()  
{  
  
}  
  
StudyData::~StudyData()  
{  
  
}  
  
void BpNet::NetInputOutput(int m)  
{  
    //求BP网络的神经网络各层进输入输出  
    //断言参数m合法 参数m表示第m组测试样本  
  
    int i, j;  
    float sum = 0.0;                      
  
    for (i=0; i<HN; i++)                             //求隐层的净输入输出  
    {  
        for (j=0; j<IN; j++)  
        {  
            sum += W[i][j] * studyData[m].input[j];     //算隐层第i个神经元不包含阈值的输入  
        }                                     
        IN_HN[i] = sum + HU_HN[i];                      //算隐层第i个神经元的净输入  
        OUT_HN[i] = 1.0 / (1.0 + exp(-IN_HN[i]));       //算隐层第i个神经元的输出  
    }  
  
    sum = 0.0;  
    for (i=0; i<ON; i++)                             //求输出层的输入输出  
    {  
        for (j=0; j<HN; j++)  
        {  
            sum += V[i][j] * OUT_HN[j];                 //算输出层第i个神经元的输入(不含阈值)  
        }  
        IN_ON[i] = sum + HU_ON[i];                      //算输出层第i个神经元的净输入  
        OUT_ON[i] = 1.0 / (1.0 + exp(-IN_ON[i]));       //算输出层第i个神经元的输出  
    }  
  
    //测试输入输出 打印到屏幕上  
/* 
    for (i=0; i<ON; i++) 
    { 
        cout << "输出层输出" << OUT_ON[i] << endl; 
    } 
    for (i=0; i<HN; i++) 
    { 
        cout << "隐层输入" << IN_HN[i] << endl; 
    }*/  
}  
  
void BpNet::ErrorSignal(int m)  
{  
    //算误差信号δk,δj  
    //断言m合法,m表示第m组样本  
  
    int k;  
    float absErr[ON];                                   //期望-输出即绝对误差  
    float sqrErr = 0.0;                                 //误差平方和  
  
    for (k=0; k<ON; k++)                               
    {  
        absErr[k] = studyData[m].teach[k] - OUT_ON[k];  //算绝对误差  
                                                        //算输出层的误差信号  
        errSignalON[k] = absErr[k] * OUT_ON[k] * (1.0-OUT_ON[k]);     
        sqrErr += absErr[k] * absErr[k];                //算第m组样本的误差平方和    
    }  
    E[m] = sqrErr / 2;                                  //算第m组样本的总误差  
      
    int j;                                              //下面算隐层的误差信号δj  
    float sum;  
  
    for (j=0; j<HN; j++)                               
    {  
        sum = 0.0;  
        for (k=0; k<ON; k++)  
        {  
            sum += errSignalON[k] * V[k][j];  
        }  
        errSignalHN[j] = sum * OUT_HN[j] * (1-OUT_HN[j]);//得到隐层的误差信号  
    }  
  
}  
  
void BpNet::UpdateWeight(int m)  
{  
    //更新两层权值,阈值  
    //断言m合法,m表示第m组测试样本  
  
    int i, j;  
    float deltaWeight;                                  //权值的改变量  
  
    for (i=0; i<ON; i++)                             //更新隐层到输出层权值  
    {  
        for (j=0; j<HN; j++)  
        {  
            deltaWeight = stuRate1 * errSignalON[i] * OUT_HN[j];//计算权值的改变量  
            V[i][j] += deltaWeight;                     //更新权值        
        }  
        HU_ON[i] += stuRate1 * errSignalON[i];          //更新输出层阈值  
    }  
  
    for (i=0; i<HN; i++)                             //调整隐层到输出层的权值  
    {  
        for (j=0; j<IN; j++)  
        {  
                                                        //权值改变量  
            deltaWeight = stuRate2 * errSignalHN[i] * studyData[m].input[j];  
            W[i][j] += deltaWeight;                     //更新权值  
        }  
        HU_HN[i] += stuRate2 * errSignalHN[i];          //更新隐层阈值  
    }  
}  
  
void BpNet::SaveBpNet(char *weight, char *threshold)  
{  
    //保存权值到指定的文件名weight内  
    //保存阈值到指定的文件名threshold内  
  
    ofstream outfile(weight, ios::out);                 //打开保存权值的文件  
    if (!outfile)  
    {  
        cerr << "打开权值文件失败" << endl;   
        exit(1);  
    }  
      
    int i, j;  
    for (i=0; i<HN; i++)                             //输入层到隐层的权值写入  
    {  
        for (j=0; j<IN; j++)  
        {  
            outfile << W[i][j] << " ";  
        }  
    }  
  
    for (i=0; i<ON; i++)                             //将输出层到隐层的权值写入  
    {  
        for (j=0; j<HN; j++)  
        {  
            outfile << V[i][j] << " ";                    
        }  
    }  
    outfile.close();                                    //关闭文件  
  
    ofstream outfile2(threshold, ios::out);             //打开阈值文件  
    if (!outfile2)  
    {  
        cerr << "阈值文件打开失败" << endl;  
        exit(1);  
    }  
  
    for (i=0; i<HN; i++)                             //写入隐层的阈值  
    {  
        outfile2 << HU_HN[i] << " ";  
    }  
    for (i=0; i<ON; i++)                             //写入输出层的阈值  
    {  
        outfile2 << HU_ON[i] << " ";  
    }  
    outfile2.close();                                   //关闭文件  
}  
  
void BpNet::ReadWeight(char *weight, char *threshold)  
{  
    //从训练好网络中读取权值、阈值等  
  
    ifstream infile1(weight, ios::in);                  //打开文件  
    if (!infile1)  
    {  
        cerr << "打开权值文件失败" << endl;  
        exit(1);  
    }  
      
    int i, j;  
    float temp;  
    for (i=0; i<HN; i++)                             //读取输入层权值到隐层权值  
    {  
        for (j=0; j<IN; j++)  
        {  
            if (infile1 >> temp)  
            {  
                W[i][j] = temp;  
            }  
        }  
    }  
  
    for (i=0; i<ON; i++)                             //读取输出层到隐层的权值  
    {  
        for (j=0; j<HN; j++)  
        {  
            if (infile1 >> temp)  
            {  
                V[i][j] = temp;   
            }  
        }  
    }  
    infile1.close();                                    //关闭权值文件  
  
    ifstream infile2(threshold, ios::in);               //打开阈值文件      
    if (!infile2)  
    {  
        cerr << "阈值文件打开失败" << endl;  
        exit(1);  
    }  
  
    for (i=0; i<HN; i++)                             //读取隐层阈值  
    {  
        if (infile2 >> temp)  
        {  
            HU_HN[i] = temp;  
        /*  cout << "隐层的阈值是" << HU_HN[i] << endl;*/  
        }     
    }  
    for (i=0; i<ON; i++)                             //读取输出层阈值  
    {  
        if (infile2 >> temp)  
        {  
            HU_ON[i] = temp;  
        /*  cout << "输出层的阈值是" << HU_ON[i] << endl;*/  
        }  
    }  
}  
  
double BpNet::GetSumErr()  
{  
    //求总误差，即所有样本的总误差  
    int m;  
    double sumErr = 0.0;  
    for (m=0; m<N; m++)  
    {  
        sumErr += E[m];  
    }  
  
    return sumErr;  
}  
  
void BpNet::Train(char *sampleFileName, char *weight, char *threshold)  
{  
    //对给定文件名sampleFileName提取样本数据进行训练  
    //训练达到一定的精度后将权值存于weight  
    //阈值存于threshold内  
    int limitStudyTimes = 400000;                       //限定内的学习次数  
    long int studyFileTimes = 0;                        //学习文件次数,即对sample整个文件学习一次，算一次  
    long int studySampleTimes = 0;                      //样本学习次数,一组样本学习一次算一次  
    double minErr = 0.000001;                           //最小的学习误差，达到这个精度后训练完毕  
    double sumErr;                                      //由实际训练得到的样本总误差  
    int m;                                              //表示sample文件第m组样本  
  
    StartShow();                                        //程序开始界面  
    cout << "现在是训练模式···" << endl;  
    GetTrainingData(sampleFileName);                    //读取样本数据到内存  
    do   
    {  
        studyFileTimes++;  
        for (m=0; m<N; m++)                              //N组样本进行学习训练,循环完毕即一个文件学习完毕  
        {  
            NetInputOutput(m);                          //算网络内部输入输出  
            ErrorSignal(m);                             //算误差信号  
            UpdateWeight(m);                            //调整权值  
        }  
  
        sumErr = GetSumErr();                           //所有样本的总误差    
  
        if (studyFileTimes > limitStudyTimes)            //超出学习的限定次数，估计收敛不了了，在下去就是无限循环，强制停止  
        {  
            cout << "超出限定的学习次数，超时了，强制停止程序" << endl;  
            break;  
        }  
        cout << "正在进行的训练次数: "<< studyFileTimes << "\r";  
  
  
    } while (sumErr > minErr);  
  
    SaveBpNet(weight, threshold);                       //保存权值、阈值  
  
    cout << "学习次数是:" << studyFileTimes << endl;  
    cout << "最后误差是" << sumErr << endl;  
    cout << "权值文件" << weight << "已成功保存" << endl;  
    cout << "阈值文件" << threshold << "已成功保存" << endl;  
}  
  
  
  
void BpNet::Work(char *weight, char *threshold)  
{  
    //将训练完毕后得到的权值用于工作  
    //从键盘输入数据，由神经网络输出结果  
  
    ReadWeight(weight, threshold);                      //读取文件中训练完毕的权值阈值到神经网络中  
    char flag;                                          //控制是否继续输入  
    int i;  
  
    cout << "现在是工作模式···" << endl;  
    while (1)  
    {  
        GetOutput();                                    //从键盘输入数据,神经网络的输出存于OUT_ON[]中  
                  
        for (i=0; i<ON; i++)  
        {  
            cout << "输出为:" << OUT_ON[i] << " ";  
        }  
        cout << endl;  
          
        cout << "你是否想要继续输入Y/N" << endl;  
        cin >> flag;  
        if ( ('n'==flag) || ('N'==flag) )  
        {  
            break;  
        }  
    }  
}  
  
void BpNet::GetOutput()  
{  
    //从键盘输入数据,神经网络的输出存于ON[]中  
      
    int i, j;  
    float sum = 0.0;  
    float input[IN];  
      
    cout << "请输入神经网络的" << IN << "个输入数据:(以空格隔开)" << endl;  
    for (i=0; i<IN; i++)                             //输入数据  
    {  
        cin >> input[i];  
    }  
      
    for (i=0; i<HN; i++)                             //求隐层的净输入输出  
    {  
        for (j=0; j<IN; j++)  
        {         
            sum += W[i][j] * input[j];                  //算隐层第i个神经元不包含阈值的输入  
        }                                     
        IN_HN[i] = sum + HU_HN[i];                      //算隐层第i个神经元的净输入  
        OUT_HN[i] = 1.0 / (1.0 + exp(-IN_HN[i]));       //算隐层第i个神经元的输出  
    }  
      
    sum = 0.0;  
    for (i=0; i<ON; i++)                             //求输出层的输入输出  
    {  
        for (j=0; j<HN; j++)  
        {  
            sum += V[i][j] * OUT_HN[j];                 //算输出层第i个神经元的输入(不含阈值)  
        }  
        IN_ON[i] = sum + HU_ON[i];                      //算输出层第i个神经元的净输入  
        OUT_ON[i] = 1.0 / (1.0 + exp(-IN_ON[i]));       //算输出层第i个神经元的输出  
    }  
}  

最后是main函数的内容，用来做一个异或运算的测试，内容如下：

sample1.txt内容如下：

0 0 0
0 1 1
1 0 1
1 1 0

表示异或运算的规则

#include "stdafx.h"  
#include "BpNet.h"  
  
int main(int argc, char* argv[])  
{  
    /*BP分为两大阶段的函数:用于训练的函数Train(),用于工作的函数Work()*/  
    BpNet bp;  
  
    /*对亦或样本进行训练*/  
  
//  bp.Train("sample1.txt", "weight1.txt", "yuzhi1.txt");  
  
    /*对亦或样本训练结果进行工作测试*/  
  
    bp.Work("weight1.txt","yuzhi1.txt");  
  
    return 0;  
}  

最后的测试结果图如下：