“程序设计与算法训练”课程设计：“BP神经网络的实现”（C++类封装实现）

一 题目：

71 BP神经网络的实现：

　　利用C++语言实现BP神经网络， 并利用BP神经网络解决螨虫分类问题：

　　蠓虫分类问题：对两种蠓虫（A与B）进行鉴别，依据的资料是触角和翅膀的长度，已知了9支Af和6支Apf 的数据如下：A: (1.24,1.27)， (1.36,1.74)，(1.38,1.64) ， (1.38,1.82) ， (1.38,1.90) ， (1.40,1.70) ， (1.48,1.82) ， (1.54,1.82) ，(1.56,2.08).B: (1.14,1.82)， (1.18,1.96)， (1.20,1.86)， (1.26,2.00)， (1.28,2.00)，(1.30,1.96).
　　要求：（1）阐述BP神经网络的结构构成及数学原理；

  （2）利用C++实现BP神经网络；

  （3）利用BP神经网络实现螨虫分类.

二 源代码：

　　头文件necessary.h：

#include<iostream>
#include<fstream>
#include<iomanip>
#include<stdlib.h>
#include<math.h>
#include<time.h>

#define SampleCount 15 //学习样本个数
#define INnum 2 //输入层神经元数目
#define HN 15//隐层神经元数目
#define ONnum 1 //输出层神经元数目

using namespace std;

　　头文件bp.h：

#ifndef BP_H
#define BP_H

#include "necessary.h"


class Back_propagation
{

public:
    Back_propagation();
    double W[HN][INnum]; //输入层至隐层权值
    double V[ONnum][HN]; //隐层至输出层权值
    double P[INnum]; //单个样本输入数据
    double T[ONnum]; //单个样本期望输出值

    double OLD_W[HN][INnum];  //保存HN-IN旧权！
    double OLD_V[ONnum][HN];  //保存ON-HN旧权！
    double HI[HN]; //隐层的输入
    double OI[ONnum]; //输出层的输入
    double hidenLayerOutput[HN]; //隐层的输出
    double OO[ONnum]; //输出层的输出
    double err_m[SampleCount]; //第m个样本的总误差
    double studyRate;//学习效率效率
    double b;//步长
    double e_err[HN];
    double d_err[ONnum];
    void input_p(int m);
    void input_t(int m);
    void H_I_O();
    void O_I_O();
    void Err_Output_Hidden(int m);
    void Err_Hidden_Input();
    void Adjust_O_H(int m,int n);
    void Adjust_H_I(int m,int n);
    void saveWV();
    struct
    {
        double input[INnum];
        double teach[ONnum];
    }Study_Data[SampleCount];
private:
};

#endif

　　源文件necessary.cpp：

#include "necessary.h"

　　源文件bp.cpp：

#include"bp.h"

Back_propagation::Back_propagation()
{


    srand( (unsigned)time( NULL ) );

    for( int i = 0; i < HN; i ++ )
    {
        for( int j = 0; j < INnum; j ++ )
        {
            W[i][j] = double( rand() % 100 ) / 100; //初始化输入层到隐层的权值    
        }
    }
    for( int ii = 0; ii < ONnum; ii ++ )
    {
        for( int jj = 0; jj < HN; jj ++ )
        {
            V[ii][jj] = double( rand() % 100 ) / 100;  //初始化隐层到输出层的权值
        }
    }
}

void Back_propagation::input_p(int m)
{
       for( int i = 0; i < INnum; i ++ )
    {
        P[i] = Study_Data[m].input[i];
    }
}

void Back_propagation::input_t(int m)
{
    for( int k = 0; k < ONnum; k ++ )
    {
        T[k] = Study_Data[m].teach[k];
    }
}

void Back_propagation::H_I_O()
{
    double net;
    int i,j;
    for( j = 0; j < HN; j ++ )
    {
        net = 0;
        for( i = 0; i < INnum; i ++ )
        {
            net += W[j][i] * P[i];//求隐层内积    
        }
        HI[j] = net;// - Thread_Hiden[j];//求隐层输入
        hidenLayerOutput[j] = 1.0 / ( 1.0 + exp(-HI[j]) );//求隐层输出 
    }
}

void Back_propagation::O_I_O()
{
    double net;
    int k,j;
    for( k = 0; k < ONnum; k ++ )
    {
        net = 0;
        for( j = 0; j < HN; j ++ )
        {
            net += V[k][j] * hidenLayerOutput[j];//求输出层内积
        }
        OI[k] = net; //求输出层输入
        OO[k] = 1.0 / ( 1.0 + exp(-OI[k]) );//求输出层输出
    }
}

