BP神经网络算法实现 C++

其他 2018-09-22 23:36:56 阅读次数: 0

BP神经网络基本原理：

误差逆传播(back propagation, BP)算法是一种计算单个权值变化引起网络性能变化的较为简单的方法。由于BP算法过程包含从输出节点开始，反向地向第一隐含层(即最接近输入层的隐含层)传播由总误差引起的权值修正，所以称为“反向传播”。
BP神经网络是有教师指导训练方式的多层前馈网络，其基本思想是：从网络输入节点输入的样本信号向前传播，经隐含层节点和输出层节点处的非线性函数作用后，从输出节点获得输出。若在输出节点得不到样本的期望输出，则建立样本的网络输出与其期望输出的误差信号，并将此误差信号沿原连接路径逆向传播，去逐层修改网络的权值和节点处阈值，这种信号正向传播与误差信号逆向传播修改权值和阈值的过程反复进行，直训练样本集的网络输出误差满足一定精度要求为止。

以下是使用C/C++（大多数是C语言代码，只有数据读取部分是C++）完成的一个实际案例。

要求：

将Iris（鸢尾花）数据集分为训练集（Iris-train.txt）和测试集（Iris-test.txt），分别含75个样本，每个集合中每种花各有25个样本。为了方便训练，将3类花分别编号为1，2，3 。使用这些数据训练一个4输入（分别对应4个特征）、隐含层（10个神经元）、3输出（分别对应该样本属于某一品种的可能性大小）的神经网络（4103）。

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <string>
#include <fstream>
#include <iomanip>
using namespace std; 

#define innode 4//输入层结点数
#define hidenode 10//隐层结点数
#define outnode 3//输出层结点数
#define trainsample 75//训练样本数
#define testsample 75//测试样本数

double trainData[trainsample][innode];//输入样本
double outData[trainsample][outnode];//输出样本

double testData[testsample][innode];//测试样本

double w[innode][hidenode];//输入层到隐层的权值
double w1[hidenode][outnode];//隐层到输出层的权值
double b1[hidenode];//隐层阈值
double b2[outnode];//输出层阈值

double e=0.0;//误差计算
double error=1.0;//允许的最大误差

double rate_w=0.9;//输入层到隐层的学习率
double rate_w1=0.9;//隐层到输出层的学习率
double rate_b1=0.9;//隐层阈值学习率
double rate_b2=0.9;//输出层阈值学习率

double result[outnode];//bp输出

//初始化函数
void init(double w[], int n);
//Bp训练函数
void train(double trainData[trainsample][innode], double label[trainsample][outnode]);
//Bp识别 
double *recognize(double *p);
//从文件夹读取数据
void readData(std::string filename, double data[][innode], int x);
//数据归一化处理
void changeData(double data[][innode], int x);

