C语言单隐含层BP神经网络代码实现

最新推荐文章于 2023-09-04 20:20:14 发布
最新推荐文章于 2023-09-04 20:20:14 发布
阅读量479 收藏 10
点赞数
分类专栏： C语言 文章标签： 神经网络 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45454343/article/details/118277610
版权 
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define Data  10		// 数据样本个数
#define Data2  2		// 测试样本个数
#define In 3			// 神经网络输入维度
#define Out 2			// 神经网络输出维度
#define Neuron 10		// 隐含层神经元个数
//#define RAND_MAX 100	// 最大随机数


//float x[10] = { 1,2,3,4,5,6,7,8,9,10 };
//float y[10] = { 1,4,9,16,25,36,49,64,81,100 };
int i, j, k, jj;
float J;
float Jnum;
float Hidden_in[Neuron], Hidden_out[Neuron], ds_Hidden[Neuron];
float Weight_in[Neuron][In], Bias_in[Neuron], Weight_out[Out][Neuron], Bias_out[Out];
float Weight_in_zhong[Neuron][In], Bias_in_zhong[Neuron], Weight_out_zhong[Out][Neuron], Bias_out_zhong[Out];
float Weight_in_old[Neuron][In], Bias_in_old[Neuron], Weight_out_old[Out][Neuron], Bias_out_old[Out];
float y_pre[Out], e[Out];
float xminmax[In][2];
float yminmax[Out][2];
float x[In], y[Out];

float dJ_de[Out], de_dym[Out];
float dym_dwif[Neuron][In], dJ_dwif[Neuron][In];
float dym_dbif[Neuron], dJ_dbif[Neuron];
float dym_dwof[Out][Neuron], dJ_dwof[Out][Neuron];
float dym_dbof[Out], dJ_dbof[Out];


// 神经网络激活函数输出计算
float calInspirit(float x, int mode1)
{
	float y = 0;
	if (mode1 == 0)		//sigmoid
	{
		y = 1 + (float)exp(-x);
		y = 1 / y;
	}
	else if (mode1 == 1)	//tanh
	{
		y = ((float)exp(x) - (float)exp(-x)) / ((float)exp(x) + (float)exp(-x));
	}
	else if (mode1 == 2)	//teshu
	{
		y = (1 - (float)exp(-x)) / (1 + (float)exp(-x));
	}
	return y;
}


// 神经网络激活函数导数计算
float caldsInspirit(float x, int mode1)
{
	float Sx, dSx = 0;
	float aa, bb, cc, dd, aaa;
	if (mode1 == 0)		//sigmoid
	{
		dSx = (float)exp(-x)/ (1 + (float)exp(-x)) / (1 + (float)exp(-x));
	}
	else if (mode1 == 1)	//tanh
	{
		//aaa = exp(0.1);
		//aa = ((float)exp(x) - (float)exp(-x));
		//bb = ((float)exp(x) + (float)exp(-x));
		//cc = aa / bb;
		//dd = 1 - cc*cc;
		//Sx = ((float)exp(x) - (float)exp(-x)) / ((float)exp(x) + (float)exp(-x));
		//dSx = 1 - Sx*Sx;
		dSx = 1-((float)exp(x) - (float)exp(-x)) / ((float)exp(x) + (float)exp(-x))*((float)exp(x) - (float)exp(-x)) / ((float)exp(x) + (float)exp(-x));
	}
	else if (mode1 == 2)	//teshu
	{
		dSx = 2* (float)exp(-x) / (1+ (float)exp(-x))/ (1 + (float)exp(-x));
	}
	return dSx;
}


// 初始化神经网络参数
void netInit()
{
	for (j = 0; j < Neuron;j++)
	{
		for (i = 0; i < In; i++)
		{
			Weight_in[j][i] = rand() / (float)(RAND_MAX)*0.1;
			Weight_in_old[j][i] = Weight_in[j][i];
			Weight_in_zhong[j][i] = Weight_in[j][i];
		}
		Bias_in[j]= rand() / (float)(RAND_MAX)*0.1;
		Bias_in_old[j] = Bias_in[j];
		Bias_in_zhong[j] = Bias_in[j];
	}
	for (k = 0; k < Out; k++)
	{
		for (j = 0; j < Neuron; j++)
		{
			Weight_out[k][j] = rand() / (float)(RAND_MAX)*0.1;
			Weight_out_old[k][j] = Weight_out[k][j];
			Weight_out_zhong[k][j] = Weight_out[k][j];
		}
		Bias_out[k] = rand() / (float)(RAND_MAX)*0.1;
		Bias_out_old[k] = Bias_out[k];
		Bias_out_zhong[k] = Bias_out[k];
	}
}


