Bp网络神经算法

最新推荐文章于 2022-12-26 20:02:54 发布
最新推荐文章于 2022-12-26 20:02:54 发布
阅读量2.1k 收藏 6
点赞数 1
分类专栏： 一些好玩的小程序 文章标签： 网络 output input 测试 struct float
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nemol1990/article/details/8093623
版权

***原型题目在2011年武汉科技大学程序设计大赛，百度文库上有，属于本人上传***

1、权阵可以手动输入，可以随机产生，也可以选择题目要求矩阵

2、手动设置误差限，学习率，隐藏结点等

3、对结果采用模糊语言输出。


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

#define OUT 2     //输出向量维数
#define IN  2     //输入向量维数
#define NUM     20     //样本数量
#define Loop_MAX 524280 //最大循环次数
#define dot_MAX 20 //最大结点个数

typedef struct   //bp人工神经网络结构
{
    int dot;             //隐层节点数
    double v[IN][dot_MAX];     //输入层权矩阵
	double u[dot_MAX][dot_MAX];		//隐藏层权矩阵
    double w[dot_MAX][OUT];    //输出层权矩阵
    double rate;          //学习率
    double error;          //允许误差限
} bp_net;

double fnet(double net)   //Sigmoid函数
{ 
    return 1/(1+exp(-net));
}

void Initialize_Bp(bp_net *bp)   //初始化bp网络
{
    
    printf("请输入隐层结点数：\n");    
    scanf("%d", &(*bp).dot);
    
    printf("请输入学习率：\n");
    scanf("%lf", &(*bp).rate); 
	
    printf("请输入允许误差限：\n");
    scanf("%lf", &(*bp).error);
	
    int i, j;
    srand((unsigned)time(NULL));	//随机函数产生随机权矩阵
    for (i = 0; i < IN; i++) 
        for (j = 0; j < (*bp).dot; j++)
            (*bp).v[i][j] = rand() / (double)(RAND_MAX);    
		
		for (i = 0; i < (*bp).dot; i++) 
			for (j = 0; j < (*bp).dot; j++)
				(*bp).u[i][j] = rand() / (double)(RAND_MAX); 
			
			for (i = 0; i < (*bp).dot; i++) 
				for (j = 0; j < OUT; j++)
					(*bp).w[i][j] = rand() / (double)(RAND_MAX);  
				
				printf("初始化输入权矩阵：\n");
				for (i = 0; i < IN; i++) 
				{
					for (j = 0; j < (*bp).dot; j++)
						printf("%lf   ",(*bp).v[i][j]); 
					printf("\n");
				}
				printf("初始化隐藏层权矩阵：\n");
				for (i = 0; i < (*bp).dot; i++) 
				{
					for (j = 0; j < (*bp).dot; j++)
						printf("%lf   ",(*bp).u[i][j]); 
					printf("\n");
				}
				printf("初始化输出权矩阵：\n");
				for (i = 0; i < (*bp).dot; i++) 
				{
					for (j = 0; j < OUT; j++)
						printf("%lf   ",(*bp).w[i][j]); 
					printf("\n");
				}
				printf("\n");
}

