经典的BPN带动量的误差反向传播神经网络类代码示例

最新推荐文章于 2020-07-01 23:14:23 发布
最新推荐文章于 2020-07-01 23:14:23 发布
阅读量1.1k 收藏
点赞数
分类专栏： 机器学习 文章标签： 神经网络 BP神经网络 数字识别

初始代码来自：

/*

 ******************************************************************
 * HISTORY
 * 15-Oct-94  Jeff Shufelt (js), Carnegie Mellon University
 *      Prepared for 15-681, Fall 1994.
 *
 ******************************************************************

 */


大众修改版：

/*
 ******************************************************************
 * backprop.h
 ******************************************************************
 */

#ifndef _BACKPROP_H_
#define _BACKPROP_H_


#define BIGRND 0x7fffffff


/*** 神经网络的数据结构。网络被假定为一个全连接的3层前向结构，
	 每层的单元0是阈值，这意味着真正的神经元编号为1－n
 ***/

typedef struct {
	int input_n;                  /* 输入层的神经元个数 */
	int hidden_n;                 /* 隐含层的神经元个数 */
	int output_n;                 /* 输出层的神经元个数 */

	double *input_units;          /* 输入层的神经元 */
	double *hidden_units;         /* 隐藏层的神经元 */
	double *output_units;         /* 输出曾的神经元 */

	double *hidden_delta;         /* 隐藏层的误差 */
	double *output_delta;         /* 输出层的误差 */

	double *target;               /* 目标向量 */

	double **input_weights;       /* 输入层到隐藏层的连接权 */
	double **hidden_weights;      /* 隐藏层到输出曾的连接权 */

                                /*** 下面两个在迭代时使用 ***/
	double **input_prev_weights;  /* 前次输入层导隐藏层权值的改变 */
	double **hidden_prev_weights; /* 前次隐藏层导输出层权值的改变 */
} BPNN;


/*** 用户接口 ***/

/* 初始化随机数种子 */
void bpnn_initialize(int seed);

/* 创建BP网络 */
BPNN *bpnn_create(int n_in, int n_hidden, int n_out);

/* 释放BP网络所占地内存空间 */
void bpnn_free(BPNN *net);

/* 训练BP网络 */
void bpnn_train(BPNN *net, double eta, double momentum, double *eo, double *eh);

/* 前向运算 */
void bpnn_feedforward(BPNN* net);

/* 保存BP网络到文件中 */
void bpnn_save(BPNN *net, char *filename);

/* 从文件中读取BP网络参数 */
BPNN *bpnn_read(char *filename);

//随机初始化权值
void bpnn_randomize_weights(double **w, int m, int n);

#endif



/*
 ******************************************************************
 * backprop.cpp
 ******************************************************************
 */

#include "StdAfx.h"
#include <stdio.h>
#include "backprop.h"
#include <math.h>
#include <stdlib.h>

#define ABS(x)          (((x) > 0.0) ? (x) : (-(x)))

/* 宏定义：快速拷贝 */
#define fastcopy(to,from,len)\
{\
	register char *_to,*_from;\
	register int _i,_l;\
	_to = (char *)(to);\
	_from = (char *)(from);\
	_l = (len);\
	for (_i = 0; _i < _l; _i++) *_to++ = *_from++;\
}

/*** 返回0－1的双精度随机数 ***/
double drnd()
{
	return ((double) rand() / (double) BIGRND);
}

/*** 返回-1.0到1.0之间的双精度随机数 ***/
double dpn1()
{
	return ((drnd() * 2.0) - 1.0);
}

/*** 作用函数，目前是S型函数 ***/

double squash(double x)
{
	return (1.0 / (1.0 + exp(-x)));
}


/*** 申请1维双精度实数数组 ***/

double *alloc_1d_dbl(int n)
{
	double *new1;

	new1 = (double *) malloc ((unsigned) (n * sizeof (double)));
	if (new1 == NULL) {
		printf("ALLOC_1D_DBL: Couldn't allocate array of doubles\n");
		return (NULL);
	}
	return (new1);
}


/*** 申请2维双精度实数数组 ***/

double **alloc_2d_dbl(int m, int n)
{
	int i;
	double **new1;

	new1 = (double **) malloc ((unsigned) (m * sizeof (double *)));
	if (new1 == NULL) {
		printf("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrs\n");
		return (NULL);
	}

	for (i = 0; i < m; i++) {
		new1[i] = alloc_1d_dbl(n);
	}

	return (new1);
}

