www.pudn.com > chepaishibiexitong.rar > AnnBP.cpp

// AnnBP.cpp: implementation of the CAnnBP class. 
// 
////////////////////////////////////////////////////////////////////// 
#include "StdAfx.h" 
#include "AnnBP.h" 
#include "math.h" 
 
 
 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CAnnBP::CAnnBP() 
{ 
	eta1=0.3; 
	momentum1=0.3; 
 
} 
 
CAnnBP::~CAnnBP() 
{ 
 
} 
 
 
double CAnnBP::drnd() 
{ 
	return ((double) rand() / (double) BIGRND); 
} 
 
 
/*** 返回-1.0到1.0之间的双精度随机数 ***/ 
double CAnnBP::dpn1() 
{ 
	return (double) (rand())/(32767/2)-1; 
} 
 
/*** 作用函数，目前是S型函数 ***/ 
double CAnnBP::squash(double x) 
{ 
	return (1.0 / (1.0 + exp(-x))); 
} 
 
 
/*** 申请1维双精度实数数组 ***/ 
double* CAnnBP::alloc_1d_dbl(int n) 
{ 
	double *new1; 
 
	new1 = (double *) malloc ((unsigned) (n * sizeof (double))); 
	if (new1 == NULL) { 
		AfxMessageBox("ALLOC_1D_DBL: Couldn't allocate array of doubles\n"); 
		return (NULL); 
	} 
	return (new1); 
} 
 
/*** 申请2维双精度实数数组 ***/ 
double** CAnnBP::alloc_2d_dbl(int m, int n) 
{ 
	int i; 
	double **new1; 
 
	new1 = (double **) malloc ((unsigned) (m * sizeof (double *))); 
	if (new1 == NULL) { 
		AfxMessageBox("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrs\n"); 
		return (NULL); 
	} 
 
	for (i = 0; i < m; i++) { 
		new1[i] = alloc_1d_dbl(n); 
	} 
 
	return (new1); 
} 
 
 
/*** 随机初始化权值 ***/ 
void CAnnBP::bpnn_randomize_weights(double **w, int m, int n) 
{ 
	int i, j; 
	for (i = 0; i <= m; i++) { 
		for (j = 0; j <= n; j++) { 
			w[i][j] = dpn1(); 
		} 
	} 
 
} 
 
/*** 0初始化权值 ***/ 
void CAnnBP::bpnn_zero_weights(double **w, int m, int n) 
{ 
	int i, j; 
 
	for (i = 0; i <= m; i++) { 
		for (j = 0; j <= n; j++) { 
			w[i][j] = 0.0; 
		} 
	} 
 
} 
 
/*** 设置随机数种子 ***/ 
void CAnnBP::bpnn_initialize(int seed) 
{ 
	CString msg,s; 
	msg="Random number generator seed:"; 
	s.Format("%d",seed); 
	AfxMessageBox(msg+s); 
	srand(seed); 
} 
 
/*** 创建BP网络 ***/ 
BPNN* CAnnBP::bpnn_internal_create(int n_in, int n_hidden, int n_out) 
{ 
	BPNN *newnet; 
 
	newnet = (BPNN *) malloc (sizeof (BPNN)); 
	if (newnet == NULL) { 
		printf("BPNN_CREATE: Couldn't allocate neural network\n"); 
		return (NULL); 
	} 
 
	newnet->input_n = n_in; 
	newnet->hidden_n = n_hidden; 
	newnet->output_n = n_out; 
	newnet->input_units = alloc_1d_dbl(n_in + 1); 
	newnet->hidden_units = alloc_1d_dbl(n_hidden + 1); 
	newnet->output_units = alloc_1d_dbl(n_out + 1); 
 
	newnet->hidden_delta = alloc_1d_dbl(n_hidden + 1); 
	newnet->output_delta = alloc_1d_dbl(n_out + 1); 
	newnet->target = alloc_1d_dbl(n_out + 1); 
 
	newnet->input_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1); 
	newnet->hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1); 
 
	newnet->input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1); 
	newnet->hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1); 
 
	return (newnet); 
 
} 
 
