神经网络编程及其训练

最新推荐文章于 2024-05-02 13:36:00 发布
最新推荐文章于 2024-05-02 13:36:00 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 算法 文章标签： 神经网络 训练 BP算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kxuehen/article/details/9256319
版权

1.神经元结构


每个神经元包含权值、输入值、激活元素，误差项，阀值组成。在这里用一个结构体Nerver来表示，其中Weights_Temp[20],这个数组在批处理训练的时候会用来，保存个样本训练后权值的改变量。

typedef struct
{
	float Weights[20];                     //权值
	float Weights_Temp[20];                     //批处理时临时权值
	float Activating_Element;           //激活元素Iq
	float OutPut;                           //神经元输出
	float Error;                              //误差项
	float Threshold;                         //阀值
}Nerver;                                     //神经元结构体


 

神经元输出与前一层的输入，本层的权值，阀值之间的关系为：

其中函数f（）一种非线性函数，编程中采用

2. 3层的神经网络

 for (i=1;i<=Lay_Number;i++)   //Lay_Number 是神经网络的层数，本例中取4层

			   {
			     for (j=0;j<Lay_Arrangement[i];j++)//Lay_Arrangement是每层中节点个数

			       {
				 for (k=0;k<Lay_Arrangement[i-1];k++)  
				  {
				    Sum+=NetWeb[i-1][k].OutPut*NetWeb[i][j].Weights[k];//NetWeb是Nerver结构体的一个对象

				   }
				    NetWeb[i][j].Activating_Element=Sum+NetWeb[i][j].Threshold;
				    Sum=0;
				    NetWeb[i][j].OutPut=(a/(1+exp(-NetWeb[i][j].Activating_Element/thta)));//第i层第j个神经元的输出值y
				 }
			   }                //计算每个神经元的值

 

在这里神经网络的正向计算已经完成，其中权值、阀值，训练样本的初始化这些工作在后面的完整代码中给出。

3. 权值的训练过程

反向传播模型采用德尔塔原则：

均方误差:

 

权值训练，相邻两层间误差项的递推关系：

 

 

 每层每个节点误差项的计算如下：

 for(Cal=0;Cal<1;Cal++)
	       {
		NetWeb[Lay_Number][Cal].Error=(Optimal_Value[m]-NetWeb[Lay_Number][Cal].OutPut)*a/thta*NetWeb[Lay_Number][Cal].OutPut*(1-NetWeb[Lay_Number][Cal].OutPut);//输出层误差项的计算
		Sum_Error+=abs(Optimal_Value[m]-NetWeb[Lay_Number][Cal].OutPut); //累计误差
	         }     //输出层的各节点误差项

	       for (i=Lay_Number-1;i>0;i--)
	       {
		for (j=0;j<Lay_Arrangement[i];j++)
		   {
		     for (k=0;k<Lay_Arrangement[i+1];k++)
			{
			  Sum+=NetWeb[i+1][k].Error*NetWeb[i+1][k].Weights[j];
			}
			   NetWeb[i][j].Error=Sum*a/thta*NetWeb[i][j].OutPut*(1-NetWeb[i][j].OutPut);
			   Sum=0;
		   }
	       }     //利用递推关系计算每层每节点误差项


对一个样本训练后利用每个节点的误差项，得到每层每节点的权值变化量，由于程序中使用批处理的方式，也就是当所有样本全部训练完一次后在改变网络中的权值，所以每个样本训练后，得到的权值改变量会累加到相应的数组NetWeb[i][j].Weights_Temp[k]中：

for (i=1;i<=Lay_Number;i++)
			{
				for (j=0;j<Lay_Arrangement[i];j++)
				{
					for (k=0;k<Lay_Arrangement[i-1];k++)  
					{
						NetWeb[i][j].Weights_Temp[k]+=Learn_Coefficient*NetWeb[i][j].Error*NetWeb[i-1][k].OutPut;
					}			
				}
			}      //计算训练一个样本后得权值改变累计

所用样本都训练完一次后，对网络权值进行更新：

 for (i=1;i<=Lay_Number;i++)
		   {
			   for (j=0;j<Lay_Arrangement[i];j++)
			   {
				   for (k=0;k<Lay_Arrangement[i-1];k++)  
				   {
					   NetWeb[i][j].Weights[k]+=NetWeb[i][j].Weights_Temp[k];
				   }			
			   }
		   }      //一个训练批次后，更新权值