int main()
{
    int i,j;
    int trainNum=0;//样本训练次数
    double *r; //测试结果
    int count=0;//正确测试结果数
    double maxRate = 1.0;//输出结果中的最大概率
    //对权值和阈值进行初始化
    init((double*)w, innode*hidenode);       //double *表示指向double型的指针，w为输入层到隐层的权值数组，innode*hidenode=4*10=40
    init((double*)w1, hidenode*outnode);
    init(b1, hidenode);    //b1为隐层阈值，hidenode为隐层结点数
    init(b2, outnode);	  //b2为输出层阈值，outnode为输出层结点数

    //读取训练数据
    readData("./Iris-train.txt", trainData, trainsample);
    //对训练数据进行归一化处理
    changeData(trainData, trainsample);

  for(i=0; i<trainsample; i++)    //trainsample为测试样本数
    {
        printf("%d: ",i+1);
        for(j=0; j<innode; j++)
            printf("%5.2lf",trainData[i][j]);
        printf("\n");
    }
  
    //准备输出样本——3类花，每类花有25个样本
    for(i=0; i<trainsample; i++)
    {
        if(i<25)
        {
            outData[i][0] = 1;
            outData[i][1] = 0;
            outData[i][2] = 0;
        }
        else if(i<50)
        {
            outData[i][0] = 0;
            outData[i][1] = 1;
            outData[i][2] = 0;
        }
        else
        {
            outData[i][0] = 0;
            outData[i][1] = 0;
            outData[i][2] = 1;
        }
    }

    printf("开始训练\n");
    while(trainNum < 10000)    //trainNum为样本训练次数
    {
        e = 0.0;                 //e为误差
        trainNum++;
        train(trainData, outData);      //BP训练
        printf("训练第%d次， error=%8.4lf\n", trainNum, error);
    }
    printf("训练完成\n\n");

    //读入测试数据
    readData("./Iris-test.txt", testData, testsample);
    //归一化测试数据
    changeData(testData, testsample);
    for(i=0; i<testsample; i++)
    {
        r = recognize(testData[i]);
        for(j=0; j<outnode; j++)
            printf("\t%7.4lf\t",r[j]);
        printf("\n");
        //判断检测结果是否正确
        if(i<25 && r[0]>r[1] && r[0]>r[2])
            count++;
        if(i>=25 && i<50 && r[1]>r[0] && r[1]>r[2])
            count++;
        if(i>=50 && r[2]>r[0] && r[2]>r[1])
            count++;
    }

    printf("\n\n共有%d个检测样本， 正确检测出%d个， 准确率: %7.4lf\n\n",testsample, count, (double)count/testsample);
    system("pause");
    system("pause");
    return 0;
}

//初始化函数（0到1之间的数）
void init(double w[], int n)
{
    int i;
    srand((unsigned int)time(NULL));    //这个是种子函数srand（）为rand函数提供不同的种子，每次运行程序产生不同的随机数，不然rand函数每次运行程序产生的随机数都是一样的
    for(i=0; i<n; i++)
    {
        w[i] = 2.0*((double)rand()/RAND_MAX)-1;     //RAND_MAX 是 <stdlib.h> 中伪随机数生成函数 rand 所能返回的最大数值。
																				 //这意味着，任何一次对 rand 的调用，都将得到一个 0~RAND_MAX 之间的伪随机数。RAND_MAX=0x7fff
    }
}