/* 释放BP网络所占地内存空间 */ 
void CAnnBP::bpnn_free(BPNN *net) 
{ 
	int n1, n2, i; 
 
	n1 = net->input_n; 
	n2 = net->hidden_n; 
 
	free((char *) net->input_units); 
	free((char *) net->hidden_units); 
	free((char *) net->output_units); 
 
	free((char *) net->hidden_delta); 
	free((char *) net->output_delta); 
	free((char *) net->target); 
 
	for (i = 0; i <= n1; i++) { 
		free((char *) net->input_weights[i]); 
		free((char *) net->input_prev_weights[i]); 
	} 
	free((char *) net->input_weights); 
	free((char *) net->input_prev_weights); 
 
	for (i = 0; i <= n2; i++) { 
		free((char *) net->hidden_weights[i]); 
		free((char *) net->hidden_prev_weights[i]); 
	} 
	free((char *) net->hidden_weights); 
	free((char *) net->hidden_prev_weights); 
 
	free((char *) net); 
} 
 
 
/*** 创建一个BP网络，并初始化权值***/ 
BPNN* CAnnBP::bpnn_create(int n_in, int n_hidden, int n_out) 
{ 
	BPNN *newnet; 
 
	newnet = bpnn_internal_create(n_in, n_hidden, n_out); 
 
#ifdef INITZERO 
	bpnn_zero_weights(newnet->input_weights, n_in, n_hidden); 
#else 
	bpnn_randomize_weights(newnet->input_weights, n_in, n_hidden); 
#endif 
	bpnn_randomize_weights(newnet->hidden_weights, n_hidden, n_out); 
	bpnn_zero_weights(newnet->input_prev_weights, n_in, n_hidden); 
	bpnn_zero_weights(newnet->hidden_prev_weights, n_hidden, n_out); 
 
	return (newnet); 
 
} 
 
 
 
void CAnnBP::bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2) 
{ 
	double sum; 
	int j, k; 
 
	/*** 设置阈值 ***/ 
	l1[0] = 1.0; 
 
	/*** 对于第二层的每个神经元 ***/ 
	for (j = 1; j <= n2; j++) { 
 
		/*** 计算输入的加权总和 ***/ 
		sum = 0.0; 
		for (k = 0; k <= n1; k++) { 
			sum += conn[k][j] * l1[k]; 
		} 
		l2[j] = squash(sum); 
	} 
} 
 
/* 输出误差 */ 
void CAnnBP::bpnn_output_error(double *delta, double *target, double *output, int nj, double *err) 
{ 
	int j; 
	double o, t, errsum; 
 
	errsum = 0.0; 
	for (j = 1; j <= nj; j++) { 
		o = output[j]; 
		t = target[j]; 
		delta[j] = o * (1.0 - o) * (t - o); 
		errsum += ABS(delta[j]); 
	} 
	*err = errsum; 
 
} 
 
/* 隐含层误差 */ 
void CAnnBP::bpnn_hidden_error(double *delta_h, int nh, double *delta_o, int no, double **who, double *hidden, double *err) 
{ 
	int j, k; 
	double h, sum, errsum; 
 
	errsum = 0.0; 
	for (j = 1; j <= nh; j++) { 
		h = hidden[j]; 
		sum = 0.0; 
		for (k = 1; k <= no; k++) { 
			sum += delta_o[k] * who[j][k]; 
		} 
		delta_h[j] = h * (1.0 - h) * sum; 
		errsum += ABS(delta_h[j]); 
	} 
	*err = errsum; 
} 
 
/* 调整权值 */ 
void CAnnBP::bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double **w, double **oldw, double eta, double momentum) 
{ 
	double new_dw; 
	int k, j; 
 
	ly[0] = 1.0; 
	for (j = 1; j <= ndelta; j++) { 
		for (k = 0; k <= nly; k++) { 
			new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j])); 
			w[k][j] += new_dw; 
			oldw[k][j] = new_dw; 
		} 
	} 
 
} 
 
