BP神经网络分类 keras BP神经网络分类器C语言

转载

梦里忧郁 2024-01-15 11:27:02

文章标签 BP神经网络分类 keras 网络 c float fp 文章分类 神经网络人工智能

在该题的程序设计中采用了文件相关的操作，记录了相关学习和测试信息数据。权值用伪随机数函数随机产生（范围是（0,0.5））

采用结构体及链表来实现神经网络的结构

分为实例结构体、层结构体和网络结构体

数据结构的设计参照了《人工神经网络原理》（马锐编著，北京：机械工业出版社，2010,7）一书

学习算法的优化也参照该书

采用学习效率自适应调整算法优化源程序的学习算法，以减少学习次数

由于能力和知识有限，该程序存在较大漏洞误差，在调整学习率时，不好掌握调节系数

初始权值的限定范围适中，则程序的学习次数将明显减少

在随机赋初始权值（0,0.5）时，学习次数可调节至135，但对测试数据的判别效果不理想，没有采用

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<malloc.h>
 
#define TRUE         1
#define FALSE        0
 
#define NUM_LAYERS   4
#define NUM          20        //训练实例个数
#define N            2         //输入层单元数
#define M            2         //输出层单元数
 
int Units[NUM_LAYERS] = {N,3,3,M};   //每层单元数
       FILE *fp,*fb;
 
typedef struct                //训练实例
{
       float x[N];
       float y[M];
}TRAIN;
 
typedef struct                //网络层结构
{
       int Units;               //该层中单元的个数
       float *Output;           //第 i 个单元的输出
       float *Error;            //第 i 个单元的校正误差
       float **Weight;          //第 i 个单元的连接权值
}LAYER;
 
typedef struct                        //网络
{
       LAYER **Layer;                     //隐层定义
       LAYER *Inputlayer;                 //输入层
       LAYER *Outputlayer;                //输出层
       float Error;                        //允许误差
       float Eta;                          //学习率
}NET;
 
//初始化伪随机数发生器
void InitializeRandoms()
{
       srand(4711);
       return;
}
 
//产生随机实数并规范化
float RandomReal()                      //产生(-0.5,0.5)之间的随机数
{
       return (float)((rand()%100)/200.0);
}
 
//初始化训练数据
void InitializeTrainingData(TRAIN *training)
{
       int i,j;
       char filename[20];
       printf("\n请输入训练实例的数据文件名: \n");
       gets(filename);
       fb = fopen(filename,"r");
       fprintf(fp,"\n\n--Saving initialization training datas ...\n");
       for(i=0;i<NUM;i++)
       {
              for(j=0;j<N;j++)
              {
                     fscanf(fb,"%f",&(training+i)->x[j]);
                     fprintf(fp,"%10.4f",(training+i)->x[j]);
              }
              for(j=0;j<M;j++)
              {
                     fscanf(fb,"%f",&(training+i)->y[j]);
                     fprintf(fp,"%10.4f",(training+i)->y[j]);
              }
              fprintf(fp,"\n");
       }
       fclose(fb);
       return;
}
 
//应用程序初始化
void InitializeApplication(NET *Net)
{
       Net->Eta = (float)0.3;
       Net->Error = (float)0.0001;
       fp = fopen("BPResultData.txt","w+");
       return;
}
 
//应用程序关闭时终止打开的文件
void FinalizeApplication(NET *Net)
{
       fclose(fp);
       return;
}
 
//分配内存,建立网络
void GenerateNetwork(NET *Net)
{
       int l,i;
       Net->Layer = (LAYER **)calloc(NUM_LAYERS,sizeof(LAYER *));
       for(l=0;l<NUM_LAYERS;l++)
       {
              Net->Layer[l] = (LAYER *)malloc(sizeof(LAYER));
              Net->Layer[l]->Units      = Units[l];
              Net->Layer[l]->Output     = (float *) calloc(Units[l]+1,sizeof(float));
              Net->Layer[l]->Error      = (float *) calloc(Units[l]+1,sizeof(float));
              Net->Layer[l]->Weight     = (float **)calloc(Units[l]+1,sizeof(float *));
              Net->Layer[l]->Output[0]  = 1;
              if(l != 0)
                     for(i=1;i <= Units[l];i++)                          //下标从"1"开始
                            Net->Layer[l]->Weight[i] = (float *)calloc(Units[l-1]+1,sizeof(float));
       }
       Net->Inputlayer  = Net->Layer[0];
       Net->Outputlayer = Net->Layer[NUM_LAYERS - 1];
       return;
}
 
//产生随机实数作为初始连接权值
void RandomWeights(NET *Net)
{
       int l,i,j;
       for(l=1;l<NUM_LAYERS;l++)
              for(i=1;i <= Net->Layer[l]->Units;i++)
                     for(j=0;j <= Net->Layer[l-1]->Units;j++)
                            Net->Layer[l]->Weight[i][j] = RandomReal();
       return;
}
 
