BP神经网络算法实现

最新推荐文章于 2024-07-27 00:32:18 发布
最新推荐文章于 2024-07-27 00:32:18 发布
阅读量1.5k 收藏 1
点赞数
文章标签： 网络 算法 fp float math.h system
  
//BP神经网络算法实现

#include <stdio.h>
#include <math.h> 
#include <conio.h> 
#include <stdlib.h>

#define nh 3			/*输入层*/
#define ni 4			/*隐层*/
#define nj 1            /*输出层*/
#define nk 100          /*样本容量*/
#define test 70         /*测试集容量*/
#define nr 0.7          /*学习效率*/
#define EPS 0.00001

float x[nk][nh],d[nk][nj],whi[nh][ni],wij[ni][nj],thi[ni],thj[nj];
int h,i,j,k,ff; 
float xmin[nh],xmax[nh],dmin[nj],dmax[nj]; 
FILE *fp1,*fp2,*fp3,*fp4; 

void init(void); 
void startleaning(void);
void testsample(void); 
void readw(void); 
void readt(void);
void writew(void); 
float sigmoid(float a); 
double ranu(void); 
char filename1[]={"samplefile.txt"};

void init(void) 
{
	int min,max;  
	if(fp1==0)
	{ 
		system("cls"); 
		printf("Can not find the learning sample file!\n"); 
		exit(0);
	} 
	for(k=0;k<nk;k++)
	{ 
		for(h=0;h<nh;h++) 
			fscanf(fp1,"%f,",&x[k][h]);  //神经网络输入
		for(j=0;j<nj;j++) 
			fscanf(fp1,"%f,",&d[k][j]);  //神经网络输出
	} 
	for(h=0;h<nh;h++)
	{ 
		min=1;
		max=1; 
		for(k=0;k<nk;k++) 
		{ 
			if(x[k][h]<x[min][h]) min=k; 
			if(x[k][h]>x[max][h]) max=k; 
		} 
		xmin[h]=x[min][h]; 
		xmax[h]=x[max][h]; 
		for(k=0;k<nk;k++)				 /*神经网络输入归一化*/ 
			x[k][h]=(x[k][h]-xmin[h])/(xmax[h]-xmin[h]); 
		/*x[k][h]=x[k][h]/xmax[h];*/
	} 
	for(j=0;j<nj;j++) 
	{ 
		min=1;max=1; 
		for(k=0;k<nk;k++) 
		{ 
			if(d[k][j]<d[min][j])
				min=k; 
			if(d[k][j]>d[max][j]) 
				max=k; 
		} 
		dmin[j]=d[min][j]; 
		dmax[j]=d[max][j]; 
		for(k=0;k<nk;k++)				/*神经网络输出归一化*/ 
			d[k][j]=(d[k][j]-dmin[j])/(dmax[j]-dmin[j]); 
		/*d[k][j]=d[k][j]/dmax[j];*/
	}
}
/*----------------------------------------------------*/ 
void startlearning(void) 
{ 
	long int nt,n; 
	float t,error[nk],gerror,xj[nj],xi[ni],yj[nj],yi[ni],pxi[ni],pxj[nj];
	float u0=0,u1=0,u2=0,u3=0;
	float v0,v1,v2,v3;

	for(i=0;i<ni;i++) 
	{ 
		for(h=0;h<nh;h++) 
			whi[h][i]=-0.8+1.6*ranu();
		for(j=0;j<nj;j++) 
			wij[i][j]=-0.8+1.6*ranu();

		thi[i]=-0.5+ranu();
	} 
	for(j=0;j<nj;j++) 
		thj[j]=-0.5+ranu();
	fp2=fopen("w.txt","w+");			/*权值、阈值初始化*/


/*学习开始*/
	printf("\t\nPlease enter the learning times:\n"); 
	scanf("%ld",&nt);
	for(n=0;n<nt;n++)					/*学习次数*/
	{
		gerror=0; 
		for(k=0;k<nk;k++)				/*单样本循环*/ 
		{ 
			for(i=0;i<ni;i++) 
			{ 
				t=0; 
				for(h=0;h<nh;h++) 
					t+=whi[h][i]*x[k][h];
				xi[i]=t+thi[i];
				yi[i]=sigmoid(xi[i]);           /*隐层输出*/
			} 
			for(j=0;j<nj;j++) 
			{
				t=0;
				for(i=0;i<ni;i++)
					t+=wij[i][j]*yi[i];
				xj[j]=t+thj[j];
				yj[j]=sigmoid(xj[j]);
			}                                /*输出层输出*/

			for(j=0;j<nj;j++)				/*输出层单样本点误差变化率*/ 
				pxj[j]=yj[j]*(1-yj[j])*(yj[j]-d[k][j]);
			for(i=0;i<ni;i++)				/*隐层单样本点误差变化率*/ 
			{ 
				t=0;
				for(j=0;j<nj;j++)
					t+=pxj[j]*wij[i][j];
				pxi[i]=yi[i]*(1-yi[i])*t;
			}
			for(j=0;j<nj;j++)
			{
				//  thj[j]=thj[j]-nr*pxj[j];
				v0=thj[j];
				thj[j]=thj[j]-0.7*nr*pxj[j]+0.3*u0;
				// thj[j]=thj[j]-nr*pxj[j];
				u0=thj[j]-v0;
				for(i=0;i<ni;i++)
				{
					v1=wij[i][j];
					wij[i][j]=wij[i][j]-0.7*nr*pxj[j]*yi[i]+0.3*u1;
					u1=wij[i][j]-v1;
					//wij[i][j]=wij[i][j]-nr*pxj[j]*yi[i];     /*隐层到输出层权值修正，其中nr为步长*/
				}
			}
			for(i=0;i<ni;i++) 
			{
				v2=thi[i];
				thi[i]=thi[i]-0.7*nr*pxi[i]+0.3*u2;
				u2=thi[i]-v2;
				// thi[i]=thi[i]-nr*pxi[i];
				for(h=0;h<nh;h++)
				{
					v3=whi[h][i];
					whi[h][i]=whi[h][i]-0.7*nr*pxi[i]*x[k][h]+0.3*u3;
					u3=whi[h][i]-v3;
					//whi[h][i]=whi[h][i]-nr*pxi[i]*x[k][h];    /*输入层到隐层权值修正，其中nr为步长*/
				}
			}
			t=0; 
			for(j=0;j<nj;j++) 
				t+=(yj[j]-d[k][j])*(yj[j]-d[k][j])/2.0; 
			error[k]=t; 
			gerror+=error[k];							/*全局误差g(lobal)error*/ 
		}
		/*单样本循环结束*/ 

		if(gerror<EPS)
			break; 
	}
	/* 学习循环结束*/ 
	printf("%f,%f,%f,%f,%f,%f",thi[0],thj[0],wij[0][0],wij[0][1],whi[1][0],whi[0][1]);
	writew(); 
	printf("\t\nGlobal error=%f\n",gerror);
	printf("\t\nAre you satisfied with the global error?\n"); 
	printf("Press any key to choose a next task!\n"); 
	getch(); 
} 
/*-------------------------------------------------*/
void testsample(void) 
{
	float tx[nh],t,xj[nj],xi[ni],yj[nj],yi[ni]; 
	if(fp2==0) 
	{ 
		//   clrscr(); 
		printf("\t\ncan not find the weight file:w.txt\n"); 
		exit(0); 
	} 
	readw(); 

	
	for(ff=0;ff<test;ff++)                        /*测试样本预测、结果保存*/
	{
		for(h=0;h<nh;h++) 
			fscanf(fp3,"%f,",&tx[h]); 
		for(h=0;h<nh;h++) 
			tx[h]=(tx[h]-xmin[h])/(xmax[h]-xmin[h]); /*归一化处理*/
		for(i=0;i<ni;i++) 
		{ 
			t=0; 
			for(h=0;h<nh;h++) 
				t+=whi[h][i]*tx[h];
			xi[i]=t+thi[i];
			yi[i]=sigmoid(xi[i]);
		} 
		for(j=0;j<nj;j++) 
		{ 
			t=0; 
			for(i=0;i<ni;i++) 
				t+=wij[i][j]*yi[i];
			xj[j]=t+thj[j]; 
			yj[j]=sigmoid(xj[j]); 
		} 
		// printf("\t\nNetwork output:\n");        /*正向预测*/
		for(j=0;j<nj;j++)                         /*保存结果*/
		{ 
			yj[j]=yj[j]*(dmax[j]-dmin[j])+dmin[j]; 
			fprintf(fp4,"%f\n",yj[j]); 
		} 
		// tx[nh-1]=yj[0];
		//rewind(fp4); 
		//    for(h=0;h<nh;h++) /*测试样本输入*/
		// fscanf(fp3,"%f,",&tx[h]); 
 }

   printf("\t\nAre you satisfied with the output?\n"); 
   printf("Press any key to choose a next task!\n"); 
   getch();
} 
/*----------------------------------------------*/ 
void writew(void) 
{ 
rewind(fp2); 
for(h=0;h<nh;h++) 
 { 
  for(i=0;i<ni;i++) 
   fprintf(fp2,"%8.3f ",whi[h][i]); 
   fprintf(fp2,"\n"); 
 } 
fprintf(fp2,"\n"); 

for(i=0;i<ni;i++) 
 fprintf(fp2,"%8.3f ",thi[i]);
fprintf(fp2,"\n\n"); 

for(j=0;j<nj;j++) 
 { 
  for(i=0;i<ni;i++) 
   fprintf(fp2,"%8.3f ",wij[i][j]); 
  fprintf(fp2,"\n"); 
 } 
fprintf(fp2,"\n"); 
for(j=0;j<nj;j++) 
 fprintf(fp2,"%8.3f ",thj[j]); 
} 
/*------------------------------------------------*/ 
void readw(void) 
{ 
for(h=0;h<nh;h++) 
 for(i=0;i<ni;i++) 
   fscanf(fp2,"%f",&whi[h][i]); 
for(i=0;i<ni;i++) 
   fscanf(fp2,"%f",&thi[i]);
for(j=0;j<nj;j++) 
   for(i=0;i<ni;i++) 
      fscanf(fp2,"%f",&wij[i][j]); 
for(j=0;j<nj;j++) 
   fscanf(fp2,"%f",&thj[j]); 
} 
/*--------------------------------*/ 
float sigmoid(float a) 
{
	return (1.0/(1+exp(-a)));
}
/*--------------------------------*/ 
double ranu(void) 
{
	static double xrand=3.0; 
	double m=8589934592.0, a=30517578125.0; 
lp: xrand=fmod(xrand*a,m);     /*整除取余*/
   if(xrand>1.0) 
	   return(xrand/m); 
   else 
   {
	   xrand=1.0;
	   goto lp;
   }
}
/*----------------------------------*/ 