/*** 随机初始化权值 ***/
void bpnn_randomize_weights(double **w, int m, int n)
{
	int i, j;

	for (i = 0; i <= m; i++) {
		for (j = 0; j <= n; j++) {
			w[i][j] = dpn1();
		}
	}
}

/*** 0初始化权值 ***/
void bpnn_zero_weights(double **w, int m, int n)
{
	int i, j;

	for (i = 0; i <= m; i++) {
		for (j = 0; j <= n; j++) {
			w[i][j] = 0.0;
		}
	}
}

/*** 设置随机数种子 ***/
void bpnn_initialize(int seed)
{
	printf("Random number generator seed: %d\n", seed);
	srand(seed);
}

/*** 创建BP网络 ***/
BPNN *bpnn_internal_create(int n_in, int n_hidden, int n_out)
{
	BPNN *newnet;

	newnet = (BPNN *) malloc (sizeof (BPNN));
	if (newnet == NULL) {
		printf("BPNN_CREATE: Couldn't allocate neural network\n");
		return (NULL);
	}

	newnet->input_n = n_in;
	newnet->hidden_n = n_hidden;
	newnet->output_n = n_out;
	newnet->input_units = alloc_1d_dbl(n_in + 1);
	newnet->hidden_units = alloc_1d_dbl(n_hidden + 1);
	newnet->output_units = alloc_1d_dbl(n_out + 1);

	newnet->hidden_delta = alloc_1d_dbl(n_hidden + 1);
	newnet->output_delta = alloc_1d_dbl(n_out + 1);
	newnet->target = alloc_1d_dbl(n_out + 1);

	newnet->input_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
	newnet->hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);

	newnet->input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
	newnet->hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);

	return (newnet);
}

/* 释放BP网络所占地内存空间 */
void bpnn_free(BPNN *net)
{
	int n1, n2, i;

	n1 = net->input_n;
	n2 = net->hidden_n;

	free((char *) net->input_units);
	free((char *) net->hidden_units);
	free((char *) net->output_units);

	free((char *) net->hidden_delta);
	free((char *) net->output_delta);
	free((char *) net->target);

	for (i = 0; i <= n1; i++) {
		free((char *) net->input_weights[i]);
		free((char *) net->input_prev_weights[i]);
	}
	free((char *) net->input_weights);
	free((char *) net->input_prev_weights);

	for (i = 0; i <= n2; i++) {
		free((char *) net->hidden_weights[i]);
		free((char *) net->hidden_prev_weights[i]);
	}
	free((char *) net->hidden_weights);
	free((char *) net->hidden_prev_weights);

	free((char *) net);
}


/*** 
	 创建一个BP网络，并初始化权值
***/

BPNN *bpnn_create(int n_in, int n_hidden, int n_out)
{
	BPNN *newnet;

	newnet = bpnn_internal_create(n_in, n_hidden, n_out);

#ifdef INITZERO
	bpnn_zero_weights(newnet->input_weights, n_in, n_hidden);
#else
	bpnn_randomize_weights(newnet->input_weights, n_in, n_hidden);
#endif

	bpnn_randomize_weights(newnet->hidden_weights, n_hidden, n_out);
	bpnn_zero_weights(newnet->input_prev_weights, n_in, n_hidden);
	bpnn_zero_weights(newnet->hidden_prev_weights, n_hidden, n_out);

	return (newnet);
}

void bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2)
{
	double sum;
	int j, k;

	/*** 设置阈值 ***/
	l1[0] = 1.0;

	/*** 对于第二层的每个神经元 ***/
	for (j = 1; j <= n2; j++) {

		/*** 计算输入的加权总和 ***/
		sum = 0.0;
		for (k = 0; k <= n1; k++) {
			sum += conn[k][j] * l1[k];
		}
		l2[j] = squash(sum);
	}
}

/* 输出误差 */
void bpnn_output_error(double *delta, double *target, double *output, int nj, double *err)
{
	int j;
	double o, t, errsum;

	errsum = 0.0;
	for (j = 1; j <= nj; j++) {
		o = output[j];
		t = target[j];
		delta[j] = o * (1.0 - o) * (t - o);
		errsum += ABS(delta[j]);
	}
	*err = errsum;
}

