bp_dll.h

bp_算法~在bp_.cpp文件里~

#include "math.h"
#include <stdlib.h>

// void  setN(double nn);
// void setA(double aa);
// double getN();
// double getA();
// int work(double * input,int inputlen,int * result,double * likehood);
// int learn(double* input,int inputlen,int result);


double BP_Net_InputNumber;
double BP_Net_OutputBypeLen;

double BP_n;
double BP_a;

//double BP_input[512];
//double BP_hid_out[64];
//double BP_out[12];
//int BP_net_result[12];

double* BP_input;
double* BP_hid_out;
double* BP_out;
int* BP_net_result;


//double BP_fff_out[12];
//double BP_fff_hid[64];
//double BP_taw_hid[64][512];
//double BP_taw_top[12][64];

double* BP_fff_out;
double* BP_fff_hid;
double** BP_taw_hid;
double** BP_taw_top;

//double BP_fist_hid[512][64];
//double BP_hid_top[64][12];

double** BP_fist_hid;
double** BP_hid_top;


void BP_init(double aa,double nn,int inputnumber,int outputbytelen)
{
	int i ,j;

	BP_Net_InputNumber=inputnumber;
	BP_Net_OutputBypeLen=outputbytelen;

	BP_a=aa;
	BP_n=nn;
	BP_input=new double[inputnumber];
	BP_hid_out=new double[64];
	BP_out=new double[outputbytelen];
	BP_net_result=new int[outputbytelen];

	BP_fff_out=new double[outputbytelen];
	BP_fff_hid=new double[64];
	BP_taw_top=new double*[outputbytelen];
	for(i=0;i<outputbytelen;i++) BP_taw_top[i]=new double[64];
	BP_taw_hid=new double*[64];
	for(i=0;i<64;i++) BP_taw_hid[i]=new double[inputnumber];


	BP_fist_hid=new double*[inputnumber];
	for(i=0;i<inputnumber;i++) BP_fist_hid[i]=new double[64];
	BP_hid_top=new double*[64];
	for(i=0;i<64;i++) BP_hid_top[i]=new double[outputbytelen];




	for (i=0;i<64;i++)
		for(j=0;j<inputnumber;j++)
		{
			BP_fist_hid[j][i]=(rand()%100-50)/300.0;
			BP_taw_hid[i][j]=0;
		}
		for (i=0;i<outputbytelen;i++){
			for(j=0;j<64;j++)
			{
				BP_hid_top[j][i]=(rand()%100-50)/300.0;
				BP_taw_top[i][j]=0;
			}
		}
}


 int BP_Save()
{

	int i,j;
	FILE *fp;

	fp=fopen("BP_NET.txt", "w"); 
	if(fp==NULL)
	{
		//MessageBox("创建数据文件出错");
		return -1;
	}
	else
	{
		fprintf(fp,"%lf ",BP_Net_InputNumber);
		fprintf(fp,"%lf ",BP_Net_OutputBypeLen);
		fprintf(fp,"%lf ",BP_n);
		fprintf(fp,"%lf ",BP_a);
		for (i=0;i<BP_Net_InputNumber;i++)
			for (j=0;j<64;j++)
			{
				fprintf(fp,"%lf ",BP_fist_hid[i][j]);
				//fscanf(fp, "%lf", &data[i][j]); 
			}

			for (i=0;i<64;i++)
				for (j=0;j<BP_Net_OutputBypeLen;j++)
				{
					fprintf(fp,"%lf ",BP_hid_top[i][j]);
					//fscanf(fp, "%lf", &data[i][j]); 
				}

	}

	fclose(fp);
	return 0;

}


int  BP_Load()
{
	int i,j;
	FILE *fp;

	fp=fopen("BP_NET.txt", "r"); 
	if(fp==NULL)
	{
		//MessageBox("创建数据文件出错");
		return -1;
	}
	else
	{
		fscanf(fp,"%lf",&BP_Net_InputNumber);
		fscanf(fp,"%lf",&BP_Net_OutputBypeLen);
		fscanf(fp,"%lf",&BP_n);
		fscanf(fp,"%lf",&BP_a);
		BP_init(BP_a,BP_n,BP_Net_InputNumber,BP_Net_OutputBypeLen);
		for (i=0;i<BP_Net_InputNumber;i++)
			for (j=0;j<64;j++)
			{
				fscanf(fp,"%lf",&BP_fist_hid[i][j]);
				//fscanf(fp, "%lf", &data[i][j]); 
			}

			for (i=0;i<64;i++)
				for (j=0;j<BP_Net_OutputBypeLen;j++)
				{
					fscanf(fp,"%lf",&BP_hid_top[i][j]);
					//fscanf(fp, "%lf", &data[i][j]); 
				}

	}
	fclose(fp);
	return 0;
}