void main() 
{ 
fp1=fopen("sample.txt","r");
fp2=fopen("w.txt","r+");
fp3=fopen("test.txt","r+");
fp4=fopen("testre.txt","r+");
init();
  while(1)
 {
   system("cls"); 
   printf("\t\n    Please choose a next task...\n\n"); 
   printf("\t\n     (S) to start learning.\n"); 
   printf("\t\n     (T) to test samples.\n"); 
   printf("\t\n     (R) to resume learning.\n"); 
   printf("\t\n     (Q) quit.\n");
   switch(getchar()) 
  {
    case 's': startlearning();break; 
    case 't': testsample();break;
    case 'r': startlearning();break; 
    case 'q': exit(0);break; 
  } 
 }
fclose(fp1); 
fclose(fp2);
fclose(fp3);
fclose(fp4);
getch();
}

xhpJsp
关注
实现BP算法
DevScript的博客
09-03 108
我们首先定义了神经网络的结构，然后使用随机初始化的方式设置权重和偏置。接下来，我们实现了前向传播和反向传播函数，用于计算网络的输出和参数的梯度。我们可以设计一个包含一个输入层、一个或多个隐藏层和一个输出层的神经网络。BP（Backpropagation）算法是一种用于训练神经网络的常见算法，它通过反向传播误差来调整网络的权重和偏置，从而实现对输入数据的准确预测。作为输入，并返回包含每个连接的权重和偏置的梯度的字典。，其中包含了每个连接的权重和每个神经元的偏置。这个函数接受一个包含每个层的神经元数量的列表。
BP神经网络及python实现（详细）
weixin_66845445的博客
10-14 3万+
本篇文章关于BP神经网络的算法实现相对来说通俗易懂，讲解下至关于函数变量的解释，上至关于BP算法中涉及的前向传播及反向传播的原理、再至其过程中涉及的公式详细推导都有笔者的一些思考笔记。本文也对标准的BP神经网络进行几处改进，目的都是为了提高训练速度。另外，若文章存在一些理论错误请各位不吝赐教，当然，在阅读过程中若有些地方不明白可以在评论区留言！
BP算法实现
weixin_41099712的博客
09-26 1448
BP算法实现 简单的实现了一下经典的BP算法的核心代码，目的是为了加深一下对此算法的理解便于下一步的深入学习。参考了其程序 对BP算法进行理论推导，对其梯度下降、反向传播有了一定的理解，但一部分公式并未推导通；理解了学习率，步长的基础概念，但对于激发函数的意义、如何选激发函数还是不太理解。 背景 1986 年，Rumelhart、Hinton 和 Williams 联合 在《自然》杂志发表了著名的反向传播算法(BP)，首次阐述了 BP 算法在浅层前向型神经网络模型的应用，不但明显降低了最优化问题求解的运算
Neural Network with only Numpy sloves XOR 只用numpy的神经网络解决异或问题
weixin_41932943的博客
10-18 270
Neural Network with only Numpy sloves XOR copy and learn from: 神经网络，BP算法，计算图模型，代码实现跟详解. Copying with a few correction. This article helps you and me understanding the basic concept of NN and its engineering implementation with only Numpy. import numpy as n
MATLAB-BP神经网络算法实现
01-23
**MATLAB-BP神经网络算法实现** BP（Backpropagation）神经网络算法是人工神经网络中最常见的一种学习方法，主要用于训练多层前馈网络。它通过反向传播误差来调整网络权重，从而使得网络能够逐步逼近给定的训练数据...
Python实现BP神经网络算法.zip
12-26
Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 ...
算法介绍及实现——BP神经网络（基于Python-torch）
weixin_51009494的博客
05-29 6466
BP算法是我接触到的第一个算法，可谓是梦开始的地方，算法专栏用它作为开篇再合适不过了。 目录 1、什么是BP神经网络？ 2、BP神经网络的原理？ 3、BP神经网络如何实现？ 4、总结 1、什么是BP神经网络？ BPNN是一种当下的应用比较广泛的智能算法，是MLP的一种，是用于寻找数据集中非线性的、复杂的数据关系。它是基于生物神经网络的原型，对其进行抽象和模拟，模仿人脑思考问题的方式和方法，能很好的去发掘数据之间的相关性。其主要用去数据的建模和预测。其结果如下图所示： ...
标准BP算法matlab实现,简单易懂
yingzi的技术博客
04-10 7370
机器学习的实验课要求自编写一份简易的标准BP（神经网络）算法,我用matlab基本实现了，现将自己的思想记录下来，方便自己以后重温.话不多说，让我们进入正题 简要介绍 神经网络中最基本的成分是神经元模型,先简单提一个最简单的神经元模型M-P神经元模型 该神经元模型有两层：输入层,输出层。 其中输入层包含 n 个神经元,输出层包含 1 个神经元。 输入信号通过连接的权重wiw_iwi​到达输出神经元,总接收的输入值与阀值θ\thetaθ进行比较,然后通过"激活函数"处理以产生神经元的输出。这里介绍一个最具
BP算法基础与实现
qq_43660987的博客
06-23 5145
1，内容简介 BP算法（backpropagation,反向传播算法）的学习过程，由信息的正向传播和误差的反向传播两个过程组成。输入层各神经元介绍来自外界的输入信息，并传递给中间层各神经元。中间层是内部信息处理层，负责信息变换，根据信息变化能力的需求，中间层可以设计为单隐层或多隐层结构。最后一个隐层传递到输出层各神经元的信息，经过进一步处理后，完成一次正向的传播过程，由输出层向外界输出信息处理的结...
机器学习-10-神经网络python实现
IT从业者的成长历程
04-18 2020
本系列是机器学习课程的系列课程，主要介绍基于python实现神经网络。
深度学习之bp算法介绍及python代码实现
Hariod的博客
07-24 6270
目录1.bp算法介绍1.1 背景1.2 多层向前神经网络(Multilayer Feed-Forward Neural Network)1.3 神经网络结构的设计1.4 bp算法过程1.4.1 初始化1.4.2 正向更新神经元值1.4.3 反向更新权重与阈值1.4.4 算法停止1.5 bp算法举例2.bp算法理论推导3.bp算法代码举例新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右Smarty
图神经网络的实现,神经网络框架图
Supermen333的博客
08-10 2075
经过激活函数f（u）的作用得到隐含层1的输出信息：岩溶地区地下水与环境的特殊性研究经过激活函数f（u）的作用得到隐含层2的输出信息：岩溶地区地下水与环境的特殊性研究激活函数f（u）我们这里采用Sigmoid型，即f（u）=1/[1+exp（-u）]（6.5）隐含层的输出信息传到输出层，可得到最终输出结果为岩溶地区地下水与环境的特殊性研究以上过程为网络学习的信息正向传播过程。第二步：将已知的样本加到网络上，利用下式可算出他们的输出值yi，其值为岩溶地区地下水与环境的特殊性研究式中：xi为该节点的输入；...
神经网络——Python实现BP神经网络算法（理论+例子+程序）
Linyun2tt的博客
11-27 8万+
一、基于BP算法的多层感知器模型 采用BP算法的多层感知器是至今为止应用最广泛的神经网络，在多层感知器的应用中，以图3-15所示的单隐层网络的应用最为普遍。一般习惯将单隐层前馈网称为三层感知器，所谓三层包括了输入层、隐层和输出层。 算法最终结果采用梯度下降法，具体详细过程此处就省略了！ 二、BP算法的程序实现流程 三、标准BP算法的改进——增加动量项 标准BP算法在调整权值时，只按t时刻误差的梯度降方向调整，而没有考虑t时刻以前的梯度方向，从而常使训练过程发生振荡，收敛缓慢。为了提
【深度学习】神经网络和BP算法(含源码实现）
最新发布
qq_73301283的博客
07-27 535
该迭代过程循环进行，直到达到某些停止条件为止，例如训练误差达到一个很小的值。图给出了在2个属性、5个样本的西瓜数据上，随着训练样例的增加，网络参数和分类边界的变化情况。
BP神经网络的数学原理及其算法实现
热门推荐
学无常师，负笈不远险阻
03-25 11万+
BP神经网络，BP即Back Propagation的缩写，也就是反向传播的意思，顾名思义，将什么反向传播？文中将会解答。不仅如此，关于隐层的含义文中也会给出个人的理解。最后会用Java实现的BP分类器作为其应用以加深印象。 　　很多初学者刚接触神经网络的时候都会到网上找相关的介绍，看了很多数学原理之后还是云里雾里，然后会琢磨到底这个有什么用？怎么用？于是又到网上找别人写的代码，下下来之后看一眼发现代码写的很糟糕
BP算法实例及代码实现
SUFEHeisenberg的博客
04-14 2737
BP算法实例
BP算法（误差逆传播算法）简单实现
拟禾的个人技术博客
03-07 783
误差逆传播算法实例
Matlab环境下BP神经网络算法实现指南
资源摘要信息:"本资源为一个关于BP神经网络算法实现的Matlab程序和数据集。BP神经网络（Back Propagation Neural Network）是一种按照误差逆传播算法训练的多层前馈神经网络，广泛应用于模式识别、数据挖掘、信号...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值