rbf.c

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

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

#include "RBF.h"

#pragma DATA_SECTION(A, ".INTPROCBUFF");
#pragma DATA_ALIGN(A,128);
double A[N][M];//存放各类输出矢量之和

#pragma DATA_SECTION(B, ".INTPROCBUFF");
#pragma DATA_ALIGN(B,128);
double B[N];//存放属于各类的样本数

#pragma DATA_SECTION(W, ".INTPROCBUFF");
#pragma DATA_ALIGN(W,128);
double W[N][M];//隐层到输出层的权值

#pragma DATA_SECTION(C, ".INTPROCBUFF");
#pragma DATA_ALIGN(C,128);
double C[N][K];//隐层中心

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

//#pragma DATA_SECTION(Oh, ".INTPROCBUFF");
//#pragma DATA_ALIGN(Oh,128);
//double Oh[N][L]; //隐层的输出       

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


double r=0.1;     //宽度参数
double e=0;       //网络训练误差
int L,i,j,m,n;             //L隐层节点数，
double  P[N][K]={
				{6.8476,14.799,21.049,21.918,43.406,29.34,42.184},
				{6.8497,14.853,20.957,21.879,43.303,29.327,42.169},
				{6.8461,14.905,20.846,21.841,43.194,29.314,42.274},
				{6.8403,14.934,20.762,21.805,43.098,29.285,42.539},
				{6.8488,14.962,20.836,21.904,43.283,29.391,43.254},
				{6.2704,12.838,19.51,19.892,39.594,26.312,39.788},
				{6.2778,12.85,19.577,19.96,39.729,26.386,39.909},
				{6.2761,12.847,19.542,19.92,39.651,26.343,39.832},
				{6.2779,12.85,19.554,19.931,39.673,26.356,39.853},
				{6.2776,12.849,19.562,19.942,39.695,26.367,39.874}};
			
                
            	double T[N][M]={{0.9,0.1},
								{0.9,0.1},
								{0.9,0.1},
								{0.9,0.1},
								{0.9,0.1},
								{0.1,0.9},
								{0.1,0.9},
								{0.1,0.9},
								{0.1,0.9},
								{0.1,0.9}};
		/*double outteachdata[N][OUT]={{1,1,1},{1,1,0},{1,1,1},{0,0,0},{1,1,0},
								{0,0,0},};*/
	
#pragma CODE_SECTION(RBFrecognise,".text1")
void RBFrecognise()
{  //训练网络
   for (i=0;i<K;i++)   C[0][i]=P[0][i];
   for (j=0;j<M;j++)   A[0][j]=T[0][j];
   B[0]=1;
   for (j=0;j<M;j++)   W[0][j]=A[0][j]/B[0];
   L=1;
   for (n=1;n<N;n++)   
   {
     double dmin=10000;
     int    mh=0;
     for(m=0;m<L;m++)
     {
        double d=0.0;
        double d1[K];
        double d2=0.0;
        for (i=0;i<K;i++)
        {
            d1[i]=absf(P[n][i]-C[m][i]);
         }
    //    double d2=0.0;
        for(i=0;i<K;i++)  d2=d2+d1[i]*d1[i];
        d=sqrtf(d2);
        if(d<dmin) {dmin=d; mh=m;}
        
      }
      if(dmin>r)
      {
         for (i=0;i<K;i++)  C[L+1][i]=P[n][i];
         L=L+1;
         for (j=0;j<M;j++)  A[L][j]=T[n][j];
         B[L]=1;
         for (j=0;j<M;j++)  W[L][j]=A[L][j]/B[L];
      }
      if(dmin<=r)
      {
         for (j=0;j<M;j++)  A[mh][j]=A[mh][j]+T[n][j];
         B[mh]++;
         for (m=0;m<L;m++)
         {
          for (j=0;j<M;j++) W[m][j]=A[m][j]/B[m];
          
         }
       }
    }
    //计算网络输出
    //double Oh[N][L];
  
    for (n=0;n<N;n++) 
    {   
      double Oh[10][3];
       for (m=0;m<L;m++)
       {  
            double sum0=0.0;
            double sum1[K];
            for (i=0;i<K;i++)
              {
                     sum1[i]=absf(P[n][i]-C[m][i]);
                     sum0=sum0+sum1[i]*sum1[i];
              }
         //第n个样本第m个隐层节点的输出
         Oh[n][m]=exp(-sum0/(r*r));
         }
        //计算输出层的输出
        
        for(j=0;j<M;j++)  
        {
          for (m=0;m<L;m++)  O[n][j]=O[n][j]+Oh[n][j]*W[m][j];
          
           e=e+(T[n][j]-O[n][j])*(T[n][j]-O[n][j])/(2*N);
        }
        
     }
     printf("%g\n\n",O[0]);
     printf("%g\n\n",O[1]);

     printf("%g\n\n",e);//误差

     
  }