//设置输入层的输出值
void SetInput(NET *Net,float *Input)
{
       int i;
       for(i=1;i <= Net->Inputlayer->Units;i++)
              Net->Inputlayer->Output[i] = Input[i-1];                          //输入层采用 u(x) = x
       return;
}
 
//设置输出层的输出值
void GetOutput(NET *Net,float *Output)
{
       int i;
       for(i=1;i <= Net->Outputlayer->Units;i++)
              Output[i-1] = (float)(1/(1 + exp(-Net->Outputlayer->Output[i])));         //输出层采用 f(x)=1/(1+e^(-x))
       return;
}
 
//层间顺传播
void PropagateLayer(NET *Net,LAYER *Lower,LAYER *Upper)
{
       int i,j;
       float sum;
       for(i=1;i <= Upper->Units;i++)
       {
              sum = 0;
              for(j=1;j <= Lower->Units;j++)
                     sum += (Upper->Weight[i][j] * Lower->Output[j]);
              Upper->Output[i] = (float)(1/(1 + exp(-sum)));
       }
       return;
}
 
//整个网络所有层间的顺传播
void PropagateNet(NET *Net)
{
       int l;
       for(l=0;l < NUM_LAYERS-1;l++)
              PropagateLayer(Net,Net->Layer[l],Net->Layer[l+1]);
       return;
}
 
//计算输出层误差
void ComputeOutputError(NET *Net,float *target)
{
       int i;
       float Out,Err;
       for(i=1;i <= Net->Outputlayer->Units;i++)
       {
              Out = Net->Outputlayer->Output[i];
              Err = target[i-1] - Out;
              Net->Outputlayer->Error[i] = Out*(1-Out)*Err;
       }
       return;
}
 
//层间逆传播
void BackpropagateLayer(NET *Net,LAYER *Upper,LAYER *Lower)
{
       int i,j;
       float Out,Err;
       for(i=1;i <= Lower->Units;i++)
       {
              Out = Lower->Output[i];
              Err = 0;
              for(j=1;j <= Upper->Units;j++)
                     Err += (Upper->Weight[j][i] * Upper->Error[j]);
              Lower->Error[i] = Out*(1-Out)*Err;
       }
       return;
}
 
//整个网络所有层间的逆传播
void BackpropagateNet(NET *Net)
{
       int l;
       for(l=NUM_LAYERS-1;l>1;l--)
              BackpropagateLayer(Net,Net->Layer[l],Net->Layer[l-1]);
       return;
}
 
//权值调整
void AdjustWeights(NET *Net)
{
       int l,i,j;
       float Out,Err;
       for(l=1;l<NUM_LAYERS;l++)
              for(i=1;i <= Net->Layer[l]->Units;i++)
                     for(j=0;j <= Net->Layer[l-1]->Units;j++)
                     {
                            Out = Net->Layer[l-1]->Output[j];
                            Err = Net->Layer[l]->Error[i];
                            Net->Layer[l]->Weight[i][j] += (Net->Eta*Err*Out);
                     }
       return;
}
 
//网络处理过程
void SimulateNet(NET *Net,float *Input,float *Output,float *target,int TrainOrNot)
{
       SetInput(Net,Input);                             //输入数据
       PropagateNet(Net);                               //模式顺传播
       GetOutput(Net,Output);                           //形成输出
       ComputeOutputError(Net,target);                  //计算输出误差
       if(TrainOrNot)
       {
              BackpropagateNet(Net);                       //误差逆传播
              AdjustWeights(Net);                          //调整权值
       }
       return;
}
 
//训练过程
void TrainNet(NET *Net,TRAIN *training)
{
       int l,i,j,k;
       int count=0,flag=0;
       float Output[M],outputfront[M],ERR,err,sum;
       do
       {
              flag = 0;
              sum = 0;
              ERR = 0;
              if(count >= 1)
                     for(j=0;j<M;j++)
                            outputfront[j]=Output[j];
              SimulateNet(Net,(training+(count%NUM))->x,Output,(training+(count%NUM))->y,TRUE);
              if(count >= 1)
              {
                     k = count%NUM;
                     for(i=1;i <= Net->Outputlayer->Units;i++)
                     {
                            sum += Net->Outputlayer->Error[i];
                            err = (training+k-1)->y[i-1] - outputfront[i-1];
                            ERR += (outputfront[i-1] * (1 - outputfront[i-1]) * err);
                     }
                     if(sum <= ERR)
                            Net->Eta = (float)(0.9999 * Net->Eta);
                     else
                            Net->Eta = (float)(1.0015 * Net->Eta);
 
              }
              if(count >= NUM)
              {
                     for(k=1;k <= M;k++)
                            if(Net->Outputlayer->Error[k] > Net->Error)
                            {   flag=1;     break;   }
                     if(k>M)
                            flag=0;
              }
              count++;
       }while(flag || count <= NUM);
       fprintf(fp,"\n\n\n");
       fprintf(fp,"--training results ... \n");
       fprintf(fp,"training times:   %d\n",count);
       fprintf(fp,"\n*****the final weights*****\n");
       for(l=1;l<NUM_LAYERS;l++)
       {
              for(i=1;i <= Net->Layer[l]->Units;i++)
              {
                     for(j=1;j <= Net->Layer[l-1]->Units;j++)
                            fprintf(fp,"%15.6f",Net->Layer[l]->Weight[i][j]);
                     fprintf(fp,"\n");
              }
              fprintf(fp,"\n\n");
       }
}
 