//BP训练函数
void train(double trainData[trainsample][innode], double label[trainsample][outnode])
{
    double x[innode];//输入层的输入值
    double yd[outnode];//期望的输出值

    double o1[hidenode];//隐层结点激活值
    double o2[hidenode];//输出层结点激活值
    double x1[hidenode];//隐层向输出层的输入
    double x2[outnode];//输出结点的输出
    /*********************************************************************
    o1: 隐层各结点的激活值等于与该结点相连的各路径上权值与该路径上的输入相乘后全部相加
    **********************************************************************
    x1: 隐层结点的输出，计算出o1后才能计算x1，等于 1.0/(1.0 + exp-(激活值+该结点的阈值))
    ***********************************************************************
    o2: 输出层结点的激活值等于与该结点相连的各路径上的权值与该路径的输入相乘后全部相加
    ***********************************************************************
    x2: 输出层结点的输出，计算出o2后才能计算x2，等于 1.0/(1.0 + exp-(激活值+该结点的阈值))
    ***********************************************************************/

    /*从前往后——输出单元偏差qq计算方式：  （期望输出 - 实际输出）乘上 实际输出 乘上 （1-实际输出）  */
    double qq[outnode];//期望的输出与实际输出的偏差

    double pp[hidenode];//隐含结点校正误差


    int issamp;
    int i,j,k;
    for(issamp=0; issamp<trainsample; issamp++)
    {
        for(i=0; i<innode; i++)
            x[i] = trainData[issamp][i];

        for(i=0; i<outnode; i++)
            yd[i] = label[issamp][i];

        //计算隐层各结点的激活值和隐层的输出值
        for(i=0; i<hidenode; i++)
        {
            o1[i] = 0.0;
            for(j=0; j<innode; j++)
                o1[i] = o1[i]+w[j][i]*x[j];              //w[][]为输入层到隐含层的网络权重，o1是隐层结点激活值
            x1[i] = 1.0/(1.0+exp(-o1[i]-b1[i]));  //x1是隐含层的输出
        }

        //计算输出层各结点的激活值和输出值
        for(i=0; i<outnode; i++)
        {
            o2[i] = 0.0;
            for(j=0; j<hidenode; j++)
                o2[i] = o2[i]+w1[j][i]*x1[j];                //w1[][]为隐层到输出层的权值，o2为输出层结点激活值
            x2[i] = 1.0/(1.0+exp(-o2[i]-b2[i]));        //x2为输出结点的输出
        }

        //得到了x2输出后接下来就要进行反向传播了

        //计算实际输出与期望输出的偏差，反向调节隐层到输出层的路径上的权值
        for(i=0; i<outnode; i++)
        {
            qq[i] = (yd[i]-x2[i]) * x2[i] * (1-x2[i]);      //输出节点j的偏差
            for(j=0; j<hidenode; j++)
                w1[j][i] = w1[j][i]+rate_w1*qq[i]*x1[j];   //隐层到输出层的路径上的权值
        }

        //继续反向传播调整输出层到隐层的各路径上的权值
        for(i=0; i<hidenode; i++)
        {
            pp[i] = 0.0;
            for(j=0; j<outnode; j++)
                pp[i] = pp[i]+qq[j]*w1[i][j];     
            pp[i] = pp[i]*x1[i]*(1.0-x1[i]);      //隐含层节点i的偏差

            for(k=0; k<innode; k++)
                w[k][i] = w[k][i] + rate_w*pp[i]*x[k];  //输出层到隐层的各路径上的权值
        }

        //调整允许的最大误差
        for(k=0; k<outnode; k++)  
        {  
            e+=fabs(yd[k]-x2[k])*fabs(yd[k]-x2[k]); //计算均方差  
        }  
        error=e/2.0; 

        //调整输出层各结点的阈值
        for(k=0; k<outnode; k++)  
            b2[k]=b2[k]+rate_b2*qq[k];

        //调整隐层各结点的阈值
        for(j=0; j<hidenode; j++)  
            b1[j]=b1[j]+rate_b1*pp[j];
    }
}

//Bp识别
double *recognize(double *p)
{
    double x[innode];//输入层的个输入值
    double o1[hidenode];//隐层结点激活值
    double o2[hidenode];//输出层结点激活值
    double x1[hidenode];//隐层向输出层的输入
    double x2[outnode];//输出结点的输出

    int i,j,k;

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

    for(j=0;j<hidenode;j++)  
    {  
        o1[j]=0.0;  
        for(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])); //隐含层各单元输出  
    }  

    for(k=0;k<outnode;k++)  
    {  
        o2[k]=0.0;  
        for(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]));//输出层各单元输出   
    }  

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

//从文件夹读取数据
void readData(std::string filename, double data[][innode], int x)
{
    ifstream inData(filename, std::ios::in);
    int i,j;
    double dataLabel;
    for(i=0; i<x; i++)
    {
        for(j=0; j<innode; j++)
        {
            inData >>data[i][j];
        }
        inData >>dataLabel;
    }
    inData.close();
}

//数据归一化处理——就是把数变为（0，1）之间的小数，主要是为了数据处理方便
void changeData(double data[][innode], int x)
{
    //归一化公式:(x-min)/(max-min)  
    double minNum,maxNum;
    int i,j;
    minNum = data[0][0];
    maxNum = data[0][0];
    //找最大最小值
    for(i=0; i<x; i++)
    {
        for(j=0; j<innode; j++)
        {
            if(minNum > data[i][j])
                minNum = data[i][j];
            if(maxNum < data[i][j])
                maxNum = data[i][j];
        }
    }
    //归一化
    for(i=0; i<x; i++)
    {
        for(j=0; j<innode; j++)
            data[i][j] = (data[i][j]-minNum)/(maxNum-minNum);
    }
}

训练数据：Iris-train.txt