void Train_Bp(bp_net *bp, double x[NUM][IN], int y[NUM][OUT])  //训练bp网络
{
    double e = (*bp).error;               //允许误差限       
    double rate = (*bp).rate;             //学习率         
    int dot = (*bp).dot;                  //隐藏层结点      
    double v[IN][dot_MAX], w[dot_MAX][OUT],u[dot_MAX][dot_MAX];  //权矩阵
    double Error_Input[dot_MAX],Error_hider[dot_MAX], Error_Output[OUT];       //各个结点的反向误差
    double Input[dot_MAX],hider[dot_MAX], Output[OUT];             //各个层的结点输出
    int i, j, k, n,flag;                                 //flag为是否继续修改权矩阵标志量
    double temp,t;
	
    for (i = 0; i < IN; i++)                     //复制结构体中的权矩阵 
        for (j = 0; j < dot; j++)
            v[i][j] = (*bp).v[i][j];
		
		for (i = 0; i < dot; i++)
			for (j = 0; j < dot; j++)
				u[i][j] = (*bp).u[i][j];
			
			for (i = 0; i < dot; i++)
				for (j = 0; j < OUT; j++)
					w[i][j] = (*bp).w[i][j];
				
				
				for (n = 0;n<Loop_MAX; n++)       //反向误差计算
				{ 
					flag=1;
					for (i= 0; i < NUM; i++) 
					{ 
						for (k= 0; k < dot; k++)       //计算输入层输出向量
						{      
							temp = 0;
							for (j = 0; j < IN; j++)
								temp+= x[i][j] * v[j][k];    
							Input[k] = fnet(temp);
						}
						for (k= 0; k < dot; k++)         //计算隐藏层输出向量
						{      
							temp = 0;
							for (j = 0; j < dot; j++)
								temp+=Input[j] * u[j][k];    
							hider[k] = fnet(temp);
						}
						for (k = 0; k < OUT; k++)          //计算输出层输出向量
						{
							temp = 0;
							for (j = 0; j < dot; j++)
								temp += hider[j] * w[j][k];
							Output[k] = fnet(temp);
						}
						
						for (j = 0; j < OUT ; j++)       //测试结果与是否在误差范围内
						{
							t=(y[i][j]-Output[j])*(y[i][j]-Output[j]);   
							t=sqrt(t);							//求输出结果与理想输出的误差的绝对值(abs()函数忽略掉小数部分，故不能用)
							if(t<e)
								continue;                      //如果满足精度要求，则继续测试下一个结点的情况
							else
							{
								flag=0;                      //修改了权矩阵
								for (j = 0; j < OUT; j++)                  
									Error_Output[j] = (y[i][j] - Output[j]);
								
								for (j = 0; j < dot; j++)  //计算隐层权修改量
								{       
									temp = 0;
									for (k = 0; k < OUT; k++)
										temp += w[j][k] * Error_Output[k];
									Error_hider[j] = temp * hider[j]*(1-hider[j]);
								}
								for (j = 0; j < dot; j++)           //修改输出层权矩阵
									for (k = 0; k < OUT; k++)
										w[j][k]+= rate * hider[j] * Error_Output[k]; 
									
									for(j=0;j<dot;j++)
									{
										temp=0;
										for(k=0;k<dot;k++)
											temp+=u[j][k]*Error_hider[k];
										Error_Input[j]=temp*Input[j]*(1-Input[j]);
									}
									
									for (j = 0; j < dot; j++)
										for (k = 0; k < dot; k++)
											u[j][k]+= rate * Input[j] * Error_hider[k];
										
										for(j=0;j<IN;j++)
											for(k=0;k<dot;k++)
												v[j][k]+=rate*x[i][j]*Error_Input[k];
											break; //如果一个实例的第一个输出结果不满足精度条件，修改权矩阵后，继续学习下一个实例。
											
							}
						}
					}
					if(!flag)
						continue;
					else
						break;
				}
				
				printf("总共循环次数：%d\n", n);
				printf("\n");
				
				printf("修改后的输入权矩阵：\n");   //输出修改后的输入层权矩阵
				for (i = 0; i < IN; i++) 
				{    
					for (j = 0; j < dot; j++)
						printf("%f    ", v[i][j]);    
					printf("\n");
				}
				printf("修改后的隐藏层权矩阵：\n");  //输出修改后的隐藏层权矩阵
				for (i = 0; i < dot; i++) 
				{    
					for (j = 0; j < dot; j++)
						printf("%f    ", u[i][j]);    
					printf("\n");
				}
				printf("修改后的输出层权矩阵：\n");  //输出修改后的输出权矩阵
				for (i = 0; i < dot; i++) 
				{
					for (j = 0; j < OUT; j++)
						printf("%f    ", w[i][j]);    
					printf("\n");
				}
				
				for (i = 0; i < IN; i++)             //将修改后的输入层权矩阵返回给bp结构体 
					for (j = 0; j < dot; j++)
						(*bp).v[i][j] = v[i][j];
					
					for (i = 0; i < dot; i++)			//将修改后的隐藏层权矩阵返回给bp结构体
						for (j = 0; j < dot; j++)
							(*bp).u[i][j] = u[i][j];
						
						for (i = 0; i < dot; i++)			//将修改后的输出层权矩阵返回给bp结构体
							for (j = 0; j < OUT; j++)
								(*bp).w[i][j] = w[i][j];
							
							printf("bp网络训练结束！\n");
}