/* 隐含层误差 */
void bpnn_hidden_error(double* delta_h, int nh, double *delta_o, int no, double **who, double *hidden, double *err)
{
	int j, k;
	double h, sum, errsum;

	errsum = 0.0;
	for (j = 1; j <= nh; j++) {
		h = hidden[j];
		sum = 0.0;
		for (k = 1; k <= no; k++) {
			sum += delta_o[k] * who[j][k];
		}
		delta_h[j] = h * (1.0 - h) * sum;
		errsum += ABS(delta_h[j]);
	}
	*err = errsum;
}

/* 调整权值 */
void bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double** w, double **oldw, double eta, double momentum)
{
	double new_dw;
	int k, j;

	ly[0] = 1.0;
	for (j = 1; j <= ndelta; j++) {
		for (k = 0; k <= nly; k++) {
			new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j]));
			w[k][j] += new_dw;
			oldw[k][j] = new_dw;
		}
	}
}

/* 进行前向运算 */
void bpnn_feedforward(BPNN* net)
{
	int in, hid, out;

	in = net->input_n;
	hid = net->hidden_n;
	out = net->output_n;

	/*** Feed forward input activations. ***/
	bpnn_layerforward(net->input_units, net->hidden_units,
		net->input_weights, in, hid);
	bpnn_layerforward(net->hidden_units, net->output_units,
		net->hidden_weights, hid, out);
}

/* 训练BP网络 */
void bpnn_train(BPNN *net, double eta, double momentum, double *eo, double *eh)
{
	int in, hid, out;
	double out_err, hid_err;

	in = net->input_n;
	hid = net->hidden_n;
	out = net->output_n;

	/*** 前向输入激活 ***/
	bpnn_layerforward(net->input_units, net->hidden_units,
		net->input_weights, in, hid);
	bpnn_layerforward(net->hidden_units, net->output_units,
		net->hidden_weights, hid, out);

	/*** 计算隐含层和输出层误差 ***/
	bpnn_output_error(net->output_delta, net->target, net->output_units,
		out, &out_err);
	bpnn_hidden_error(net->hidden_delta, hid, net->output_delta, out,
		net->hidden_weights, net->hidden_units, &hid_err);
	*eo = out_err;
	*eh = hid_err;

	/*** 调整输入层和隐含层权值 ***/
	bpnn_adjust_weights(net->output_delta, out, net->hidden_units, hid,
		net->hidden_weights, net->hidden_prev_weights, eta, momentum);
	bpnn_adjust_weights(net->hidden_delta, hid, net->input_units, in,
		net->input_weights, net->input_prev_weights, eta, momentum);
}


/* 保存BP网络 */
void bpnn_save(BPNN *net, char *filename)
{
	int n1, n2, n3, i, j, memcnt;
	double dvalue, **w;
	char *mem;
	FILE *fd;

	if ((fd = fopen(filename, "w")) == NULL) {
		printf("BPNN_SAVE: Cannot create '%s'\n", filename);
		return;
	}

	n1 = net->input_n;  n2 = net->hidden_n;  n3 = net->output_n;
	printf("Saving %dx%dx%d network to '%s'\n", n1, n2, n3, filename);
	fflush(stdout);


	fwrite((char *) &n1, sizeof(int), 1, fd);
	fwrite((char *) &n2, sizeof(int), 1, fd);
	fwrite((char *) &n3, sizeof(int), 1, fd);

	memcnt = 0;
	w = net->input_weights;
	mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));
	for (i = 0; i <= n1; i++) {
		for (j = 0; j <= n2; j++) {
			dvalue = w[i][j];
			fastcopy(&mem[memcnt], &dvalue, sizeof(double));
			memcnt += sizeof(double);
		}
	}

	fwrite(mem, (n1+1) * (n2+1) * sizeof(double), 1, fd);
	free(mem);

	memcnt = 0;
	w = net->hidden_weights;
	mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));
	for (i = 0; i <= n2; i++) {
		for (j = 0; j <= n3; j++) {
			dvalue = w[i][j];
			fastcopy(&mem[memcnt], &dvalue, sizeof(double));
			memcnt += sizeof(double);
		}
	}

	fwrite(mem, (n2+1) * (n3+1) * sizeof(double), 1, fd);
	free(mem);

	fclose(fd);
	return;
}