// 神经网络输出计算
void network(float *data_in, float *data_out, float data_in_col, float Hiden_col,float data_out_col, int model)
{
	// 输入层到隐含层 输入层维度用i 隐含层用j 输出层用k
	for (j = 0; j < Hiden_col; j++)
	{
		Hidden_in[j] = 0;
		for (i = 0; i < data_in_col; i++)
		{
			Hidden_in[j] = Hidden_in[j] + Weight_in[j][i] * data_in[i];
		}
		Hidden_in[j] = Hidden_in[j] + Bias_in[j];
	}
	// 隐含层激活函数
	for (j = 0; j < Hiden_col; j++)
	{
		Hidden_out[j] = calInspirit(Hidden_in[j], model);
		// Hidden[j] = 1 / (1 + exp(-Hidden[j]));	// sigmoid
		// Hidden[j] = (exp(Hidden[j])- exp(-Hidden[j])) / (exp(Hidden[j]) + exp(-Hidden[j]));	// tanh
		//Hidden[j] = (1 - exp(-Hidden[j])) / (1 + exp(-Hidden[j]));
		// Hidden[j] = 2 / (1 + exp(-2*Hidden[j])) - 1;
		ds_Hidden[j] = caldsInspirit(Hidden_in[j], model);
	}
	// 隐含层到输出层
	for (k = 0; k < 4; k++)
	{
		data_out[k] = 0;
		for (j = 0; j < 17; j++)
		{
			data_out[k] = data_out[k] + Weight_out[k][j] * Hidden_out[j];
		}
		data_out[k] = data_out[k] + Bias_out[k];
	}
}


// 计算神经网络输出误差
float calSSE(float *net_output, float *data_output)
{
	J = 0;
	for (k = 0; k < Out; k++)
	{
		e[k] = net_output[k] - data_output[k];
		J = J + (float)e[k] * (float)e[k] * 0.5;
	}
	return J;
}


// 神经网络反向传播
void backword(float *net_input,float a, float alfa)
{
	for (j = 0; j < Neuron; j++)
	{
		for (i = 0; i < In; i++)
		{
			dJ_dwif[j][i] = 0;
		}
		dJ_dbif[j] = 0;
	}
	for (k = 0; k < Out; k++)
	{
		dJ_de[k] = e[k];
		de_dym[k] = 1;

		for (j = 0; j < Neuron; j++)
		{
			for (i = 0; i < In; i++)
			{
				dym_dwif[j][i] = Weight_out[k][j] * ds_Hidden[j] * net_input[i];

				dJ_dwif[j][i] = dJ_dwif[j][i] + dJ_de[k] * de_dym[k] * dym_dwif[j][i];
			}
			dym_dbif[j] = Weight_out[k][j] * ds_Hidden[j] * 1;
			dJ_dbif[j] = dJ_dbif[j] + dJ_de[k] * de_dym[k] * dym_dbif[j];

			dym_dwof[k][j] = Hidden_out[j];
			dJ_dwof[k][j]= dJ_de[k] * de_dym[k] * dym_dwof[k][j];
		}
		dym_dbof[k] = 1;
		dJ_dbof[k] = dJ_de[k] * de_dym[k] * dym_dbof[k];
	}
	for (j = 0; j < Neuron; j++)
	{
		for (i = 0; i < In; i++)
		{
			Weight_in[j][i] = Weight_in[j][i]-a*dJ_dwif[j][i]+alfa*(Weight_in_zhong[j][i]- Weight_in_old[j][i]);

			Weight_in_old[j][i] = Weight_in_zhong[j][i];
			Weight_in_zhong[j][i] = Weight_in[j][i];
		}
		Bias_in[j] = Bias_in[j] - a*dJ_dbif[j] + alfa*(Bias_in_zhong[j] - Bias_in_old[j]);

		Bias_in_old[j] = Bias_in_zhong[j];
		Bias_in_zhong[j] = Bias_in[j];
	}
	for (k = 0; k < Out; k++)
	{
		for (j = 0; j < Neuron; j++)
		{
			Weight_out[k][j] = Weight_out[k][j] - a*dJ_dwof[k][j] + alfa*(Weight_out_zhong[k][j] - Weight_out_old[k][j]);

			Weight_out_old[k][j] = Weight_out_zhong[k][j];
			Weight_out_zhong[k][j] = Weight_out[k][j];
		}
		Bias_out[k] = Bias_out[k] - a*dJ_dbof[k] + alfa*(Bias_out_zhong[k] - Bias_out_old[k]);

		Bias_out_old[k] = Bias_out_zhong[k];
		Bias_out_zhong[k] = Bias_out[k];
	}
	
}