void Use_Bp(bp_net *bp)    //使用bp网络测试结果
{
    float Input[IN];    //输入实例
    double Output_In[dot_MAX];   //输入层输出
    double Output_Hi[dot_MAX];      //隐藏层输出
	double Output_Ou[OUT];		//输出层输出
	double temp;
    while (1) 
	{                 
        printf("请输入一个实例：\n");
        int i, j;
        for (i = 0; i <IN ; i++)
            scanf("%f", &Input[i]);
        for (i = 0; i < (*bp).dot; i++)    //计算输入层输出
		{
            temp = 0;
            for (j = 0; j < IN; j++)
                temp += Input[j] * (*bp).v[j][i];
            Output_In[i] = fnet(temp);
        }
		for (i = 0; i < (*bp).dot; i++)		//计算隐藏层输出
		{
            temp = 0;
            for (j = 0; j < (*bp).dot; j++)
                temp += Output_In[j] * (*bp).u[j][i];
            Output_Hi[i] = fnet(temp);
        }
        for (i = 0; i < OUT; i++)			//计算输出层输出
		{
            temp = 0;
            for (j = 0; j < (*bp).dot; j++)
                temp += Output_Hi[j] * (*bp).w[j][i];
            Output_Ou[i] = fnet(temp);
        }
        printf("bp网络计算结果：   \n");
		printf("\n");

        for (i = 0; i < OUT; i++)
		{
            printf("%.6f ", Output_Ou[i]);
			if(Output_Ou[i]>=1)
				printf("   肯定是！\n");
			else
				switch((int)(Output_Ou[i]*10))
			{
			case 0:printf("    肯定不是！");break;
			case 1:printf("    稍稍像是！");break;
			case 2:printf("    有点像是！");break;
			case 3:printf("    有些像是！");break;
			case 4:printf("    比较像是！");break;
			case 5:printf("    差不多是！");break;
			case 6:printf("    相当是！");break;
			case 7:printf("    很是！");break;
			case 8:printf("    极是！");break;
			case 9:printf("    几乎是！");break;
			}
			printf("\n");
		}
	}
}
	
	void main(void)
	{
		double x[NUM][IN]=       //训练样本
		{
			{0.05,0.02}, 
			{0.09,0.11},
			{0.12,0.20},
			{0.15,0.22},
			{0.20,0.25},
			{0.75,0.75},
			{0.80,0.83},
			{0.82,0.80},
			{0.90,0.89},
			{0.95,0.89},
			{0.09,0.04},
			{0.10,0.10},
			{0.14,0.21},
			{0.18,0.24},
			{0.22,0.28},
			{0.77,0.78},
			{0.79,0.81},
			{0.84,0.82},
			{0.94,0.93},
			{0.98,0.99},
		}; 
		int y[NUM][OUT] =   //理想输出
		{
			{1,0},
			{1,0},
			{1,0},
			{1,0},
			{1,0},
			{0,1},
			{0,1},
			{0,1},
			{0,1},
			{0,1},
			{1,0},
			{1,0},
			{1,0},
			{1,0},
			{1,0},
			{0,1},
			{0,1},
			{0,1},
			{0,1},
			{0,1},
		};
		bp_net bp;						//定义bp结构体
		Initialize_Bp(&bp);              //初始化bp网络结构
		Train_Bp(&bp, x, y);             //训练bp神经网络
		Use_Bp(&bp);                     //测试bp神经网络
	}