/* 进行前向运算 */ 
void CAnnBP::bpnn_feedforward(BPNN *net) 
{ 
	int in, hid, out; 
 
	in = net->input_n; 
	hid = net->hidden_n; 
	out = net->output_n; 
 
	/*** Feed forward input activations. ***/ 
	bpnn_layerforward(net->input_units, net->hidden_units, 
		net->input_weights, in, hid); 
	bpnn_layerforward(net->hidden_units, net->output_units, 
		net->hidden_weights, hid, out); 
 
} 
 
/* 训练BP网络 */ 
void CAnnBP::bpnn_train(BPNN *net, double eta, double momentum, double *eo, double *eh) 
{ 
	int in, hid, out; 
	double out_err, hid_err; 
 
	in = net->input_n; 
	hid = net->hidden_n; 
	out = net->output_n; 
 
	/*** 前向输入激活 ***/ 
	bpnn_layerforward(net->input_units, net->hidden_units, 
		net->input_weights, in, hid); 
	bpnn_layerforward(net->hidden_units, net->output_units, 
		net->hidden_weights, hid, out); 
 
	/*** 计算隐含层和输出层误差 ***/ 
	bpnn_output_error(net->output_delta, net->target, net->output_units, 
		out, &out_err); 
	bpnn_hidden_error(net->hidden_delta, hid, net->output_delta, out, 
		net->hidden_weights, net->hidden_units, &hid_err); 
	*eo = out_err; 
	*eh = hid_err; 
 
	/*** 调整输入层和隐含层权值 ***/ 
	bpnn_adjust_weights(net->output_delta, out, net->hidden_units, hid, 
		net->hidden_weights, net->hidden_prev_weights, eta, momentum); 
	bpnn_adjust_weights(net->hidden_delta, hid, net->input_units, in, 
		net->input_weights, net->input_prev_weights, eta, momentum); 
} 
 
/* 保存BP网络 */ 
void CAnnBP::bpnn_save(BPNN *net, char *filename) 
{ 
CFile file; 
	char *mem; 
	int n1, n2, n3, i, j, memcnt; 
	double dvalue, **w; 
	n1 = net->input_n;  n2 = net->hidden_n;  n3 = net->output_n; 
	printf("Saving %dx%dx%d network to '%s'\n", n1, n2, n3, filename); 
	try 
	{ 
		file.Open(filename,CFile::modeWrite|CFile::modeCreate|CFile::modeNoTruncate); 
	} 
	catch(CFileException* e) 
	{ 
		e->ReportError(); 
		e->Delete(); 
	} 
	 
	file.Write(&n1,sizeof(int)); 
	file.Write(&n2,sizeof(int)); 
	file.Write(&n3,sizeof(int)); 
	 
	memcnt = 0; 
	w = net->input_weights; 
	mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double))); 
//	mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double))); 
	for (i = 0; i <= n1; i++) { 
		for (j = 0; j <= n2; j++) { 
			dvalue = w[i][j]; 
			//fastcopy(&mem[memcnt], &dvalue, sizeof(double)); 
			fastcopy(&mem[memcnt], &dvalue, sizeof(double)); 
			memcnt += sizeof(double); 
		 
		} 
	} 
 
	file.Write(mem,sizeof(double)*(n1+1)*(n2+1)); 
	free(mem); 
 
	memcnt = 0; 
	w = net->hidden_weights; 
	mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double))); 
//	mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double))); 
	for (i = 0; i <= n2; i++) { 
		for (j = 0; j <= n3; j++) { 
			dvalue = w[i][j]; 
			fastcopy(&mem[memcnt], &dvalue, sizeof(double)); 
//			fastcopy(&mem[memcnt], &dvalue, sizeof(double)); 
			memcnt += sizeof(double); 
		} 
	} 
 
	file.Write(mem, (n2+1) * (n3+1) * sizeof(double)); 