void train(float data_in[In][Data], float data_out[Out][Data], int maxepoch, int model, float a, float alfa)
{
	netInit();
	printf("神经网络开始训练：\n");
	Jnum = Data;
	int epoch = 0;
	while (Jnum / Data >= 0.000001)
	{
		Jnum = 0;
		epoch = epoch + 1;
		for (int num = 0; num < Data; num++)
		{
			for (i = 0; i < In; i++)
			{
				x[i] = data_in[i][num];
			}
			for (k = 0; k < Out; k++)
			{
				y[k] = data_out[k][num];
			}

			network(x, y_pre, In, Neuron, Out, model);
			J = calSSE(y_pre, y);
			Jnum = Jnum + J;
			backword(x, a, alfa);
		}
		printf("训练次数:%d\t", epoch);
		printf("训练误差:%f\n", Jnum / Data);
		if (epoch >= maxepoch)
		{
			break;
		}
	}
	//for (int epoch = 0; epoch < maxepoch; epoch++)
	//{
	//	Jnum = 0;
	//	for (int num = 0; num < Data; num++)
	//	{
	//		for (i = 0; i < In; i++)
	//		{
	//			x[i] = data_in[i][num];
	//		}
	//		for (k = 0; k < Out; k++)
	//		{
	//			y[k] = data_out[k][num];
	//		}
	//		
	//		network(x, y_pre, In, Neuron, Out, model);
	//		J = calSSE(y_pre, y);
	//		Jnum = Jnum + J;
	//		backword(x, a, alfa);
	//	}
	//	printf("训练次数:%d\t", epoch);
	//	printf("训练误差:%f\n",Jnum / Data);
	//}
}