王尼莫
关注
专栏目录
【CVPR‘24】BP-Net：用于深度补全的双边传播网络，新 SOTA！
梁瑛平的博客
08-28 843
深度补全任务旨在从稀疏的深度测量数据和同步的彩色图像中生成密集的深度图。现有的最先进方法多为基于传播的，通常作为对初始估计的密集深度的迭代改进。然而，这些初始深度估计通常直接将卷积层应用于稀疏深度图。在本文中，我们提出了一种双边传播网络（BP-Net），在最早阶段进行深度传播，以避免直接在稀疏数据上进行卷积。具体而言，我们的方法通过一个非线性模型从附近的深度测量中传播目标深度，该模型的系数由一个多层感知器生成，并基于辐射差异和空间距离进行调整。
BP人工神经网络C代码（转）
尼欧
08-20 1292
#include #include #include #include #define OUT_COUT 2 //输出向量维数 #define IN_COUT 3 //输入向量维数 #define COUT 6 //样本数量 typedef struct { //bp人工神经网络结构 int h; //实际使用
BP神经网络计算实例
XuFangfang5206的博客
06-27 1787
BP网络推导过程以及例子
ZJE
03-20 5423
*****（不关心推导过程的，可以直接从“四”开始看例子）***** BP神经网络： 以只有一个隐藏层的BP神经网络为例： 1.隐藏层和输出层的激活函数f1和f2都用Sigmodi函数，即：，因为BP网络的激活函数必须可导，所以Sigmoid函数是可取的选择。 2.当BP网络反向调整网络权值时，激活函数的导数是经常用到的，因此我们先对激活函数f(x)求导： 所以: 重要： ...
深度学习 前馈神经网络 手动推导 作业三
weixin_51395608的博客
10-01 1351
深度学习，前馈神经网络，
DeepLearning:四、BP神经网络
王谦的专栏
08-25 2598
前面简单的认识了一下神经网络，这里我要与大家分享的是神经网络中的大明星：BP算法。下面的内容主要是来自斯坦福大学的教程，这篇教程是我看过的所有BP相关教程中最好的，其中补充了一些内容。
BP神经网络算法基本原理,bp神经网络的算法步骤
Supermen333的博客
08-22 1万+
（一）方法原理人工神经网络是由大量的类似人脑神经元的简单处理单元广泛地相互连接而成的复杂的网络系统。理论和实践表明，在信息处理方面，神经网络方法比传统模式识别方法更具有优势。人工神经元是神经网络的基本处理单元，其接收的信息为x1，x2，…，xn，而ωij表示第i个神经元到第j个神经元的连接强度或称权重。神经元的输入是接收信息X＝（x1，x2，…，xn）与权重W＝｛ωij｝的点积，将输入与设定的某一阈值作比较，再经过某种神经元激活函数f的作用，便得到该神经元的输出Oi。常见的激活函数为Sigmoid型。人工神
代码 基于遗传算法的Bp神经网络优化算法代码
06-04
代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化...
BP神经网络(LM),bp神经网络lm算法,matlab
09-10
在本项目中，BP神经网络是通过Levenberg-Marquardt（LM）算法进行训练的，这是一种在优化问题中寻找最小值的有效方法，特别适用于训练神经网络时的权重调整。 LM算法结合了梯度下降法和牛顿法的优点，它在迭代过程...
基于遗传算法的BP神经网络优化算法_基于遗传算法的BP神经网络优化算法_matlab_遗传神经网络_遗传算法_优化MATLAB_
09-29
**基于遗传算法的BP神经网络优化算法** 在人工智能和机器学习领域，BP（Backpropagation）神经网络是一种广泛应用的监督学习模型，它通过反向传播误差来调整权重，以达到训练数据的最佳拟合。然而，BP神经网络在...
基于遗传算法的BP神经网络优化算法.zip_遗传算法 _遗传算法 BP_遗传算法，bp
07-15
**遗传算法与BP神经网络优化** 遗传算法（Genetic Algorithm, GA）是一种模拟自然选择和遗传过程的全局优化方法，由John H. Holland在20世纪60年代提出。它通过模拟生物进化过程中的基因重组、突变和自然选择等机制...
一文弄懂神经网络中的反向传播法——BackPropagation
weixin_30757793的博客
06-30 3429
　　最近在看深度学习的东西，一开始看的吴恩达的UFLDL教程，有中文版就直接看了，后来发现有些地方总是不是很明确，又去看英文版，然后又找了些资料看，才发现，中文版的译者在翻译的时候会对省略的公式推导过程进行补充，但是补充的又是错的，难怪觉得有问题。反向传播法其实是神经网络的基础了，但是很多人在学的时候总是会遇到一些问题，或者看到大篇的公式觉得好像很难就退缩了，其实不难，就是一个链式求导法则反复用。...
BP神经网络计算过程详解，用笔手算一遍弄懂反向传播
热门推荐
dare_kz的博客
08-26 6万+
现在很多人都说，做it门槛很低，脑子灵活点，愿意去熬的，培训个几个月就可以，无非是调调函数而已。 确实，现在一些程序员的工作，调调函数掌握得好的话，也是能够胜任的。但是，想要更进一步，还得不断提升自己，努力理解各种算法结构。 (类)神经网络算法在深度学习等领域应用十分广泛。 而负反馈BP神经网络其中应用最多的一种，一起来试试手算理解神经网络吧。
解释这行代码 c = ((double)rand() / RAND_MAX) * (a + b - fabs(a - b)) + fabs(a - b);
最新发布
weixin_35753291的博客
12-26 447
这行代码的作用是随机生成一个浮点数，范围在 a 和 b 之间(包括 a 和 b)。 其中，rand() 函数是 C 语言标准库中的一个函数，用于生成一个伪随机整数。RAND_MAX 是一个常量，它表示 rand() 函数生成的随机数的最大值。 因此，(double)rand() / RAND_MAX 表示生成的随机数在 [0, 1] 之间的浮点数。 然后，将这个随机数乘上 (a - b) - fa...
Pytorch框架应用系列 之 BPNet 5-1：从零开始！你的第一个神经网络！（综述）
打团不但人不齐，而且人多看不清
12-30 1713
Pytorch框架应用系列专题项目1：BP网络（综述）
srand和rand函数使用
SDU_st的博客
04-20 2492
函数一：int rand(void)； 功能：产生随机值，从srand (seed)中指定的seed开始，返回一个[seed, RAND_MAX（0x7fff）)间的随机整数。 函数二：void srand(unsigned seed)； 参数seed是rand()的种子，用来初始化rand()的起始值。 可以认为rand()在每次被调用的时候，它会查看： 1） 如果用户在此之前调用过srand(seed)，给seed指定了一个值，那么它会自动调用 srand(seed)一次来初始化它的起始值。 2） 如果
关于rand函数的一些使用
a12344447的博客
02-23 2448
问：如何缩放rand函数的返回值？答：在C中，rand() % 32会产生一个[0, 32)之间的伪随机数，那么rand() % 32 + 1的取值区间实际上是[1, 33)。       要产生[0, 32)（开区间）之间伪随机数：rand() % 32即可；       要产生[0, 32]（闭区间）之间伪随机数：rand() % 33即可。                          ...
随机数函数
zn2016的博客
12-12 5299
说明：    1、这两个函数都在头文件是stdlib.h中。    2、rand()函数和srand()函数必须配套使用。 (1) rand()函数:    原型: int rand(void)    功能: 产生从0到RAND_MAX(0x7fff）之间的随机数。    头文件: stdlib.h    例:    #include    #i
Java实现BP神经网络算法详解
"该资源是关于使用Java实现BP神经网络算法的一个代码片段，包含了神经网络节点（Node）类的定义，包含激活值、阈值、权重等关键属性以及构造函数来初始化这些属性。" BP神经网络（Backpropagation Neural Network）...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值