gzj.cpp

在VC++上实现感知机的神经网络算法

#include<stdio.h>
#include<malloc.h>


void hardlim(float**, int*, float*);
bool zero(int*, int*);
void addwe(float**, int*, int*);
void addbe(float*, int*);

//输入向量P
int P_DIMENSION,p_dimension; //维数
int psum,PSUM,** p_psum=NULL; //矩阵p
//输出向量T
int Q_DIMENSION,q_dimension;// 维数
int tsum,**p_tsum=NULL;//矩阵
//神经元个数
int NERVE_CELL,nerve_cell;
//偏置矩阵B
float *p_bsum = NULL;
//权值矩阵W
float **p_wsum = NULL;
//实际输出向量A
int * pA=NULL;
//误差向量E
int * pE=NULL;
int * pBool=NULL;


void main(){

/*----------------------------------------------------------------------------------
									输入相关数据
---------------------------------------------------------------------------------*/
	//输入向量p的个数
	printf("请输入向量P的个数= ");
	scanf("%d",&PSUM);
	psum=PSUM;

	//每个输入向P的维数
	printf("请输入向量P的维数= ");
	scanf("%d",&P_DIMENSION);
	p_dimension=P_DIMENSION;
	
	//申请内存空间
	p_psum = (int **)malloc(psum*sizeof(int));
	for(int i=0; i<psum; i++){
		*(p_psum + i) = (int *)malloc(p_dimension*sizeof(int));
	}
	
	//输入p的数值
	printf("请输入向量P[%d][%d]\n",psum,p_dimension);
	for(i=0; i<psum; i++){
		for(int j=0; j<p_dimension; j++){
			int temp;
			printf("P[%d][%d]:",i,j);
			scanf("%d",&temp);
			*(*(p_psum+i) + j) = temp;
		}
	}

	//输入T的维数
	tsum = psum;
	printf("请输入目标输出向量T的维数=");
	scanf("%d",&Q_DIMENSION);
	q_dimension=Q_DIMENSION;
	p_tsum = (int **)malloc(tsum*sizeof(int));
	for( i=0; i<tsum; i++){
		*(p_tsum + i) = (int *)malloc(q_dimension*sizeof(int));
	}
	//输入向量T
	printf("请输入目标输出向量T[%d][%d]：\n",tsum,q_dimension);
	for(i=0; i<tsum; i++){
		for(int j=0; j<q_dimension; j++){
			int temp;
			printf("T[%d][%d]:",i,j);
			scanf("%d",&temp);
			*(*(p_tsum+i) + j) = temp;
		}
	}
	
	//输入神经元个数
	printf("请输入神经元个数＝");
	scanf("%d",&NERVE_CELL);
	nerve_cell=NERVE_CELL;
	if(nerve_cell!=q_dimension)
	{
		printf("Wrong! nerve_cell must be equal q_dimension, so you must restart from the begin!");
		return;
	}

	p_bsum = (float *)malloc(nerve_cell*sizeof(float));
	pA = (int *)malloc(nerve_cell*sizeof(int));
	pE = (int *)malloc(nerve_cell*sizeof(int));
	pBool = (int *)malloc(psum*sizeof(int));
	for(i=0; i<psum; i++){
		*(pBool+i) = 0;
	}
	
	//输入偏置矩阵B
	for(i=0; i<nerve_cell; i++){
			float temp;
			printf("请输入偏置 B[%d]=",i);
			scanf("%f",&temp);
			*(p_bsum + i) = temp;
	}

	//输入权值矩阵W
	p_wsum = (float **)malloc(nerve_cell*sizeof(float));
	for( i=0; i<nerve_cell; i++){
		*(p_wsum + i) = (float *)malloc(p_dimension*sizeof(float));
	}
	for(i=0; i<nerve_cell; i++){
		for(int j=0; j<p_dimension; j++){
			float temp;
			printf("请输入权值W[%d][%d]=",i,j);
			scanf("%f",&temp);
			*(*(p_wsum+i) + j) = temp;
		}
	}

/*----------------------------------------------------------------------------------
									计算
---------------------------------------------------------------------------------*/
	int t,q=0;//计数器
	while(true){
		t=0;
		q++;
		for(int m=0; m<psum; m++){
			hardlim(p_wsum, *(p_psum+m), p_bsum);
			if(zero(*(p_tsum+m), pA)){
				t++;
				continue;
			}
			else{
				addwe(p_wsum, pE, *(p_psum+m)); //矩阵相加调整权值
				addbe(p_bsum, pE);
			}					
		}
		if (t==psum||q==1000)
			break;
	}

/*----------------------------------------------------------------------------------
								输出
---------------------------------------------------------------------------------*/
	printf("\n计算结果W:\n");
	for( i=0; i<nerve_cell; i++){
		for(int j=0; j<p_dimension; j++){
			printf("w[%d][%d]: %f\t",i,j,*(*(p_wsum+i)+j));
		}
		printf("\n");
	}
	printf("计算结果B:\n");
	for( i=0; i<nerve_cell; i++){
		printf("b[%d]:%f\t",i,*(p_bsum+i));
	}
	printf("\n\n");
	scanf("%c");
	return;	

}

void hardlim(float **pW, int *p2, float *p3){
	
	float sum = 0.0f;
	for(int i=0; i<nerve_cell; i++){
		for(int j=0; j<p_dimension; j++){
			sum+=(*(*(pW+i)+j)) * (*(p2+j));
		}
		sum += *(p3 + i);
		if(sum>=0){
			sum=1;
			*(pA+i)=(int)sum;
		}else{
			sum=0;
			*(pA+i)=(int)sum;
		}
	}
}

bool zero(int *ptQ, int *pA){
	for(int i=0; i<nerve_cell; i++){
		*(pE+i)=*(ptQ+i) - *(pA+i);
	}
	int count=0;
	for( i=0; i<nerve_cell; i++){
		
		if(*(pE+i)==0)
			count++;
	}
	if(count==nerve_cell)
		return true;
	else{
		count=0;
		return false;
	}
	
}

void addwe(float **pW, int *pE, int*p2){   //公式4。38
	for(int i=0; i<nerve_cell; i++){
		for(int j=0; j<p_dimension; j++)
			*(*(pW+i)+j) += *(pE+i) * *(p2+j);
	}
}

void addbe(float *p_bsum, int *pE){     //公式4。39
	for(int i=0; i<nerve_cell; i++){
		*(p_bsum+i)+=(float)*(pE+i);
	}
}