void BP_free()
{
	delete(BP_input);
	delete(BP_hid_out);
	delete(BP_out);
	delete(BP_net_result);
	
	delete(BP_fff_out);
	delete(BP_fff_hid);
	delete(BP_taw_hid);
	delete(BP_taw_top);
	
	delete(BP_fist_hid);
	delete(BP_hid_top);
}

 
 void  BP_setN(double nn){
	BP_n=nn;
}
 void BP_setA(double aa){
	BP_a=aa;
}
 double BP_getN(){
	return BP_n;
}

 double BP_getA(){
	return BP_a;
}

 int BP_work(double * BP_input2,int BP_inputlen,int * result,double * likehood)
{
	if(BP_inputlen>BP_Net_InputNumber){
		return -1;////说明输入数组大小大于最大能处理大小
	}
	
	//////////////////////////////////////////////////////////////////////////////////////
	///////////计算BP_hid_out[64]
	int i,j;
	for(i=0;i<BP_inputlen;i++)
	{
		BP_input[i]=0;
	}
	for(i=0;i<BP_inputlen;i++)
	{
		BP_input[i]=BP_input2[i];
	}


	for (i=0;i<64;i++)
	{
		BP_hid_out[i]=0.0;
		for (j=0;j<BP_inputlen;j++)
		{	
			BP_hid_out[i]=BP_hid_out[i]+BP_fist_hid[j][i]*BP_input[j];//hid_nero[i].w[j]*data[j][row];			

		}
		BP_hid_out[i]=1.0/(1.0+exp(-BP_hid_out[i]));

	}

	////////////////////////////////////////////////////////////////	
	////////////计算net_top[8]
	for (i=0;i<BP_Net_OutputBypeLen;i++)
	{
		BP_out[i]=0.0;
		for (j=0;j<64;j++)
		{	
			BP_out[i]=BP_out[i]+BP_hid_top[j][i]*BP_hid_out[j];//[i].w[j]*Oj_hid[j];

		}
		BP_out[i]=1.0/(1.0+exp(-BP_out[i]));

	}


	*result=0;
	*likehood=0.0;
	for(i=0;i<BP_Net_OutputBypeLen;i++){
		if(BP_out[i]>0.5){
			*result=*result+(int)pow(2,i);
			*likehood=*likehood+BP_out[i];
		}else
		{
			*likehood=*likehood-BP_out[i]+1;
		}
	}
	*likehood=*likehood/BP_Net_OutputBypeLen;

	return 1;


}

 int BP_learn(double* BP_input2,int inputlen,int result)
{
	if(inputlen>BP_Net_InputNumber){
		return -1;////说明输入数组大小大于最大能处理大小
	}
	if(result>(int)pow(2.0,BP_Net_OutputBypeLen)){
		return -2;/////////应该小于(int)pow(2.0,BP_Net_OutputBypeLen) 就是取下12位
	}


	double likehood;
	int i,j;
	double temp;

	for(i=0;i<inputlen;i++)
	{
		BP_input[i]=0;
	}
	for(i=0;i<inputlen;i++)
	{
		BP_input[i]=BP_input2[i];
	}


	for(i=0;i<BP_Net_OutputBypeLen;i++){
		BP_net_result[i]=(int)fmod(result,2.0);
		result=(int)(result/2.0);
	}
	/////////////////////////////////////////////////////////////////////////////////////
	//////////////用feel得到net_hid,oj_hid,net_top,oj_top
	BP_work(BP_input2,inputlen,&result,&likehood);

	////////////////////////////////////////////////////////////////////
	/////////计算 top-ffff
	for(i=0;i<BP_Net_OutputBypeLen;i++){
		BP_fff_out[i]=(BP_net_result[i]-BP_out[i])*BP_out[i]*(1-BP_out[i]);
	}	

	///////////////////////////////////////////////////////////////////////////////////
	//////////////计算hid fff
	for (i=0;i<64;i++)
	{
		temp=0;
		for(j=0;j<BP_Net_OutputBypeLen;j++){
			temp=temp+BP_hid_top[i][j]*BP_fff_out[j];//top_nero[j].w[i]*fff_top[j];
		}
		BP_fff_hid[i]=BP_hid_out[i]*(1-BP_hid_out[i])*temp;//Oj_hid[i]*(1-Oj_hid[i])*temp;		
	}
	/////////////////////////////////////////////////////////////////////////////////////////////////
	for (i=0;i<64;i++)
	{

		for(j=0;j<inputlen;j++)
		{

			temp=BP_n*BP_fff_hid[i]*BP_input[j];
			BP_taw_hid[i][j]=temp+BP_a*BP_taw_hid[i][j];
			BP_fist_hid[j][i]=BP_fist_hid[j][i]+BP_taw_hid[i][j];			
		}
	}
	////////////////////////////////////////////////////////////////////////////////////////////
	for (i=0;i<BP_Net_OutputBypeLen;i++)
	{

		for(j=0;j<64;j++)
		{
			temp=BP_n*BP_fff_out[i]*BP_hid_out[j];
			BP_taw_top[i][j]=temp+BP_a*BP_taw_top[i][j];
			BP_hid_top[j][i]=BP_hid_top[j][i]+BP_taw_top[i][j];			
		}

	}
	return 1;

}