/* 从文件中读取BP网络 */
BPNN *bpnn_read(char *filename)
{
	char *mem;
	BPNN *new1;
	int n1, n2, n3, i, j, memcnt;
	FILE *fd;

	if ((fd = fopen(filename, "r")) == NULL) {
		return (NULL);
	}

	printf("Reading '%s'\n", filename);  fflush(stdout);

	fread((char *) &n1, sizeof(int), 1, fd);
	fread((char *) &n2, sizeof(int), 1, fd);
	fread((char *) &n3, sizeof(int), 1, fd);

	new1 = bpnn_internal_create(n1, n2, n3);

	printf("'%s' contains a %dx%dx%d network\n", filename, n1, n2, n3);
	printf("Reading input weights...");  fflush(stdout);

	memcnt = 0;
	mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));

	fread( mem, (n1+1) * (n2+1) * sizeof(double), 1, fd);
	for (i = 0; i <= n1; i++) {
		for (j = 0; j <= n2; j++) {
			fastcopy(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double));
			memcnt += sizeof(double);
		}
	}
	free(mem);

	printf("Done\nReading hidden weights...");  fflush(stdout);

	memcnt = 0;
	mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));

	fread( mem, (n2+1) * (n3+1) * sizeof(double), 1, fd);
	for (i = 0; i <= n2; i++) {
		for (j = 0; j <= n3; j++) {
			fastcopy(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double));
			memcnt += sizeof(double);
		}
	}
	free(mem);
	fclose(fd);

	printf("Done\n");  fflush(stdout);

	bpnn_zero_weights(new1->input_prev_weights, n1, n2);
	bpnn_zero_weights(new1->hidden_prev_weights, n2, n3);

	return (new1);
}



使用该BP神经网络识别数字1-9的例子：