void Back_propagation::Err_Output_Hidden( int m )
{
    double abs_err[ONnum];//样本误差
    double sqr_err = 0;//临时保存误差平方
    
    for( int k = 0; k < ONnum; k ++ )
    {
        abs_err[k] = T[k] - OO[k];    //求第m个样本下的第k个神经元的绝对误差

        sqr_err += (abs_err[k]) * (abs_err[k]);//求第m个样本下输出层的平方误差

        d_err[k] = abs_err[k] * OO[k] * (1.0-OO[k]);//d_err[k]输出层各神经元的一般化误差
    }
    err_m[m] = sqr_err / 2;//第m个样本下输出层的平方误差/2=第m个样本的均方误差,据ppt1.5-3

}

void Back_propagation::Err_Hidden_Input()
{
  double sigma;
  for( int j = 0; j < HN; j ++ ) 
  {
     sigma = 0.0;
     for( int k = 0; k < ONnum; k ++ ) 
     {
        sigma += d_err[k] * V[k][j];  
     }

     e_err[j] = sigma * hidenLayerOutput[j] * ( 1 - hidenLayerOutput[j] );//隐层各神经元的一般化误差
  }
}

void Back_propagation::Adjust_O_H( int m,int n )
{
    if( n <= 1 )
    {
        for( int k = 0; k < ONnum; k ++ )
        {
            for( int j = 0; j < HN; j ++ )
            {
                V[k][j] = V[k][j] + studyRate * d_err[k] * hidenLayerOutput[j];//输出层至隐层的权值调整
            }
        }
    }
    else if( n > 1 )
    {
        for( int k = 0; k < ONnum; k ++ )
        {
            for( int j = 0; j < HN; j ++ )
            {
                V[k][j] = V[k][j] + studyRate * d_err[k] * hidenLayerOutput[j] + b * ( V[k][j] - OLD_V[k][j] );//输出层至隐层的权值调整
            }
        }
    }
}

void Back_propagation::Adjust_H_I( int m,int n )
{
    if( n <= 1 )
    {
        for( int j = 0; j < HN; j ++ )
        {
            for ( int i = 0; i < INnum; i ++ ) 
            {
                W[j][i] = W[j][i] + studyRate * e_err[j] * P[i];//隐层至输入层的权值调整
            }
        }

    }
    else if( n > 1 )
    {
        for( int j = 0; j < HN; j ++ )
        {
            for( int i = 0; i < INnum; i ++ ) 
            {
                W[j][i] += studyRate * e_err[j] * P[i] + b * ( W[j][i] - OLD_W[j][i] );//隐层至输入层的权值调整
            }
        }
    }
}

void Back_propagation::saveWV()
{
    for( int i = 0; i < HN; i ++ )
    {
        for( int j = 0; j < INnum; j ++ )
        {
            OLD_W[i][j] = W[i][j];
        }
    }

    for( int ii = 0; ii < ONnum; ii ++ )
    {
        for( int jj = 0; jj < HN; jj ++ )
        {
            OLD_V[ii][jj] = V[ii][jj];
        }
    }
}

　　源文件main.cpp：

#include "bp.h"

void saveWV( Back_propagation bp )
{
    for( int i = 0; i < HN; i ++ )
    {
        for( int j = 0; j < INnum; j ++ )
        {
            bp.OLD_W[i][j] = bp.W[i][j];
        }
    }

    for( int ii = 0; ii < ONnum; ii ++ )
    {
        for( int jj = 0; jj < HN; jj ++ )
        {
            bp.OLD_V[ii][jj] = bp.V[ii][jj];
        }
    }
}

//保存数据
void savequan( Back_propagation bp )
{
    ofstream outW( "w.txt" );
    ofstream outV( "v.txt" );
    
    for( int i = 0; i < HN; i ++ )
    {
        for( int j = 0; j < INnum; j ++ )
        {
            outW << bp.W[i][j] << "   ";        
        }
        outW << "
";
    }

    for( int ii = 0; ii < ONnum; ii ++ )
    {
        for( int jj = 0; jj < HN; jj ++ )
        {
            outV << bp.V[ii][jj] << "   ";
        }
        outV << "
";
    }


    outW.close();
    outV.close();

}