5.1 3.5 1.4 0.2 0 
4.9 3.0 1.4 0.2 0 
4.7 3.2 1.3 0.2 0 
4.6 3.1 1.5 0.2 0 
5.0 3.6 1.4 0.2 0 
5.4 3.9 1.7 0.4 0 
4.6 3.4 1.4 0.3 0 
5.0 3.4 1.5 0.2 0 
4.4 2.9 1.4 0.2 0 
4.9 3.1 1.5 0.1 0 
5.4 3.7 1.5 0.2 0 
4.8 3.4 1.6 0.2 0 
4.8 3.0 1.4 0.1 0 
4.3 3.0 1.1 0.1 0 
5.8 4.0 1.2 0.2 0 
5.7 4.4 1.5 0.4 0 
5.4 3.9 1.3 0.4 0 
5.1 3.5 1.4 0.3 0 
5.7 3.8 1.7 0.3 0 
5.1 3.8 1.5 0.3 0 
5.4 3.4 1.7 0.2 0 
5.1 3.7 1.5 0.4 0 
4.6 3.6 1.0 0.2 0 
5.1 3.3 1.7 0.5 0 
4.8 3.4 1.9 0.2 0 
7.0 3.2 4.7 1.4 1 
6.4 3.2 4.5 1.5 1 
6.9 3.1 4.9 1.5 1 
5.5 2.3 4.0 1.3 1 
6.5 2.8 4.6 1.5 1 
5.7 2.8 4.5 1.3 1 
6.3 3.3 4.7 1.6 1 
4.9 2.4 3.3 1.0 1 
6.6 2.9 4.6 1.3 1 
5.2 2.7 3.9 1.4 1 
5.0 2.0 3.5 1.0 1 
5.9 3.0 4.2 1.5 1 
6.0 2.2 4.0 1.0 1 
6.1 2.9 4.7 1.4 1 
5.6 2.9 3.6 1.3 1 
6.7 3.1 4.4 1.4 1 
5.6 3.0 4.5 1.5 1 
5.8 2.7 4.1 1.0 1 
6.2 2.2 4.5 1.5 1 
5.6 2.5 3.9 1.1 1 
5.9 3.2 4.8 1.8 1 
6.1 2.8 4.0 1.3 1 
6.3 2.5 4.9 1.5 1 
6.1 2.8 4.7 1.2 1 
6.4 2.9 4.3 1.3 1 
6.3 3.3 6.0 2.5 2 
5.8 2.7 5.1 1.9 2 
7.1 3.0 5.9 2.1 2 
6.3 2.9 5.6 1.8 2 
6.5 3.0 5.8 2.2 2 
7.6 3.0 6.6 2.1 2 
4.9 2.5 4.5 1.7 2 
7.3 2.9 6.3 1.8 2 
6.7 2.5 5.8 1.8 2 
7.2 3.6 6.1 2.5 2 
6.5 3.2 5.1 2.0 2 
6.4 2.7 5.3 1.9 2 
6.8 3.0 5.5 2.1 2 
5.7 2.5 5.0 2.0 2 
5.8 2.8 5.1 2.4 2 
6.4 3.2 5.3 2.3 2 
6.5 3.0 5.5 1.8 2 
7.7 3.8 6.7 2.2 2 
7.7 2.6 6.9 2.3 2 
6.0 2.2 5.0 1.5 2 
6.9 3.2 5.7 2.3 2 
5.6 2.8 4.9 2.0 2 
7.7 2.8 6.7 2.0 2 
6.3 2.7 4.9 1.8 2 
6.7 3.3 5.7 2.1 2

测试数据：Iris-test.txt

