最新神经网络dll版.cpp

神经网络 高精度double dll版本

// design by 安仔 at 07.08.19

#include "stdafx.h"
#include "Stdio.h"
#include "Conio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define IN_MUN 5 /*输入层神经元数目，为语音特征码输入*/
#define HN 2 /*隐层神经元数目，前馈网络隐藏层*/
#define ON 3 /*输出层神经元数模，各个命令的开关阀*/
#define N 5
float W[HN][IN_MUN]; /*输入层至隐层权值*/
float V[ON][HN]; /*隐层至输出层权值*/

float YU_HN[HN]; /*隐层的阈值*/
float YU_ON[ON]; /*输出层的阈值*/

float X[HN]; /*隐层的输入,各个隐藏层的神经单元的内积*/
float Y[ON]; /*输出层的输入，各个输出层的神经单元的内积*/
float H[HN]; /*隐层的输出，s型函数之后的输出值*/
float O[ON]; /*输出层的输出，s型函数之后的输出值*/

float alpha;   /*/动量因子，改进型bp算法使用*/
float err_m[N]; /*第m个样本的总误差*/
float a; /*   输出层至隐层学习效率*/
float b; /*   隐层至输入层学习效率*/
float d_err[ON];/*δk*/
float e_err[HN];/*δj*/

/*权值和阈值的保存*/
float old_W[HN][IN_MUN];
float old_V[ON][HN];

float teachers[8][3]={{0.1,0.1,0.1},{0.1,0.1,0.9},{0.1,0.9,0.1},{0.1,0.9,0.9},{0.9,0.1,0.1},{0.9,0.1,0.9},{0.9,0.9,0.1},{0.9,0.9,0.9}};  //命令的期望值

FILE *fp;

/*定义一个放学习样本的结构*/
struct {
float input[IN_MUN];
float teach[ON];
        }Study_Data[N];


BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    return TRUE;
}


/*读取读取文件数据*/
GetTrainingData()
{int j;
float cdata;
if((fp=fopen("input.ini","r"))==NULL)
      {
       return 0;
      }
       j=0;
       while(j!=(IN_MUN)&&fscanf(fp,"%f",&cdata)!=EOF)
        {
         Study_Data[1].input[j]=cdata;
         j++;
        }
fclose(fp);

return 1;
}


get_teacher(int commd)
     {int i=0;
      if(commd>7||commd<0)
	{
   MessageBox(NULL,"参数错误！","警告！",MB_OK);
   return 0;
	  }	  
    for(i=0;i<ON;i++)
	{
	Study_Data[1].teach[i]=teachers[commd][i];
	}
return 1;
     }



/*初始化权、阈值子程序*/
initial()
{int x;
int xx;
int q;
int qq;
int z;
int zz;
srand(time(NULL));/*随机函数种子*/
for(x=0;x<HN;x++) {
   for(q=0;q<IN_MUN;q++) {
   W[x][q]=(float)(((rand()/32767.0)*2-1)/2);  /*初始化输入层到隐层的权值，随机模拟0.5~-0.5 */
   }
   }
for(xx=0;xx<ON;xx++) {
   for(qq=0;qq<HN;qq++)    {V[xx][qq]= (float)(((rand()/32767.0)*2-1)/2);   /*初始化隐层到输出层的权值，随机模拟0.5~-0.5 */
     }
   }

for(z=0;z<HN;z++) {
   YU_HN[z] = (double)((rand()/32767.0)*2-1);
/*隐层阈值初始化 */

     }
for(zz=0;zz<ON;zz++) {
   YU_ON[zz] = (double)((rand()/32767.0)*2-1);
/*输出层阈值初始化 */
    }
return 1;
}


/*求净输入，输出*/
IN_OUT()
{
float sigma1,sigma2;
int i,j,ii,jj;
for(i=0;i<HN;i++)   {
    sigma1=0.0;
    for(j=0;j<IN_MUN;j++)
    {sigma1+=W[i][j]*Study_Data[1].input[j];}/*求隐层内积*/
     X[i]=sigma1+YU_HN[i];
     H[i]=1.0/(1.0+exp(-X[i]));   /*隐层内积的s型函数输出*/
    }
for(ii=0;ii<ON;ii++) {
    sigma2=0.0;
    for(jj=0;jj<HN;jj++)
    {sigma2+=V[ii][jj]*H[jj];}
     Y[ii]=sigma2+YU_ON[ii];
     O[ii]=1.0/(1.0+exp(-Y[ii]));   /*输出层内积的s型函数输出*/
    }
return 1;
}

/*误差分析*/
/*δk*/
int Err_O_H(int m)
{int k;
float abs_err[ON];
float sqr_err=0.0;
for (k=0;k<ON;k++)   {
    abs_err[k]=Study_Data[1].teach[k]-O[k];
    sqr_err+=(abs_err[k])*(abs_err[k]);
    d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);   /*教师值与输出值的差 乘以 输出值 乘以 1－输出值*/
   }
   err_m[m]=sqr_err/2;                    /*输出层的每个输出神经元的 教师值与输出值的差 的和  除以2的值*/
return 1;
}

/*δj*/
int Err_H_I()
{
int j,k;
float sigma;
for(j=0;j<HN;j++) {
   sigma=0.0;
   for(k=0;k<ON;k++)
    {sigma+=d_err[k]*V[k][j];}
     e_err[j]=sigma*H[j]*(1-H[j]);
   }
return 1;
}

