bp.c

用RBF实现的目标图象识别程序,C实现,可以应用于DSP系统.

#include <stdlib.h> 
#include <math.h>
#include <string.h> 
#include <time.h> 
#include <stdio.h>

#include "BP.h"

#pragma DATA_SECTION(P, ".INTPROCBUFF");
#pragma DATA_ALIGN(P,128);
double P[7];//单个样本输入数据

#pragma DATA_SECTION(D, ".INTPROCBUFF");
#pragma DATA_ALIGN(D,128);
double D[OUT];//单个样本教师数据

#pragma DATA_SECTION(W, ".INTPROCBUFF");
#pragma DATA_ALIGN(W,128);
double W[10][7];//输入层至隐层权值

#pragma DATA_SECTION(V, ".INTPROCBUFF");
#pragma DATA_ALIGN(V,128);
double V[3][10];//隐层至输出层权值

#pragma DATA_SECTION(X, ".INTPROCBUFF");
#pragma DATA_ALIGN(X,128);
double X[10];//隐层的输入＝输入层的输出

#pragma DATA_SECTION(Y, ".INTPROCBUFF");
#pragma DATA_ALIGN(Y,128);
double Y[3]; //输出层的输入＝隐层的输出       

#pragma DATA_SECTION(H, ".INTPROCBUFF");
#pragma DATA_ALIGN(H,128);
double H[10];//隐层的输出＝输出层的输入H

#pragma DATA_SECTION(O, ".INTPROCBUFF");
#pragma DATA_ALIGN(O,128);
double O[3];//输出层的输出

#pragma DATA_SECTION(sita, ".INTPROCBUFF");
#pragma DATA_ALIGN(sita,128);
double sita[10];//隐层的阈值

#pragma DATA_SECTION(gama, ".INTPROCBUFF");
#pragma DATA_ALIGN(gama,128);
double gama[3]; //输出层的阈值

#pragma DATA_SECTION(err_m, ".INTPROCBUFF");
#pragma DATA_ALIGN(err_m,128);
double err_m[6];//第m个样本的总误差
  
double ita=0.01; //输出层至隐层的学习效率
double beta=0.005; //隐层至输入层学习效率
double delta[OUT];
double e_err1[HN];
double  sum_err,sigma,Pre_err=0.05,abs_err[OUT];//预定误差
double  sqr_err=0,total_err=0;//每个样本的平方误差、绝对误差计算都是从0开始的
int     study=0, Pre_times=5000,i,j,m,k;//训练次数 //预定最大学习次数
		double  traindata[N][IN]={
				{9.8110,20.4342,22.7633,22.4481,45.1707,32.6502,44.9360},
				{10.6677,21.2930,24.6907,24.6288,49.2377,35.2753,47.4063},
				{10.3338,20.6956,22.6669,23.1986,46.4295,33.5463,44.4628},
				{11.9899,23.9757,28.8088,29.4443,58.8868,41.4321,56.2600},
				{11.1991,22.4173,26.3123,26.2892,52.5885,37.4978,49.2577},
				{12.2879,24.5794,31.2586,31.1897,62.3814,43.4794,58.3585}};
			
                
	double outteachdata[N][OUT]={{0.9,0.1,0.1},
								{0.9,0.1,0.1},
								{0.9,0.1,0.1},
								{0.9,0.1,0.1},
								{0.9,0.1,0.1},
								{0.9,0.1,0.1}};
		/*double outteachdata[N][OUT]={{1,1,1},{1,1,0},{1,1,1},{0,0,0},{1,1,0},
								{0,0,0},};*/
	