int main()
{
	// 加载数据集
	float data_in[In][Data] = { {1,		0.9,	0.8,	0.7,	0.6,	0.5,	0.4,	0.3,	0.2,	0.1},
								{0.5,	0.4,	0.3,	0.2,	0.1,	0.6,	0.7,	0.8,	0.9,	1},
								{0.1,	0.5,	0.4,	0.3,	0.2,	0.9,	0.8,	0.7,	0.6,	1} };
	float data_out[Out][Data] = {{0.8,	0.9,	0.75,	0.6,	0.45,	1,		0.95,	0.9,	0.85,	1.05 },
								{0.6,	1,		0.9,	0.8,	0.7,	0.8,	0.5,	0.2,	-0.1,	0.1 } };
	float data_in_test[In][Data2] = {	{0.5,	0.4},
										{0.3,	0.7},
										{0.2,	0.8} };
	float data_out_test[Out][Data2]= {	{0.5,	0.95},
										{0.4,	0.5  } };;
	int maxepoch = 1000000;
	int model = 1;	//0-sigmoid 1-tanh 2-tansig?
	float a = 0.01, alfa=-0.000;
	train(data_in, data_out, maxepoch, model, a, alfa);

	for (int num = 0; num < Data2; num++)
	{
		for (i = 0; i < In; i++)
		{
			x[i] = data_in_test[i][num];
		}
		for (k = 0; k < Out; k++)
		{
			y[k] = data_out_test[k][num];
		}

		network(x, y_pre, In, Neuron, Out, model);
		J = calSSE(y_pre, y);
		printf("测试数据：\t", num);
		printf("测试误差：%f\n",J);
		backword(x, a, alfa);
	}
	a = 0.05;
}
一饮丶一啄
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
在 C# 中实现简单神经网络#
05-12 1404
而且，如果所有树突上都有足够的输入，体细胞将“激发”轴突上的信号，并将其传递给下一个神经元。是的，我们可以使用一些框架来很好地处理这些矩阵上的操作，例如 PyTorch。反过来，这些连接将请求来自这些连接的输入神经元的输出值，即来自前一层的神经元的输出值。除此之外，实现的网络代表了神经网络的一种简化的、最基本的形式。正如我们提到的，人工神经网络是生物驱动的，这意味着它们试图模仿真实神经系统的行为。在真正的神经系统中，这些神经元通过突触相互连接，这为整个系统提供了巨大的处理能力、学习能力和巨大的灵活性。
基于C语言和MATLAB的卷积神经网络设计（代码+报告+ppt）
毕业作品网站
06-07 888
卷积神经网络（Convolutional Neural Networks, CNN）是一类包含卷积计算且具有深度结构的前馈神经网络（Feedforward Neural Networks），是深度学习（deep learning）的代表算法之一。卷积神经网络具有表征学习（representation learning）能力，能够按其阶层结构对输入信息进行平移不变分类（shift-invariant classification），因此也被称为“平移不变人工神经网络（Shift-Invariant Artif
模糊rbf神经网络基于c语言,基于神经网络的交流伺服系统的智能研究
weixin_39737233的博客
05-25 214
摘要：该文首先,综合神经网络理论和CSCAD技术的最新进展,运用VB语言和C语言联合开发了一个基于Windows图形界面通用型机电神经控制仿真软件包.该软件具有完善的服务功能,全新的多窗口外观和直观的"拖放"操作机制,结构定义,训练仿真可实现一体化解决.同时,对神经网络的方法、学习算法、网络结构的定义、初值的定义、学习参数的选择、以及导入导出规则的建立等神经理论问题进行了深入讨论.其次,通过对永磁...
神经网络与深度学习三：编写单隐层神经网络
m0_52118763的博客
04-26 2930
三：编写单隐层神经网络 1 神经网络概述 这篇文章你会学到如何实现一个神经网络，在我们深入学习技术细节之前，现在先大概快速的了解一下如何实现神经网络，如果你对某些内容不甚理解（后面的文章中会深入其中的细节） 上周我们讨论了logistic回归，一起了解了这个模型 和下面这个流程图的联系 这里面你需要输入特征x，参数w和b，用那些计算z，然后用z计算出 a，我们用a表示y^\hat{y}y^​,接下来你就可以计算损失函数L，神经网络就是这个样子。之前提到过你可以把很多sigmoid单元堆叠起来构成一个神经
机器学习——BP神经网络的C++简易实现
weixin_43856705的博客
12-13 1479
机器学习，BP神经网络
三层BP神经网络C语言代码
05-02
C语言写的三层BP神经网络代码，用fisheriris数据集训练和测试网络，也可以用于其他分类问题。 一个输入层，一个隐藏层，一个输出层，各层的节点数都可以设置。属性数据归一化采用Z-score算法，标签数据归一化采用Min...
通过C语言实现的BP神经网络.zip
06-17
本次设计主要任务是利用 C++ 语言实现 BP 神经网络， 并利用 BP 神经网络解决螨虫分类问题。主要有这些： 熟悉自己所学的多种数据结构. 理解 BP 神经网络的工作原理 利用 C++ 实现 BP 神经网络 利用 BP 神经网络实现...
C语言-三层BP网络（隐层一层）实现mnist手写数字识别
11-17
C语言-三层BP网络（隐层一层）实现mnist手写数字识别。cpp文件可直接运行，mnist手写数字识别请自行下载，和cpp文件放到同一个路径文件夹下就可以了。成功率达93.49；高斯分布初始化参数。 训练参数的代码文件是BP-...
bp神经网络 C语言实现
02-02
用C语言实现的bp神经网络库，接口都已经写好，直接调用即可，有完善的注释，没有改进过得原版bp网络实现
BP神经网络算法的C语言实现代码1
08-08
BP神经网络算法的C语言实现代码http://wenku.baidu.com/link?url=BFoQXfdr7YaDV-3DM95_sjoUvElzGGW1
BP神经网络源代码（c语言版本）
07-01
BP神经网络代码，vc下实现 BP神经网络代码，vc下实现 BP神经网络代码，vc下实现
基于C语言的bp神经网络实现
02-26
最近一直想学习深度学习，先学习了下神经网络，用c实现了bp算法，算法采用3层网络结构，好像测试了下多层隐藏层，结果一直无法收敛，不知道是不是我的测试数据问题，3层结构能收敛，可能有局部最优，看数据了，最近又发现了python，简直是写机器学习方面代码的神器啊
c语言实现人工神经网络Bp算法源代码
10-17
很好的c语言人工神经网络bp算法工程源代码。
bp神经网络的训练方法,一文搞定bp神经网络
m0_54846070的博客
08-06 5227
BP算法的基本思想是：学习过程由信号正向传播与误差的反向回传两个部分组成；正向传播时，输入样本从输入层传入，经各隐层依次逐层处理，传向输出层，若输出层输出与期望不符，则将误差作为调整信号逐层反向回传，对神经元之间的连接权矩阵做出处理，使误差减小。经反复学习，最终使误差减小到可接受的范围。具体步骤如下：1、从训练集中取出某一样本，把信息输入网络中。2、通过各节点间的连接情况正向逐层处理后，得到神经网络的实际输出。3、计算网络实际输出与期望输出的误差。...
代码笔记 | BP神经网络的C语言代码
代码屠夫CodePudge
09-01 1541
#include #include #include #include typedef enum {CUSTOM,SIGMOD} ActionType; typedef double(*Function)(double); typedef struct { int cbSize; //神经网络所占用的内存空间 int szLayer;
BP神经网络C语言实现
qq_39545674的博客
09-07 2万+
BP神经网络C语言实现 山人 BP神经网络应用广泛，大概是今年的五月份左右，我需要做一个多元函数的拟合，所以写了这个BP神经网络。为什么要使用C语言来写呢？因为我的程序需要在单片机上跑，所以不得不使用C语言。 这一篇博客不会讲解BP神经网络的基本原理，反向传播公式，因为关于这些的资料网上已经很多了（虽然大多数都有着不小的BUG，但足以入门学习）。我会着重讲解我写的BP神经网络的每个函数的具体...
C语言实现神经网络
weixin_62562497的博客
09-04 1441
这个例子中，我们实现了一个简单的单层神经网络，它只有一个输入节点和一个输出节点，权重向量有3个元素（对应于输入节点和输出节点之间的3个连接），偏置为0。我们使用sigmoid作为激活函数，使用梯度下降法进行训练。在训练过程中，我们根据期望的输出和实际的输出计算误差，然后根据误差和梯度更新权重和偏置。最后，我们使用训练好的神经网络来计算输入为[1, 1]时的输出，输出结果为0.99。神经网络是一种深度学习的结构，它可以模拟人脑的神经元来进行复杂的学习和预测。下面是一个简单的使用C语言实现神经网络的例子。
神经网络学习 之 BP神经网络
热门推荐
Mr.Phoebe的专栏
11-30 19万+
上一次我们讲了M-P模型，它实际上就是对单个神经元的一种建模，还不足以模拟人脑神经系统的功能。由这些人工神经元构建出来的网络，才能够具有学习、联想、记忆和模式识别的能力。BP网络就是一种简单的人工神经网络。 本文具体来介绍一下一种非常常见的神经网络模型——反向传播(Back Propagation)神经网络。概述BP（Back Propagation）神经网络是1986年由Rumelhart和Mc
基于C++实现简单的BP神经网络算法
xuanwo11的博客
01-08 2万+
最近在学习神经网络算法，用C语言写了一个简单的BP神经网络算法，实现了简单的数据分类。 这里主要参考了http://blog.csdn.net/acdreamers/article/details/44657439， http://blog.csdn.net/bryan__/article/details/51288701这两篇博客，收获良多。 有导师学习算法：BP算法  采用BP
bp神经网络c语言实现
最新发布
11-08
如果您需要使用C语言实现BP神经网络，可以参考已有的开源代码库，例如引用中提到的用C语言实现的BP神经网络库。此外，您还可以参考引用中作者自己实现的BP神经网络代码，了解其实现思路和方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值