4.训练结果

           

 

程序中采用了一个输入层，两个隐层和一个输入层的结构。每次训练结果会有所差异。误差总会存在，还存在许多改进的地方，不过作为一个理解神经网络基本运作原理来说已经够了。

目标函数选择 (sin(2*3.1415926*x)+1)/2。训练范围为（0，1）。

对于样本的选取，最好将输入与输出规范化到（0，1）中这样训练效果会比较好。程序中S函数参数选取为a=1.716，thta=1。a的值要比目标函数的最大值要大，这样训练才能成功。

 

5.源代码

该源代码使用了opencv显示图像，需要包含opencv库，可能由于各个电脑程序库不同，并不一定可以直接运行。但各个功能部分是可以使用的，本程序可以实现任意层数与节点的神经网络。

 

#include <stdio.h>
#include <tchar.h>
#include "function.h"
#include <math.h>
#include "opencv2/opencv.hpp"


#include <ctime>
#include <cstdlib>
using namespace cv;#define NUM 40
  double random(double,double);typedef struct
{
	float Weights[20];                     //权值
	float Weights_Temp[20];                     //批处理时临时权值
	float Activating_Element;           //激活元素Iq
	float OutPut;                           //神经元输出
	float Error;                              //误差项
	float Threshold;                         //阀值
}Nerver;                                     //神经元结构体
int _tmain(int argc, _TCHAR* argv[])
{
	unsigned int Lay_Arrangement[10],i,j,k,m,Lay_Number=3,Learn_Num=0,Sample_Num=NUM,Cal=0;
	float Sum=0,Optimal_Value[NUM+1],Learn_Coefficient=0.01,x,Sum_Error=100000,a=1.716,thta=1;
	Lay_Arrangement[0]=1;
    Lay_Arrangement[1]=3;
	Lay_Arrangement[2]=2;
	Lay_Arrangement[3]=1;
   
	Nerver NetWeb[10][NUM];
	 srand(unsigned(time(0)));
	IplImage *im;
	CvPoint PrePoint,Point;
	CvScalar m_RGB;
	for (i=1;i<=Lay_Number;i++)          //i层
	{
		for (j=0;j<Lay_Arrangement[i];j++)   //第j个节点
		{			
			NetWeb[i][j].Threshold=0;		//初始化神经元阀值				
		}		
	}
	for (i=1;i<=Lay_Number;i++)          //i层
	{
		for (j=0;j<Lay_Arrangement[i];j++)   //第j个节点
		{
			for (k=0;k<Lay_Arrangement[i-1];k++)   // 第i层第j个节点与前一层第k个节点之间的权值初始值
			{
				NetWeb[i][j].Weights[k]=random(-0.5,0.5);
				//NetWeb[i][j].Weights[k]=0.1;
				NetWeb[i][j].Weights_Temp[k]=0;

			}			
		}		
	}

	for(x=0.0;x<PI;x+=PI/Sample_Num)
	{		
		NetWeb[0][Cal].OutPut=x;   //神经元输入值
		Optimal_Value[Cal]=(sin(2*3.1415926*x)+1)/2;   //神经元理想输出值
		//Optimal_Value[Cal]=sin(x); 
		Cal++;
	}      //初始化神经网络输入层
	while ((Sum_Error>0.0001)&&(Learn_Num<40000))
	{
		Sum_Error=0;
		Learn_Num++;
		 
		for (i=1;i<=Lay_Number;i++)          //i层
		{
			for (j=0;j<Lay_Arrangement[i];j++)   //第j个节点
			{
				for (k=0;k<Lay_Arrangement[i-1];k++)   // 第i层第j个节点与前一层第k个节点之间的权值初始值
				{					
					NetWeb[i][j].Weights_Temp[k]=0;
				}			
			}		
		}
		
	       for(m=0;m<Sample_Num;m++)
		   {
			   NetWeb[0][0].OutPut=NetWeb[0][m].OutPut;			  
			   for (i=1;i<=Lay_Number;i++)
			   {
				   for (j=0;j<Lay_Arrangement[i];j++)
				   {
					   for (k=0;k<Lay_Arrangement[i-1];k++)  
					   {
						   Sum+=NetWeb[i-1][k].OutPut*NetWeb[i][j].Weights[k];
					   }
					   NetWeb[i][j].Activating_Element=Sum+NetWeb[i][j].Threshold;
					   Sum=0;
					   NetWeb[i][j].OutPut=(a/(1+exp(-NetWeb[i][j].Activating_Element/thta)));
				   }
			   }                //计算每个神经元的值
			   for(Cal=0;Cal<1;Cal++)
			   {
				   NetWeb[Lay_Number][Cal].Error=(Optimal_Value[m]-NetWeb[Lay_Number][Cal].OutPut)*a/thta*NetWeb[Lay_Number][Cal].OutPut*(1-NetWeb[Lay_Number][Cal].OutPut);
				   Sum_Error+=abs(Optimal_Value[m]-NetWeb[Lay_Number][Cal].OutPut); //累计误差
			   }     //输出层的各节点误差项



			   for (i=Lay_Number-1;i>0;i--)
			   {
				   for (j=0;j<Lay_Arrangement[i];j++)
				   {
					   for (k=0;k<Lay_Arrangement[i+1];k++)
					   {
						   Sum+=NetWeb[i+1][k].Error*NetWeb[i+1][k].Weights[j];
					   }
					   NetWeb[i][j].Error=Sum*a/thta*NetWeb[i][j].OutPut*(1-NetWeb[i][j].OutPut);
					   Sum=0;
				   }
			   }     //计算每层每节点误差项

		   
			
			for (i=1;i<=Lay_Number;i++)
			{
				for (j=0;j<Lay_Arrangement[i];j++)
				{
					for (k=0;k<Lay_Arrangement[i-1];k++)  
					{
						NetWeb[i][j].Weights_Temp[k]+=Learn_Coefficient*NetWeb[i][j].Error*NetWeb[i-1][k].OutPut;
					}			
				}
			}      //计算训练一个样本后得权值改变累计       		
	    }
		   for (i=1;i<=Lay_Number;i++)
		   {
			   for (j=0;j<Lay_Arrangement[i];j++)
			   {
				   for (k=0;k<Lay_Arrangement[i-1];k++)  
				   {
					   NetWeb[i][j].Weights[k]+=NetWeb[i][j].Weights_Temp[k];
				   }			
			   }
		   }      //一个训练批次后，更新权值
}

	im=cvCreateImage(cvSize(1400,400),IPL_DEPTH_8U,3);
	Mat im_Mat(im);
	cvZero(im);
	PrePoint=cvPoint(0,100);
	m_RGB=CV_RGB(255,0,0);
	x=0;
	for(Cal=0.0;Cal<Sample_Num;Cal++)
	{			
		Point=cvPoint(int(100*x),int(100*Optimal_Value[Cal]));
		cvLine(im, PrePoint, Point,m_RGB,1,CV_AA,0);
		PrePoint=Point;
		x+=PI/Sample_Num;
	} 
	m_RGB=CV_RGB(0,255,0);	
	PrePoint=cvPoint(0,int((NetWeb[Lay_Number][Cal].OutPut)*100));
	x=0;
	for (i=1;i<=Lay_Number;i++)
	{
		for (j=0;j<Lay_Arrangement[i];j++)
		{
			for (k=0;k<Lay_Arrangement[i-1];k++)  
			{
				printf("%f1.4 ",NetWeb[i][j].Weights[k]);
			}			
		}
		printf("\n");
	}      //一个训练批次后，更新权值
	for(Cal=0.0;Cal<Sample_Num;Cal++)
	{	
		NetWeb[0][0].OutPut=x;					  
		for (i=1;i<=Lay_Number;i++)
		{
			for (j=0;j<Lay_Arrangement[i];j++)
			{
				for (k=0;k<Lay_Arrangement[i-1];k++)  
				{
					Sum+=NetWeb[i-1][k].OutPut*NetWeb[i][j].Weights[k];
				}
				NetWeb[i][j].Activating_Element=Sum+NetWeb[i][j].Threshold;
				Sum=0;
				NetWeb[i][j].OutPut=(a/(1+exp(-NetWeb[i][j].Activating_Element/thta)));//利用训练后网络实现对目标函数的拟合
			}
		}   

		
		Point=cvPoint(int(100*x),int(100*(NetWeb[Lay_Number][0].OutPut)));
		cvLine(im, PrePoint, Point,m_RGB,1,CV_AA,0);
		PrePoint=Point;
		x+=PI/Sample_Num;
		 
	}     
	imshow("result",im_Mat);
	waitKey(0);




	return 0;
}