一代程序码农
关注
专栏目录
bp神经网络误差反向传播,什么叫误差的反向传播
wenangou的博客
10-07 2903
BP算法的基本思想是：学习过程由信号正向传播与误差的反向回传两个部分组成；正向传播时，输入样本从输入层传入，经各隐层依次逐层处理，传向输出层，若输出层输出与期望不符，则将误差作为调整信号逐层反向回传，对神经元之间的连接权矩阵做出处理，使误差减小。经反复学习，最终使误差减小到可接受的范围。具体步骤如下：1、从训练集中取出某一样本，把信息输入网络中。2、通过各节点间的连接情况正向逐层处理后，得到神经网络的实际输出。3、计算网络实际输出与期望输出的误差。
神经网络-误差反向传播算法 BP算法
qq_31232793的博客
07-25 2330
BP算法学习笔记 1 学习基础–神经网络的基本原理和前向过程 ​ 如下图所示，这时一个简单的神经网络模型，通过这样一个模型我们就可以完成一些工作。例如我们输入三个数据，a1表示一个公司的银行存款，a2表示所拥有的固定资产估值，a3表示这个人最近一个月的利润，out1表示这是状态良好，out2表示它状态不好。现在我们要通过这个网络来判断，我们是否给这个公司发放贷款。 ​ 现在我们先明确一下图中参数的意义：w表示权重，b表示偏置,下面是基本计算步骤。 z11=a1∗w1,11+a2
经典的BPN人工神经网络例子源码
02-23
Backpropagation Network Time-Series Forecasting 源码, 经典的BPN人工神经网络例子源码
机器学习入门（14）— 神经网络学习整体流程、误差反向传播代码实现、误差反向传播梯度确认、误差反向传播使用示例
wohu1104的专栏
07-01 623
1. 误差反向传播整体流程 2. 误差反向传播代码实现 3. 误差反向传播梯度确认 4. 误差反向传播使用示例
误差反向传播
Fan_nie的博客
07-19 326
# -*- coding: utf-8 -*- """ Created on Fri Jul 19 09:24:13 2019 @author: Administrator """ apple = 100 apple_num = 2 orange = 150 orange_num = 3 tax = 1.1 class MulLayer: def __init__(self): sel...
神经网络中误差反向传播(back propagation)算法的工作原理
ddq_107038的博客
01-19 1004
注意：版权所有，转载需注明出处。 神经网络，从大学时候就知道，后面上课的时候老师也讲过，但是感觉从来没有真正掌握，总是似是而非，比较模糊，好像懂，其实并不懂。 在开始推导之前，需要先做一些准备工作，推导中所使用的神经网络如上图所示。一个神经网络由多个层(layer)构成，每一层有若干个节点(node)，最左边是输入层，中间的层被称为隐含层，最右边是输出层；上一层节点与下一层节点之...
BPN训练1
alaclp的专栏
05-11 835
BP神经网络训练程序. P=-1:0.1:1 T=[-0.9602 -0.5770 -0.0729 0.3771 0.6405 0.6600 0.4609 0.1336 -0.2013 -0.4344 -0.5000 -.03930 -0.1647 0.0988 0.3027 0.3960 0.3449 0.1816 -0.0312 -0.2189 -0.3201] plot(P,T); s=3:8; % s=3; res=1:6; for i=1:6 net=newff(min
分类算法——神经网络算法BPN实践.rar_BPN神经网络_FFBPN神经网络_分类算法_神经网络分类
09-21
本篇将详细探讨一种经典的神经网络分类算法——BPN（Back Propagation Network，反向传播神经网络）及其变种FFBPN（Fast and Flexible Back Propagation Network），以及它们在实际应用中的重要性。 首先，我们来...
BPN.rar_Iris分类matlab_bp matlab iris_iris_matlab iris bp_神经网络 分类
07-14
标题中的"BPN.rar_Iris分类matlab_bp matlab iris_iris_matlab iris bp_神经网络 分类"揭示了这个压缩包内容的核心，它涉及到一个使用MATLAB实现的BP神经网络，用于对Iris（鸢尾花）数据集进行分类。 BP神经网络是一...
BPN.zip_BP神经网络算法
09-24
`BPN.C`文件很可能是一个C语言实现的BP神经网络代码。代码中可能包含了神经网络的定义、前向传播、反向传播和权重更新的函数。通过对代码的阅读和理解，我们可以更直观地了解BP神经网络的算法细节和实现方式。 总结...
BPN算法反向传播神经网络
04-03
BPN算法训练反向传播网络各层的权值，输入简单的训练样本，经过的反复的训练直到结束条件
NeuralNet:使用反向传播和动量的神经网络
05-18
神经网络 该程序是针对人工智能的学术课程项目实施的。 目标是实现一个程序，该程序能够从PROBEN1 Benchmark套件中加载数据文件，并将其加载到神经网络中以衡量其性能。 建议的学习算法是经典的“具有动量的反向传播” ，以及“早期停止”功能，可以防止网络过度拟合数据。 在ftp://ftp.ira.uka.de/pub/neuron/上，您可以找到数据文件和有关PROBEN1的原始文档，其中还包括有关Early Stopping的详细信息。 检查以获取更多信息！
神经网络7种模型，如SOM、HOPFIELD、CPN、BPN、BOLTZMAN、RT、ADALINE
04-24
神经网络7种模型，如SOM、HOPFIELD、CPN、BPN、BOLTZMAN、ART、ADALINE 并带有人工神经网络入门讲稿.pdf
BPN人工神经网络源码
04-29
经典的BPN人工神经网络例子,是学习神经网络算法的优秀实例。
BPN人工神经网络例子代码(经典的)
03-23
BPN人工神经网络例子代码(经典的)
网络游戏-基于反向传播神经网络模型的室内无线网络定位方法.zip
09-19
反向传播神经网络是一种多层前馈神经网络，它的学习过程基于梯度下降法，通过反向传播误差来调整权重和偏置，以最小化预测输出与实际输出之间的差异。BPN模型具有强大的非线性拟合能力，能处理复杂的数据关系，因此...
神经网络反向传播算法.zip
最新发布
08-10
神经网络反向传播算法（Backpropagation Neural Network，简称BPN）是深度学习领域中的一种基础且重要的算法，广泛应用于图像识别、语音识别、自然语言处理等多个场景。该算法通过梯度下降法更新权重，以最小化损失...
【读书1】【2017】MATLAB与深度学习——反向传播算法(3)
weixin_42825609的博客
10-13 220
更多精彩文章请关注微信号：
数据挖掘---分类算法之神经网络算法BPN
热门推荐
数据时代--收集，存储，处理，分析，挖掘，检索，展现
08-07 1万+
有段时间没有写了，觉得很有必要继续加油写下去。一直有想梳理下主要的机器学习算法了，做一个从各个主流算法到新兴的算法，都做一番回顾，理论结合代码实践，做一个复习，毕竟温故而知新。顺便说下，什么机器学习，数据挖掘，人工智能，这几个词语很多，也很容易用的模糊了，边界不是很清晰，我也不想做过多的解读与区分，免得弄巧成拙，或者班门弄斧。还是埋头实践吧。        后面的几篇主要从这么几个类别来整理：
误差反向传播神经网络：BP神经网络详解
该网络由Werbos在1974年、Parker在1985年以及Rumelhart等人在1986年独立提出，其核心是误差反向传播算法。BP网络因其能够处理非线性问题和自适应学习能力，在各种领域得到了广泛应用。 BPN的体系结构包括输入层、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值