5.0 3.0 1.6 0.2 0 
5.0 3.4 1.6 0.4 0 
5.2 3.5 1.5 0.2 0 
5.2 3.4 1.4 0.2 0 
4.7 3.2 1.6 0.2 0 
4.8 3.1 1.6 0.2 0 
5.4 3.4 1.5 0.4 0 
5.2 4.1 1.5 0.1 0 
5.5 4.2 1.4 0.2 0 
4.9 3.1 1.5 0.1 0 
5.0 3.2 1.2 0.2 0 
5.5 3.5 1.3 0.2 0 
4.9 3.1 1.5 0.1 0 
4.4 3.0 1.3 0.2 0 
5.1 3.4 1.5 0.2 0 
5.0 3.5 1.3 0.3 0 
4.5 2.3 1.3 0.3 0 
4.4 3.2 1.3 0.2 0 
5.0 3.5 1.6 0.6 0 
5.1 3.8 1.9 0.4 0 
4.8 3.0 1.4 0.3 0 
5.1 3.8 1.6 0.2 0 
4.6 3.2 1.4 0.2 0 
5.3 3.7 1.5 0.2 0 
5.0 3.3 1.4 0.2 0 
6.6 3.0 4.4 1.4 1 
6.8 2.8 4.8 1.4 1 
6.7 3.0 5.0 1.7 1 
6.0 2.9 4.5 1.5 1 
5.7 2.6 3.5 1.0 1 
5.5 2.4 3.8 1.1 1 
5.5 2.4 3.7 1.0 1 
5.8 2.7 3.9 1.2 1 
6.0 2.7 5.1 1.6 1 
5.4 3.0 4.5 1.5 1 
6.0 3.4 4.5 1.6 1 
6.7 3.1 4.7 1.5 1 
6.3 2.3 4.4 1.3 1 
5.6 3.0 4.1 1.3 1 
5.5 2.5 4.0 1.3 1 
5.5 2.6 4.4 1.2 1 
6.1 3.0 4.6 1.4 1 
5.8 2.6 4.0 1.2 1 
5.0 2.3 3.3 1.0 1 
5.6 2.7 4.2 1.3 1 
5.7 3.0 4.2 1.2 1 
5.7 2.9 4.2 1.3 1 
6.2 2.9 4.3 1.3 1 
5.1 2.5 3.0 1.1 1 
5.7 2.8 4.1 1.3 1 
7.2 3.2 6.0 1.8 2 
6.2 2.8 4.8 1.8 2 
6.1 3.0 4.9 1.8 2 
6.4 2.8 5.6 2.1 2 
7.2 3.0 5.8 1.6 2 
7.4 2.8 6.1 1.9 2 
7.9 3.8 6.4 2.0 2 
6.4 2.8 5.6 2.2 2 
6.3 2.8 5.1 1.5 2 
6.1 2.6 5.6 1.4 2 
7.7 3.0 6.1 2.3 2 
6.3 3.4 5.6 2.4 2 
6.4 3.1 5.5 1.8 2 
6.0 3.0 4.8 1.8 2 
6.9 3.1 5.4 2.1 2 
6.7 3.1 5.6 2.4 2 
6.9 3.1 5.1 2.3 2 
5.8 2.7 5.1 1.9 2 
6.8 3.2 5.9 2.3 2 
6.7 3.3 5.7 2.5 2 
6.7 3.0 5.2 2.3 2 
6.3 2.5 5.0 1.9 2 
6.5 3.0 5.2 2.0 2 
6.2 3.4 5.4 2.3 2 
5.9 3.0 5.1 1.8 2

程序运行结果：

在这里插入图片描述

注意：1.训练数据和测试数据的文件命名为lris-train、lris-test，不要加上.txt；
2.两个txt文件要放在跟源文件同目录下。
在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/weixin_43202635/article/details/82734432
今日推荐
周排行
四大线程池详解
如何高效使用Vim
Mogodb的常用操作总结
Spyder默认页面布局调整
SAR日志分析
OAuth是一个关于授权（authorization）的开放网络标准，在全世界得到广泛应用，目前的版本是2.0版。 本文对OAuth 2.0的设计思路和运行流程，做一个简明通俗的解释，主要参考材料为R
WebService中注解开发，CXF，Spring整合，Rest风格
2019考研英语一 Text1分析
windows下安装docker详细步骤
CentOS 7/6系统升级内核版本到5.2.2
每日归档
更多
2024-08-05(0)
2024-08-04(0)
2024-08-03(0)
2024-08-02(0)
2024-08-01(0)
2024-07-31(0)
2024-07-30(0)
2024-07-29(0)
2024-07-28(0)
2024-07-27(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022