double random(double start, double end)
{
	return start+(end-start)*rand()/(RAND_MAX + 1.0);
}


 

 

k雪痕
关注
专栏目录
PyTorch深度学习实战（1）——神经网络与模型训练过程详解
盼小辉丶的博客
05-28 6万+
在本节中，我们将了解传统机器学习与人工神经网络间的差异，并了解如何在实现前向传播之前连接网络的各个层，以计算与网络当前权重对应的损失值；实现反向传播以优化权重达到最小化损失值的目标。并将实现网络的所有关键组成——前向传播、激活函数、损失函数、链式法则和梯度下降，从零开始构建并训练了一个简单的神经网络。
编程训练
刘锐群的笔记
09-12 1334
题目：图片整理 描述 Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。 输入 Lily使用的图片包括"A"到"Z"、"a"到"z"、"0"到"9"。输入字母或数字个数不超过1024。 输出 Lily的所有图片按照从小到大的顺序输出 样例输入 Ihave1n
编程训练1
qq_36386435的博客
03-14 222
前序     我感觉编程是一个进入大厂的基本门槛，前期在寒假，做过一个月的编程学习，就是每周六会做一下题，现在应该是不搞了，之后我可能会不定期的做一下，好像大厂的题目都来自leetcode上的hard，那我就直接刷leetcode的hard题吧。其实我想精进一下我的python语言，所以我用了python，但感觉后面我还是会用c++，我还是想偏向c++开发类似的岗位。 贪心 1、Circle of Monsters http://codeforces.com/cont
编程练习
冰清雪酷的专栏
02-09 377
前人练习总结的代码：https://github.com/haoel/leetcode
一些在线编程练习或调试网站
热门推荐
竭尽全力的专栏
08-22 3万+
总结了一些在线编程练习的网站、学习网站以及在线代码调试网站，以供参考，欢迎补充！一、代码练习网站 欧拉计划问题 Leetcode OJ 赛码网在线编程 计蒜客 牛客网在线编程 PAT（Programming Ability Test） 九度Online Judge 南阳理工学院在线测评系统 Python编程挑战 直播编程 北京大学JudgeOnline 任青网络信息学奥赛(O
编程入门训练
New_Leaf的博客
07-11 1697
编程入门训练：题目均来自于牛客网上编程入门训练的门类，所有源码均通过平台测试，以此文记录，有助于个人学习恢复编程能力
深层神经网络编程题数据集
05-10
深度神经网络（Deep Neural Networks, DNN）是现代人工智能领域中的关键组成部分，尤其在...因此，无论你是初学者还是经验丰富的工程师，这个“深层神经网络编程题数据集”都将是你学习和研究深度学习的宝贵资料。
MATLAB神经网络编程源程序（张德丰教材）
06-19
总之，这个MATLAB神经网络编程源程序压缩包是一份宝贵的教育资源，对于想要深入学习神经网络及其在MATLAB中实现的学者来说，具有很高的参考价值。通过实践这些代码，不仅可以提升MATLAB编程能力，还能更好地理解和...
基于TensorFlow的神经网络构建与训练详解
最新发布
10-15
内容概要：介绍了TensorFlow的基础概念、张量与相关操作以及tf.keras构建神经网络的方法。文中详细讲解了使用TensorFlow创建并处理张量的基本方法，并演示如何建立并训练一个多层感知机模型。同时涵盖了使用不同回调...
神经网络编程_源代码.zip_BP神经网络_matlab神经网络_神经网络_遗传算法 _非线性函数拟合
07-15
在本压缩包中，我们主要探讨的是神经网络的编程实现，特别是使用AForge.NET和MATLAB两种工具。这两种工具在机器学习和数据处理领域都具有广泛的应用。让我们逐一深入理解这些概念及其相关知识点。 首先，BP...
【java-springboot-毕业设计】在线教育系统
2301_79766712的博客
11-03 179
1.1研究背景随着计算机技术的发展以及计算机网络的逐渐普及，互联网成为人们查找信息的重要场所，二十一世纪是信息的时代，所以信息的管理显得特别重要。因此，使用计算机来管理在线教育系统的相关信息成为必然。开发合适的在线教育系统，可以方便管理人员对在线教育系统的管理，提高信息管理工作效率及查询效率，有利于更好的为人们服务。1.2研究目的随着互联网技术的快速发展，网络时代的到来，网络信息也将会改变当今社会。各行各业在日常企业经营管理等方面也在慢慢的向规范化和网络化趋势汇合。
编程训练：潜伏（9528）
Limitless1113的专栏
11-24 934
题目：记录长度为N（1
神经网络的编程实现
bjy_fighting的博客
04-27 1251
CNN的编程实现可以分为以下几大模块： layers层的实现，包括每个层的前向传播和反向传播函数 CNN网络类的实现，通过堆叠layers层中实现的各种layer，构建网络的结构 优化方法的实现包括SGD、SGD+Momentum、Adam等方法 Solver类的实现，对构建的CNN网络采用实现的优化方法进行优化，求解参数 layers层layers层的实现主要包含对不同种类的网络层实现前向传播和反
编程训练计划
akfhell
11-18 535
编程训练计划 总览       训练目的 暂时分两步提高。   第一步：语言表达练习。就是熟练使用语言来表达逻辑。   第二步：学习常用算法和数据结构。熟悉使用算法和数据结构解决一些问题。 训练方法   在一些在线做题网站（OnlineJudge简称OJ网站）上搜集相关题目，并做题。 当然首先要注册一个账号，并且熟悉网站怎么在线答题，交题。   常用的编程在线判题系统训练网站：
【C语言】编程初学者入门训练（完结）
shangguanxiu的博客
02-19 5010
C语言编程初学者入门训练130题，所有题目代码都通过牛客网测试
C++编程练习
312小公举的专栏
01-08 982
字符的左右移动题目 字符串是任意的＊和字母的组合，设计算法，把＊都移到最左边，字母都移到最右边且保持相对顺序不变。 实现 逆序处理字符串。双指针，一个指针alpha最初指向最右边的字符，另一个last指针最初指向最右边的＊。 当alpha指向字母时，就和last指向的字符互换，并且这两个指针同时向左移一位。 当alpha指向＊时，只有alpha向左移动一位。 当alpha<0时，结束。 代码void
ICode国际青少年编程竞赛- Python-1级训练场-基础训练2
QD_Jason的博客
05-02 4807
ICode国际青少年编程竞赛- Python-1级训练场-基础训练2
C语言经典编程训练（算法入门）
qq_55786319的博客
04-13 1280
1.任意次方后的最后三位 编程求一个整数任意次方后的最后三位数，即求x^y的最后三位数，x和y的值由键盘输入。 #include<stdio.h> int main(){ int x,y,sum; printf("请输入两个数，x和y（x^y）：\n"); scanf("%d%d",&x,&y); sum=x;//将sum初始化为x的值 if(y==0) sum=1; else if(y==1) sum=x; for(int i=2;i<=y;i++
深度学习实验（五）——循环神经网络编程
code_bro的博客
01-03 1345
本次实验练习使用torch.nn中的类设计一个循环神经网络进行MNIST图像分类。在本次实验中，你要设计一个CNN，用于将28×2828 \times 2828×28的MNIST图像转换为M×M×DM\times M\times DM×M×D的特征图，将该特征图看作是一个长度为M×MM\times MM×M的特征序列，序列中每一个特征向量的大小为DDD，然后使用RNN对该序列分类。 1. 准备数据 从torch.nn.Module派生一个子类CNN，表示一个卷积神经网络;用于将
RBF神经网络编程及其在Matlab中的实现
rbf.zip文件是与人工智能、神经网络、深度学习相关的Matlab编程资源。该文件包聚焦于径向基函数（Radial Basis Function, RBF）神经网络的实现与应用。径向基函数网络是一种人工神经网络，它使用径向基函数作为激活...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值