#pragma CODE_SECTIONT(bprecognise,".text1")
void bprecognise()
{ 
             /******隐层权、阈值初始化******/
   for(j=0;j<HN;j++)
    { 
      sita[j]=rand()/RAND_MAX;
      for(i=0;i<IN;i++)
      {      
         W[j][i]=rand()/RAND_MAX;
      }
   } 
              /******输出层权、阈值初始化******/
   for (k=0;k<OUT;k++)
    { 
       gama[k]=rand()/RAND_MAX;
       for (j=0;j<HN;j++)
       {     
         V[k][j]=rand()/RAND_MAX;
       }
    }    
     ////****开始进行大循环****////////

do
{  //sum_err=0;
   study++; 
   total_err=0;       //double total_err=0;

  for(m=0;m<N;m++)           //样本开始输入训练
  {   
     for(k=0;k<IN;k++)          //第m个样本输入子程序
        P[k]=traindata[m][k];       
     for(j=0;j<OUT;j++)           //第m个样本教师信号子程序
        D[j]=outteachdata[m][j];
	              /******隐层各单元输入输出子程序******/ 
     for (j=0;j<HN;j++)          
       {
         sigma=0.0;
         for (k=0;k<IN;k++)
		 { 
            sigma+=W[j][k]*P[k];    //求隐层内积
          }
        X[j]=sigma - sita[j];      //求隐层净输入
        H[j]=1.0/(1.0+exp(-X[j])); //求隐层输出
       }
                  /******输出层各单元输入输出子程序*******/
     for (k=0;k<OUT;k++)
      {
        sigma=0.0;
        for (j=0;j<HN;j++)
         {
           sigma+=V[k][j]*H[k];   //求输出层内积
         }
         Y[k]=sigma-gama[k];       //求输出层净输入
         O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
      }     
               /**********输出层至隐层的一般化误差子程序*********/
  //每个样本的绝对误差、平方误差计算都是从0开始的,double abs_err[OUT];
    sqr_err=0;                  
    for (k=0;k<OUT;k++)
     {
		abs_err[k]=D[k]-O[k];                 //求第m个样本下的第k个神经元的绝对误差
		sqr_err+=(abs_err[k])*(abs_err[k]);   //求第m个样本下输出层的平方误差
		delta[k]=abs_err[k]*O[k]*(1.0-O[k]);  //delta[k]输出层各神经元的一般化误差
      }
     err_m[m]=sqr_err/2;                     //第m个样本下输出层的平方误差/2=第m个样本的均方误差
   
     total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差        
              /**********隐层至输入层的一般化误差子程序 *********/ 
    for (j=0;j<HN;j++)
     {
       sigma=0.0;
       for (k=0;k<OUT;k++)
        {
          sigma+=delta[k]*V[k][j];
        }
        e_err1[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
     }
              /*****输出层至隐层的权值调整、输出层阈值调整计算子程序******/
   for(k=0;k<OUT;k++)
    {
      for(j=0;j<HN;j++)
      {
        V[k][j]=V[k][j]+ita*delta[k]*H[j];//输出层至隐层的权值调整
      }
      gama[k]+=ita*delta[k];//输出层至隐层的阈值调整
    }

              /**********隐层至输入层的权值调整、隐层阈值调整计算子程序*********/
   for(j=0;j<HN;j++)
	{ 
       for(i=0;i<IN;i++)
       {
			W[j][i]=W[j][i]+beta*e_err1[j]*P[i];//隐层至输入层的权值调整
		}
      sita[j]+=beta*e_err1[j];
    }       
   }
 //printf("%g\t",total_err);
 }while(total_err>Pre_err && study<Pre_times);

                /******************识别*****************/
//double testdata[1][7]={{10.6677,21.2930,24.6907,24.6288,49.2377,35.2753,47.4063}};
for(k=0;k<IN;k++)
        P[k]=traindata[5][k];
         
for (j=0;j<HN;j++)          //隐层各单元输入输出子程序 
 {
      sigma=0.0;
      for (k=0;k<IN;k++)
      {
         sigma+=W[j][k]*P[k];    //求隐层内积
      }
      X[j]=sigma - sita[j];      //求隐层净输入
      H[j]=1.0/(1.0+exp(-X[j])); //求隐层输出
 }
                                 //输出层各单元输入输出子程序
for (k=0;k<OUT;k++)
{
    sigma=0.0;
     for (j=0;j<HN;j++)
     {
        sigma+=V[k][j]*H[k];   //求输出层内积
     }
     Y[k]=sigma-gama[k];       //求输出层净输入
     O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
}
 
printf("%g\n\n",O[0]);
printf("%g\n\n",O[1]);
printf("%g\n\n",O[2]);

/*for(j=0;j<HN;j++)
for(i=0;i<IN;i++)
   printf("%g\n",W[j][i]);
for(m=0;m<N;m++) 
printf("%g\n",err_m[m]);*/
printf("%g\n\n",total_err);//误差

printf("%d\n\n",study);

}