/*总误差，当需要批量训练的时候才用*/
float Err_Sum()
{int m;
float total_err=0.0;
for(m=0;m<N;m++)
    {total_err+=err_m[m];}
return total_err;
}



/*新旧权值更新量交替--改进型Bp算法*/
/*
saveWV()
{int i;
int ii;
int j;
int jj;
for(i=0;i<HN;i++)    {
    for(j=0;j<IN_MUN;j++)
      {old_W[i][j] =b*e_err[i]*Study_Data[1].input[j];}    输入层到隐层的权值更新
    }
for(ii=0;ii<ON;ii++){
    for(jj=0;jj<HN;jj++)
      {old_V[ii][jj] =a*d_err[ii]*H[jj];}       隐层到输出层的权值更新
    }
return 1;
}
*/

/*更新权值，阈值*/
/*输出层*/
int Delta_O_H()
{int k,j;
    for (k=0;k<ON;k++)   {
      for (j=0;j<HN;j++)
        {V[k][j]=V[k][j]+(1.0-alpha)*a*d_err[k]*H[j]+alpha*a*d_err[k]*H[j];}
      YU_ON[k]+=a*d_err[k];
     }

return 1;
}
/*隐层*/
Delta_H_I()
{int i,j;

   for (j=0;j<HN;j++)    {
      for (i=0;i<IN_MUN;i++)
        {W[j][i]=W[j][i]+(1.0-alpha)*b*e_err[j]*Study_Data[1].input[i]+alpha*b*e_err[i]*Study_Data[1].input[j];}
      YU_HN[j]+=b*e_err[j];
     }

return 1;
}


/*保存更新*/
void savequan()
{ int i,j,k,f;
   int ii,jj,kk;
   /*save weight 权值*/
   if((fp=fopen("weight.txt","a"))==NULL)
    {
      printf("Cannot open file strike any key exit!");
      getch();
      exit(1);
    }
   for(i=0;i<HN;i++)
     {for(j=0;j<IN_MUN;j++)   fprintf(fp,"W[%d][%d]=%f\n",i,j,W[i][j]); }
   fprintf(fp,"\n");
   for(ii=0;ii<ON;ii++)
     {for(jj=0;jj<HN;jj++)   fprintf(fp,"V[%d][%d]=%f\n",ii,jj,V[ii][jj]);}
   fclose(fp);

   /*save limit 阈值*/
   if((fp=fopen("limit.txt","a"))==NULL)
    {
      printf("Cannot open file strike any key exit!");
      getch();
      exit(1);
    }
   for(k=0;k<ON;k++)    fprintf(fp,"YU_ON[%d]=%f\n",k,YU_ON[k]);
   for(kk=0;kk<HN;kk++)   fprintf(fp,"YU_HN[%d]=%f\n",kk,YU_HN[kk]);
      fprintf(fp,"\n");
        for(f=0;f<ON;f++)    fprintf(fp,"O[%d]=%f\n",f,O[f]);
         fprintf(fp,"\n");

		         for(f=0;f<8;f++)
					 for(i=0;i<3;i++) 

					 fprintf(fp,"teachers[%d][%d]=%f\n",f,i,teachers[f][i]);
                        fprintf(fp,"\n");
						for(f=0;f<ON;f++)    fprintf(fp,"O[%d]=%f\n",f,Study_Data[1].teach[f]);
						 fprintf(fp,"\n");
   fclose(fp);
}

extern "C" _declspec(dllexport) BOOL accept_tz(int *intputs[29],int *teac[2])
{
int i,j;
for(i=0;i<IN_MUN;i++)
{
Study_Data[1].input[i]=*intputs[i];
}
for(i=0;i<=ON;i++)
{
Study_Data[1].teach[j]=*teac[i];
}
return 1;
}


//int _declspec(dllexport) xunlian(float Pre_error,long int flag,int inputsj,int hidesj,int outputsj)
extern "C" _declspec(dllexport) BOOL xunlian(int cm)
{
int F_resault;
//参数检查
//if(Pre_error<=0 || Pre_error>=1 || flag<=0 || flag>=1000000 || Pre_error==NULL || flag==NULL)
//{
//   MessageBox(NULL,"参数错误！","警告！",MB_OK);
//   return 0;
//}
      if(cm>7||cm<0)
	  {
      MessageBox(NULL,"参数错误！","警告！",MB_OK);
      return 0;
	  }	
float sum_err,Pre_error;
long int study,flag;
alpha=0.5;
a=0.5;   /*  0~1之间 ，趋于0就比较保守，趋于1就比较激进*/
b=0.5;   /*  0~1之间 ，趋于0就比较保守，趋于1就比较激进*/
flag=200000;
study=0;
Pre_error=0.00001;/*可接受误差*/
F_resault=GetTrainingData();
get_teacher(cm);
if(!F_resault)
{
   MessageBox(NULL,"找不到input.ini或output.ini文件！","警告！",MB_OK);
   return 0;
}
initial();
do
   {
      ++study;
      IN_OUT();
      Err_O_H(0);
      Err_H_I();
      Delta_O_H();
      Delta_H_I();
      sum_err=Err_Sum();
   if(study>flag)
    {
     break;
    }
}while (sum_err>Pre_error);
savequan(); /*save the results*/
return 1;
}