//	free(mem); 
 
	file.Close(); 
	return; 
} 
 
/* 从文件中读取BP网络 */ 
BPNN* CAnnBP::bpnn_read(char *filename) 
{ 
	char *mem; 
	BPNN *new1; 
	int n1, n2, n3, i, j, memcnt; 
	CFile file; 
 
	try 
	{ 
		file.Open(filename,CFile::modeRead|CFile::modeCreate|CFile::modeNoTruncate); 
	} 
	catch(CFileException* e) 
	{ 
		e->ReportError(); 
		e->Delete(); 
	} 
 
	 
//	printf("Reading '%s'\n", filename);// fflush(stdout); 
 
	file.Read(&n1, sizeof(int)); 
	file.Read(&n2, sizeof(int)); 
	file.Read(&n3, sizeof(int)); 
	 
 
	new1 = bpnn_internal_create(n1, n2, n3); 
 
//	printf("'%s' contains a %dx%dx%d network\n", filename, n1, n2, n3); 
//	printf("Reading input weights..."); // fflush(stdout); 
 
 
	memcnt = 0; 
	mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double))); 
 
	file.Read(mem, ((n1+1)*(n2+1))*sizeof(double)); 
	for (i = 0; i <= n1; i++) { 
		for (j = 0; j <= n2; j++) { 
			//fastcopy(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double)); 
			fastcopy(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double)); 
			memcnt += sizeof(double); 
		} 
	} 
	free(mem); 
 
//	printf("Done\nReading hidden weights...");  //fflush(stdout); 
 
	memcnt = 0; 
	mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double))); 
 
	file.Read(mem, (n2+1) * (n3+1) * sizeof(double)); 
	for (i = 0; i <= n2; i++) { 
	 
		for (j = 0; j <= n3; j++) { 
			//fastcopy(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double)); 
			fastcopy(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double)); 
			memcnt += sizeof(double); 
			 
		} 
	} 
	free(mem); 
	file.Close(); 
 
	printf("Done\n");  //fflush(stdout); 
 
	bpnn_zero_weights(new1->input_prev_weights, n1, n2); 
	bpnn_zero_weights(new1->hidden_prev_weights, n2, n3); 
 
	return (new1); 
} 
 
void CAnnBP::CreateBP(int n_in, int n_hidden, int n_out) 
{ 
	net=bpnn_create(n_in,n_hidden,n_out); 
} 
 
void CAnnBP::FreeBP() 
{ 
	bpnn_free(net); 
 
} 
 
void CAnnBP::Train(double *input_unit,int input_num, double *target,int target_num, double *eo, double *eh) 
{ 
	for(int i=1;i<=input_num;i++) 
	{ 
		net->input_units[i]=input_unit[i-1]; 
	} 
 
	for(int j=1;j<=target_num;j++) 
	{ 
		net->target[j]=target[j-1]; 
	} 
	bpnn_train(net,eta1,momentum1,eo,eh); 
 
} 
 
void CAnnBP::Identify(double *input_unit,int input_num,double *target,int target_num) 
{ 
	for(int i=1;i<=input_num;i++) 
	{ 
		net->input_units[i]=input_unit[i-1]; 
	} 
	bpnn_feedforward(net); 
	for(int j=1;j<=target_num;j++) 
	{ 
		target[j-1]=net->output_units[j]; 
	} 
} 
 
void CAnnBP::Save(char *filename) 
{ 
	bpnn_save(net,filename); 
 
} 
 
void CAnnBP::Read(char *filename) 
{ 
	net=bpnn_read(filename); 
} 
 
void CAnnBP::SetBParm(double eta, double momentum) 
{ 
	eta1=eta; 
	momentum1=momentum; 
 
} 
 
void CAnnBP::Initialize(int seed) 
{ 
	bpnn_initialize(seed); 
 
}