double Err_Sum( Back_propagation bp )
{
    double total_err = 0;
    for ( int m = 0; m < SampleCount; m ++ ) 
    {
      total_err += bp.err_m[m];//每个样本的均方误差加起来就成了全局误差
    }
    return total_err;
}

int main()
{
    double sum_err;
    int study;
    int m;
    double check_in, check_out;
    ifstream Train_in( "trainin.txt", ios::in );
    ifstream Train_out( "trainout.txt", ios::in );

    if( ( Train_in.fail() ) || ( Train_out.fail() ) )
    {
        //printf( "Error input file!
" );
        cerr << "Error input file!" << endl;
        exit(0);
    }

    Back_propagation bp;

    cout << "请输入学习效率: studyRate = ";
    cin >> bp.studyRate;

    cout << "
请输入步长: b= ";
    cin >> bp.b;

    study = 0;
    double Pre_error ; //预定误差
    cout << "
请输入预定误差: Pre_error = ";
    cin >> Pre_error;

    int Pre_times;
    cout << "
请输入预定最大学习次数:Pre_times=";
    cin >> Pre_times;

    for( m = 0; m < SampleCount; m ++ )
    {
        for( int i = 0; i < INnum; i ++ )
        {
            Train_in >> bp.Study_Data[m].input[i];
        }
    }
 
    cout << endl;
    for( m = 0; m < SampleCount; m ++ )
    {
        for( int k = 0; k < ONnum; k ++ )
        {
           Train_out >> bp.Study_Data[m].teach[k];
        }
    }
    
    cout << endl;

    do
    {
        ++ study;
        if( study > Pre_times )
        {
            cout << "训练失败！" << endl;
            break;
        }

        for ( int m = 0; m < SampleCount; m ++ ) 
        {
            bp.input_p(m); //输入第m个学习样本 (2)
            bp.input_t(m);//输入第m个样本的教师信号 (3)
            bp.H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
            bp.O_I_O();
            bp.Err_Output_Hidden(m); //第m个学习样本输出层至隐层一般化误差 (6) 
            bp.Err_Hidden_Input(); //第m个学习样本隐层至输入层一般化误差 (7)
            bp.Adjust_O_H(m,study);
            bp.Adjust_H_I(m,study);
            if( m == 0 )
            {
                cout << bp.V[0][0] << " " << bp.V[0][1] << endl;
            }
        }//全部样本训练完毕
        sum_err = Err_Sum(bp); //全部样本全局误差计算 (10)
        bp.saveWV();
    }while( sum_err > Pre_error ); 

    if( ( study <= Pre_times ) & ( sum_err < Pre_error ) )
    {
        cout << "训练结束！" << endl;
        cout << "你已经学习了 " << study << "次" << endl;
    }
    double net;
    int k, j;
    while(1)
    {
        printf( "请输入蠓虫的触角及翅膀的长度:" );
        cin >> check_in;
        cin >> check_out;
        bp.P[0] = check_in;
        bp.P[1] = check_out;
        bp.H_I_O();
        for ( k = 0; k < ONnum; k ++ )
        {
            net = 0;
            for( j = 0; j < HN; j ++ )
            {
                net += bp.V[k][j] * bp.hidenLayerOutput[j];//求输出层内积
            }
            bp.OI[k] = net; //求输出层输入
            bp.OO[k] = 1.0 / ( 1.0 + exp(-bp.OI[k]) );//求输出层输出
        }
        if( bp.OO[0] > 0.5 )
        {
            printf( "该蠓虫是af!
" );
        }
        else if( bp.OO[0] >= 0 )
        {
            printf( "该蠓虫是apf!
" );
        }
    }
    return 0;
}

三 测试文件：

　　文件trainin.txt：

1.24 1.27
1.36 1.74
1.38 1.64
1.38 1.82
1.38 1.90
1.40 1.70
1.48 1.82
1.54 1.82
1.56 2.08
1.14 1.82
1.18 1.96
1.20 1.86
1.26 2.00
1.28 2.00
1.30 1.96

　　文件trainout.txt：

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

四 实验结果：

图1 输入数据

 

图2 测试算法“学习”结果

附录：

　　题目里面既有“螨（音mǎn）虫”，也有“蠓（音měng）虫”，程序里面用的是“蠓虫”。

参考文献：

[1]甘刚.BP算法在IDS中应用与实现的研究[J].成都：电子科技大学，硕博学位论文，2005.