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神经网络
	}


王尼莫
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
bp 神经网络算法.zip
10-18
bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法...
一文弄懂神经网络中的反向传播法——BackPropagation
weixin_30757793的博客
06-30 3334
　　最近在看深度学习的东西，一开始看的吴恩达的UFLDL教程，有中文版就直接看了，后来发现有些地方总是不是很明确，又去看英文版，然后又找了些资料看，才发现，中文版的译者在翻译的时候会对省略的公式推导过程进行补充，但是补充的又是错的，难怪觉得有问题。反向传播法其实是神经网络的基础了，但是很多人在学的时候总是会遇到一些问题，或者看到大篇的公式觉得好像很难就退缩了，其实不难，就是一个链式求导法则反复用。...
BP神经网络计算实例
XuFangfang5206的博客
06-27 1696
BP神经网络计算过程详解，用笔手算一遍弄懂反向传播
热门推荐
dare_kz的博客
08-26 6万+
现在很多人都说，做it门槛很低，脑子灵活点，愿意去熬的，培训个几个月就可以，无非是调调函数而已。 确实，现在一些程序员的工作，调调函数掌握得好的话，也是能够胜任的。但是，想要更进一步，还得不断提升自己，努力理解各种算法结构。 (类)神经网络算法在深度学习等领域应用十分广泛。 而负反馈BP神经网络其中应用最多的一种，一起来试试手算理解神经网络吧。
深度学习 前馈神经网络 手动推导 作业三
weixin_51395608的博客
10-01 970
深度学习，前馈神经网络，
BP网络推导过程以及例子
ZJE
03-20 4759
*****（不关心推导过程的，可以直接从“四”开始看例子）***** BP神经网络： 以只有一个隐藏层的BP神经网络为例： 1.隐藏层和输出层的激活函数f1和f2都用Sigmodi函数，即：，因为BP网络的激活函数必须可导，所以Sigmoid函数是可取的选择。 2.当BP网络反向调整网络权值时，激活函数的导数是经常用到的，因此我们先对激活函数f(x)求导： 所以: 重要： ...
MATLAB BP神经网络算法
05-03
自己写的BP神经网络算法，经测试可以实现自主学习使结果不断接近目标输出
Python实现BP神经网络算法
03-02
BP 神经网络算法的基本理论和实现步骤： 神经网络架构： BP 神经网络通常由输入层、隐藏层和输出层构成。每个层中有多个神经元，神经元之间通过权重连接。 前向传播： 将输入样本输入到网络中，通过前向传播计算...
Python实现BP神经网络算法.zip
12-26
Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 ...
BP神经网络算法1
08-08
3、后向传播：根据公式修正权值和阈值直到满足终止条件 2、关于终止条件，可以有多种形式：§ 前一周期所有的都太小，小于某个指定的阈值 2、 网络结构的选择 3、
c++随机数
DLaugust的博客
03-13 520
rand()函数 rand()函数随机生成0-RAND_MAX范围内的整数，RAND_MAX至少为32767（(2e+15)-1）。 用法：int rand() 头文件：#include<cstdlib> 要点：rand()产生的其实是伪随机数，它是由数学公式计算出来的，每次执行随机数都一样，要想不同，就用srand()函数设置一个随机数种子。srand()函数为定义时，默认为srand(1). srand()函数 srand函数为rand()函数设置一个随机数种子，srand函数里参数相同随机
解释这行代码 c = ((double)rand() / RAND_MAX) * (a + b - fabs(a - b)) + fabs(a - b);
weixin_35753291的博客
12-26 350
这行代码的作用是随机生成一个浮点数，范围在 a 和 b 之间(包括 a 和 b)。 其中，rand() 函数是 C 语言标准库中的一个函数，用于生成一个伪随机整数。RAND_MAX 是一个常量，它表示 rand() 函数生成的随机数的最大值。 因此，(double)rand() / RAND_MAX 表示生成的随机数在 [0, 1] 之间的浮点数。 然后，将这个随机数乘上 (a - b) - fa...
Pytorch框架应用系列 之 BPNet 5-1：从零开始！你的第一个神经网络！（综述）
打团不但人不齐，而且人多看不清
12-30 1496
Pytorch框架应用系列专题项目1：BP网络（综述）
BP人工神经网络的介绍与实现
weixin_34081595的博客
12-10 440
神经网络概念与适合领域 神经网络最早的研究是 40 年代心理学家 Mcculloch 和数学家 Pitts 合作提出的 ，他们提出的MP模型拉开了神经网络研究的序幕。 神经网络的发展大致经过 3 个阶段：1947～1969 年为初期，在这期间科学家们提出了许多神经元模型和学习规则，如 MP 模型、HEBB 学习规则和感知器等；60 年代末期至 80 年代中期，神经网络控制与整个神经网络研究一样...
srand和rand函数使用
SDU_st的博客
04-20 2420
函数一：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） 如果
C/C++编程笔记：C语言 rand() 随机函数，深入解析程序随机数！
致力于C语言C++知识分享！
07-02 1376
各种编程语言返回的随机数（确切地说是伪随机数）实际上都是根据递推公式计算的一组数值，当序列足够长，这组数值近似满足均匀分布。 C的标准函数库提供一随机数生成器rand（定义在stdlib.h），能返回0~RAND_MAX之间均匀分布的伪随机整数（RAND_MAX至少为32767，一般都默认为32767）。 用rand()随机生成在[x,y]内的整数 int k; k=x+rand()%(y-x+1)，k即为所求范围内随机生成的数，rand()%a的结果最大为a-1. rand()%20的意思.
关于rand函数的一些使用
a12344447的博客
02-23 2400
问：如何缩放rand函数的返回值？答：在C中，rand() % 32会产生一个[0, 32)之间的伪随机数，那么rand() % 32 + 1的取值区间实际上是[1, 33)。       要产生[0, 32)（开区间）之间伪随机数：rand() % 32即可；       要产生[0, 32]（闭区间）之间伪随机数：rand() % 33即可。                          ...
随机数函数
zn2016的博客
12-12 5263
说明：    1、这两个函数都在头文件是stdlib.h中。    2、rand()函数和srand()函数必须配套使用。 (1) rand()函数:    原型: int rand(void)    功能: 产生从0到RAND_MAX(0x7fff）之间的随机数。    头文件: stdlib.h    例:    #include    #i
BP（Back Propagation）神经网络——原理篇
AXYZdong的博客
08-24 2万+
神经网络控制是20世纪80年代以来，在人工神经网络（Artificial Neural Networks，ANN）研究取得的突破性进展基础上发展起来的自动控制领域的前沿学科之一。本文主要介绍神经网络、感知器网络、BP神经网络和9 行代码实现BP神经网络，以自学过程中的心得为主。
BP神经网络算法的优势
最新发布
05-08
BP神经网络算法是一种常见的人工神经网络算法，其优势主要体现在以下几个方面： 1. BP神经网络算法可以逼近任意非线性函数。这意味着它可以解决许多复杂的问题，如图像识别、语音识别等。 2. BP神经网络算法具有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值