//评估过程
void EvaluateNet(NET *Net)
{
       int i;
       printf("\n\n(");
       fprintf(fp,"\n\n(");
       for(i=1;i <= Net->Inputlayer->Units;i++)
       {
              printf(" %.4f",Net->Inputlayer->Output[i]);
              fprintf(fp,"%10.4f",Net->Inputlayer->Output[i]);
       }
       printf(")\t");
       fprintf(fp,")\t");
       for(i=1;i <= Net->Outputlayer->Units;i++)
       {
              if(fabs(Net->Outputlayer->Output[i] - 1.0) <= 0.0499)
              {
                     printf("肯定是第 %d 类, ",i);
                     fprintf(fp,"肯定是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.9) <= 0.0499)
              {
                     printf("几乎是第 %d 类,  ",i);
                     fprintf(fp,"几乎是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.8) <= 0.0499)
              {
                     printf("极是第 %d 类, ",i);
                     fprintf(fp,"极是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.7) <= 0.0499)
              {
                     printf("很是第 %d 类, ",i);
                     fprintf(fp,"很是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.6) <= 0.0499)
              {
                     printf("相当是第 %d 类,  ",i);
                     fprintf(fp,"相当是第 %d 类,  ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.5) <= 0.0499)
              {
                     printf("差不多是第 %d 类, ",i);
                     fprintf(fp,"差不多是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.4) <= 0.0499)
              {
                     printf("比较像是第 %d 类, ",i);
                     fprintf(fp,"比较像是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.3) <= 0.0499)
              {
                     printf("有些像是第 %d 类, ",i);
                     fprintf(fp,"有些像是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.2) <= 0.0499)
              {
                     printf("有点像是第 %d 类, ",i);
                     fprintf(fp,"有点像是第 %d 类, ",i);
              }
              if(fabs(Net->Outputlayer->Output[i] - 0.1) <= 0.0499)
              {
                     printf("稍稍像是第 %d 类, ",i);
                     fprintf(fp,"稍稍像是第 %d 类, ",i);
              }
              if(Net->Outputlayer->Output[i] <= 0.0499)
              {
                     printf("肯定不是第 %d 类, ",i);
                     fprintf(fp,"肯定不是第 %d 类, ",i);
              }
       }
       printf("\n\n");
       fprintf(fp,"\n\n\n");
       return;
}
 
//测试过程
void TestNet(NET *Net)
{
       TRAIN Testdata;
       float Output[M];
       int i,j,flag=0;
       char select;
       fprintf(fp,"\n\n--Saving test datas ...\n");
       do
       {
              printf("\n请输入测试数据(x1 x2 ... y1 y2 ...): \n");
              for(j=0;j<N;j++)
              {
                     scanf("%f",&Testdata.x[j]);
                     fprintf(fp,"%10.4f",Testdata.x[j]);
              }
              for(j=0;j<M;j++)
              {
                     scanf("%f",&Testdata.y[j]);
                     fprintf(fp,"%10.4f",Testdata.y[j]);
              }
              fprintf(fp,"\n");
              SimulateNet(Net,Testdata.x,Output,Testdata.y,FALSE);
              fprintf(fp,"\n--NET Output and Error of the Test Data ....\n");
              for(i=1;i <= Net->Outputlayer->Units;i++)
                     fprintf(fp,"%10.6f  %10.6f\n",Net->Outputlayer->Output[i],Net->Outputlayer->Error[i]);
              EvaluateNet(Net);
              printf("\n继续测试?(y/n):\n");
              getchar();
              scanf("%c",&select);
              printf("\n");
              if((select == 'y')||(select == 'Y'))
                     flag = 1;
              else
                     flag=0;
       }while(flag);
       return;
}
 
//主函数
void main()
{
       TRAIN TrainingData[NUM];
       NET Net;
       InitializeRandoms();                                  //初始化伪随机数发生器
       GenerateNetwork(&Net);                                //建立网络
       RandomWeights(&Net);                                  //形成初始权值
       InitializeApplication(&Net);                          //应用程序初始化,准备运行
       InitializeTrainingData(TrainingData);                 //记录训练数据
       TrainNet(&Net,TrainingData);                          //开始训练
       TestNet(&Net);
       FinalizeApplication(&Net);                            //程序关闭,完成善后工作
       return;
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。