BP神经网络原理及C++代码实现

最新推荐文章于 2024-03-09 16:30:01 发布
最新推荐文章于 2024-03-09 16:30:01 发布
阅读量1.5w 收藏 107
点赞数 20
分类专栏： 机器学习算法的一些理解总结 文章标签： BP算法 BP神经网络 BP神经网络C++实现 视觉机器学习之BP算法推导 BP算法及C++实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AP1005834/article/details/52951501
版权

                               

                               

                               

                               

                               

                               

                               

                               

                               

                               

                               

                               

                               

                               

                               

                             

//ann_bp.h//
#ifndef _ANN_BP_H_
#define _ANN_BP_H_

#include <assert.h>
#include <stdlib.h>
#include <iostream>
#include <string.h>
#include <windows.h>
#include <ctime>

class Ann_bp
{
public:
	explicit Ann_bp(int _SampleN, int nNIL, int nNOL, const int nNHL, float _sR = 0.2);
	~Ann_bp();

	void train(int _sampleNum, float** _trainMat, int** _labelMat);
	void predict(float* in, float* proba);

private:
	int numNodesInputLayer;
	int numNodesOutputLayer;
	int numNodesHiddenLayer;
	int SampleCount;               //总的训练样本数
	double ***weights;            //网络权值
	double **bias;                 //网络偏置
	float studyRate;               //学习速率

	double *hidenLayerOutput;     //隐藏层各结点的输出值
	double *outputLayerOutput;     //输出层各结点的输出值

	double ***allDeltaBias;        //所有样本的偏置更新量
	double ****allDeltaWeights;    //所有样本的权值更新量
	double **outputMat;            //所有样本的输出层输出

	void train_vec(const float* _trainVec, const int* _labelVec, int index);
	double sigmoid(double x){ return 1 / (1 + exp(-1 * x)); }
	bool Ann_bp::isNotConver(const int _sampleNum, int** _labelMat, double _thresh);

};

#endif

//ann_bp.cpp//
#include "ann_bp.h"
#include <math.h>

Ann_bp::Ann_bp(int _SampleN, int nNIL, int nNOL, const int nNHL, float _sR) :
SampleCount(_SampleN), numNodesInputLayer(nNIL), numNodesOutputLayer(nNOL),
numNodesHiddenLayer(nNHL), studyRate(_sR)
{

	//创建权值空间,并初始化
	srand(time(NULL));
	weights = new double**[2];
	weights[0] = new double *[numNodesInputLayer];
	for (int i = 0; i < numNodesInputLayer; ++i){
		weights[0][i] = new double[numNodesHiddenLayer];
		for (int j = 0; j <numNodesHiddenLayer; ++j){
			weights[0][i][j] = (rand() % (2000) / 1000.0 - 1); //-1到1之间
		}
	}
	weights[1] = new double *[numNodesHiddenLayer];
	for (int i = 0; i < numNodesHiddenLayer; ++i){
		weights[1][i] = new double[numNodesOutputLayer];
		for (int j = 0; j < numNodesOutputLayer; ++j){
			weights[1][i][j] = (rand() % (2000) / 1000.0 - 1); //-1到1之间
		}
	}

	//创建偏置空间，并初始化
	bias = new double *[2];
	bias[0] = new double[numNodesHiddenLayer];
	for (int i = 0; i < numNodesHiddenLayer; ++i){
		bias[0][i] = (rand() % (2000) / 1000.0 - 1); //-1到1之间
	}
	bias[1] = new double[numNodesOutputLayer];
	for (int i = 0; i < numNodesOutputLayer; ++i){
		bias[1][i] = (rand() % (2000) / 1000.0 - 1); //-1到1之间
	}

	//创建隐藏层各结点的输出值空间
	hidenLayerOutput = new double[numNodesHiddenLayer];
	//创建输出层各结点的输出值空间
	outputLayerOutput = new double[numNodesOutputLayer];

	//创建所有样本的权值更新量存储空间
	allDeltaWeights = new double ***[_SampleN];
	for (int k = 0; k < _SampleN; ++k){
		allDeltaWeights[k] = new double**[2];
		allDeltaWeights[k][0] = new double *[numNodesInputLayer];
		for (int i = 0; i < numNodesInputLayer; ++i){
			allDeltaWeights[k][0][i] = new double[numNodesHiddenLayer];
		}
		allDeltaWeights[k][1] = new double *[numNodesHiddenLayer];
		for (int i = 0; i < numNodesHiddenLayer; ++i){
			allDeltaWeights[k][1][i] = new double[numNodesOutputLayer];
		}
	}

	//创建所有样本的偏置更新量存储空间
	allDeltaBias = new double **[_SampleN];
	for (int k = 0; k < _SampleN; ++k){
		allDeltaBias[k] = new double *[2];
		allDeltaBias[k][0] = new double[numNodesHiddenLayer];
		allDeltaBias[k][1] = new double[numNodesOutputLayer];
	}

	//创建存储所有样本的输出层输出空间
	outputMat = new double*[ _SampleN ];
	for (int k = 0; k < _SampleN; ++k){
		outputMat[k] = new double[ numNodesOutputLayer ];
	}


}

Ann_bp::~Ann_bp()
{
	//释放权值空间
	for (int i = 0; i < numNodesInputLayer; ++i)
		delete[] weights[0][i];
	for (int i = 1; i < numNodesHiddenLayer; ++i)
		delete[] weights[1][i];
	for (int i = 0; i < 2; ++i)
		delete[] weights[i];
	delete[] weights;

	//释放偏置空间
	for (int i = 0; i < 2; ++i)
		delete[] bias[i];
	delete[] bias;

	//释放所有样本的权值更新量存储空间
	for (int k = 0; k < SampleCount; ++k){
		for (int i = 0; i < numNodesInputLayer; ++i)
			delete[] allDeltaWeights[k][0][i];
		for (int i = 1; i < numNodesHiddenLayer; ++i)
			delete[] allDeltaWeights[k][1][i];
		for (int i = 0; i < 2; ++i)
			delete[] allDeltaWeights[k][i];
		delete[] allDeltaWeights[k];
	}
	delete[] allDeltaWeights;

	//释放所有样本的偏置更新量存储空间
	for (int k = 0; k < SampleCount; ++k){
		for (int i = 0; i < 2; ++i)
			delete[] allDeltaBias[k][i];
		delete[] allDeltaBias[k];
	}
	delete[] allDeltaBias;

	//释放存储所有样本的输出层输出空间
	for (int k = 0; k < SampleCount; ++k)
		delete[] outputMat[k];
	delete[] outputMat;

}

void Ann_bp::train(const int _sampleNum, float** _trainMat, int** _labelMat)
{
	double thre = 1e-4;
	for (int i = 0; i < _sampleNum; ++i){
		train_vec(_trainMat[i], _labelMat[i], i);
	}
	int tt = 0;
	while (isNotConver(_sampleNum, _labelMat, thre) && tt<100000){
		tt++;
		//调整权值
		for (int index = 0; index < _sampleNum; ++index){
			for (int i = 0; i < numNodesInputLayer; ++i){
				for (int j = 0; j < numNodesHiddenLayer; ++j){
					weights[0][i][j] -= studyRate* allDeltaWeights[index][0][i][j];
				}
			}
			for (int i = 0; i < numNodesHiddenLayer; ++i){
				for (int j = 0; j < numNodesOutputLayer; ++j){
					weights[1][i][j] -= studyRate* allDeltaWeights[index][1][i][j];
				}
			}
		}

		for (int index = 0; index < _sampleNum; ++index){
			for (int i = 0; i < numNodesHiddenLayer; ++i){
				bias[0][i] -= studyRate* allDeltaBias[index][0][i];
			}
			for (int i = 0; i < numNodesOutputLayer; ++i){
				bias[1][i] -= studyRate*allDeltaBias[index][1][i];
			}
		}

		for (int i = 0; i < _sampleNum; ++i){
			train_vec(_trainMat[i], _labelMat[i], i);
		}
	}

	printf("训练权值和偏置成功了！\n");
}

void Ann_bp::train_vec(const float* _trainVec, const int* _labelVec, int index)
{
	//计算各隐藏层结点的输出
	for (int i = 0; i < numNodesHiddenLayer; ++i){
		double z = 0.0;
		for (int j = 0; j < numNodesInputLayer; ++j){
			z += _trainVec[j] * weights[0][j][i];
		}
		z += bias[0][i];
		hidenLayerOutput[i] = sigmoid(z);
		
	}

	//计算输出层结点的输出值
	for (int i = 0; i < numNodesOutputLayer; ++i){
		double z = 0.0;
		for (int j = 0; j < numNodesHiddenLayer; ++j){
			z += hidenLayerOutput[j] * weights[1][j][i];
		}
		z += bias[1][i];
		outputLayerOutput[i] = sigmoid(z);
		outputMat[index][i] = outputLayerOutput[i];
	}

	//计算偏置及权重更新量，但不更新

	for (int j = 0; j <numNodesOutputLayer; ++j){
		allDeltaBias[index][1][j] = (-0.1)*(_labelVec[j] - outputLayerOutput[j])*outputLayerOutput[j]
			* (1 - outputLayerOutput[j]);
		for (int i = 0; i < numNodesHiddenLayer; ++i){
			allDeltaWeights[index][1][i][j] = allDeltaBias[index][1][j] * hidenLayerOutput[i];
		}
	}
	for (int j = 0; j < numNodesHiddenLayer; ++j){
		double z = 0.0;
		for (int k = 0; k < numNodesOutputLayer; ++k){
			z += weights[1][j][k] * allDeltaBias[index][1][k];
		}
		allDeltaBias[index][0][j] = z*hidenLayerOutput[j] * (1 - hidenLayerOutput[j]);
		for (int i = 0; i < numNodesInputLayer; ++i){
			allDeltaWeights[index][0][i][j] = allDeltaBias[index][0][j] * _trainVec[i];
		}
	}

}


bool Ann_bp::isNotConver(const int _sampleNum,
	int** _labelMat, double _thresh)
{
	double lossFunc = 0.0;
	for (int k = 0; k < _sampleNum; ++k){
		double loss = 0.0;
		for (int t = 0; t < numNodesOutputLayer; ++t){
			loss += (outputMat[k][t] - _labelMat[k][t])*(outputMat[k][t] - _labelMat[k][t]);
		}
		lossFunc += (1.0 / 2)*loss;
	}

	lossFunc = lossFunc / _sampleNum;

	//for (int k = 0; k < _sampleNum; ++k){
	//	for (int i = 0; i< numNodesOutputLayer; ++i){
	//		std::cout << outputMat[k][i] << " " ;
	//	}
	//	std::cout << std::endl;
	//}

	第几次时的损失函数值//
	static int tt = 0;
	printf("第%d次训练：", ++tt);
	printf("%0.12f\n", lossFunc);


	if (lossFunc > _thresh)
		return true;

	return false;
}

void Ann_bp::predict(float* in, float* proba)
{
	输出训练得到的权值
	//std::cout << "\n输出训练得到的权值:\n";
	//for (int i = 0; i < numNodesInputLayer; ++i){
	//	for (int j = 0; j < numNodesHiddenLayer; ++j)
	//		std::cout <<weights[0][i][j] << " ";
	//}
	//std::cout << "\n\n\n";
	//for (int i = 0; i < numNodesHiddenLayer; ++i){
	//	for (int j = 0; j < numNodesOutputLayer; ++j)
	//		std::cout<< weights[1][i][j] << " ";
	//}
	//std::cout << "\n输出训练得到的偏置:\n";
	//for (int i = 0; i < numNodesHiddenLayer; ++i)
	//	std::cout << bias[0][i] << " ";
	//std::cout << "\n\n\n";
	//for (int j = 0; j < numNodesOutputLayer; ++j)
	//	std::cout << bias[1][j] << " ";
	//Sleep(5000);

	//计算各隐藏层结点的输出
	for (int i = 0; i < numNodesHiddenLayer; ++i){
		double z = 0.0;
		for (int j = 0; j < numNodesInputLayer; ++j){
			z += in[j] * weights[0][j][i];
		}
		z += bias[0][i];
		hidenLayerOutput[i] = sigmoid(z);

	}

	//计算输出层结点的输出值
	for (int i = 0; i < numNodesOutputLayer; ++i){
		double z = 0.0;
		for (int j = 0; j < numNodesHiddenLayer; ++j){
			z += hidenLayerOutput[j] * weights[1][j][i];
		}
		z += bias[1][i];
		outputLayerOutput[i] = sigmoid(z);
		std::cout << outputLayerOutput[i] << " ";
	}
	
}
//main.cpp
#include "ann_bp.h"


int main()
{
	const int hidnodes = 8; //单层隐藏层的结点数
	const int inNodes = 10;   //输入层结点数
	const int outNodes = 5;  //输出层结点数

	const int trainClass = 5; //5个类别
	const int numPerClass = 30;  //每个类别30个样本点
	
	int sampleN = trainClass*numPerClass;     //每类训练样本数为30，5个类别，总的样本数为150
	float **trainMat = new float*[sampleN];                         //生成训练样本
	for (int k = 0; k < trainClass; ++k){
		for (int i = k * numPerClass; i < (k + 1) * numPerClass; ++i){
			trainMat[i] = new float[inNodes];
			for (int j = 0; j < inNodes; ++j){
				trainMat[i][j] = rand() % 1000 / 10000.0 + 0.1*(2 * k + 1);

			}
		}
	}

	int **labelMat = new int*[sampleN]; //生成标签矩阵
	for (int k = 0; k < trainClass; ++k){
		for (int i = k * numPerClass; i < (k + 1) * numPerClass; ++i){
			labelMat[i] = new int[outNodes];
			for (int j = 0; j <trainClass; ++j){
				if (j == k)
					labelMat[i][j] = 1;
				else
					labelMat[i][j] = 0;
			}

		}
	}

	Ann_bp ann_classify(sampleN, inNodes, outNodes, hidnodes, 0.12);  //输入层为10个结点，输出层5个结点，单层隐藏层
	ann_classify.train(sampleN, trainMat, labelMat);


	for (int i = 0; i < 30; ++i){
		ann_classify.predict(trainMat[ i+120], NULL);
		std::cout << std::endl;
	}


	//释放内存
	for (int i = 0; i < sampleN; ++i)
		delete[] trainMat[i];
	delete[] trainMat;

	for (int i = 0; i < sampleN; ++i)
		delete[] labelMat[i];
	delete[] labelMat;

	return 0;
}
                            
                            


                            


ForeverYang2015
关注
  • 20
    点赞
  • 踩
  • 107
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
神经网络pid程序c语言,基于bp神经网络pid控制程序
weixin_39842237的博客
05-18 1015
%BP based PID Controlclear all;close all;xite=0.25;alfa=0.05;S=2; %Signal typeIN=4;H=5;Out=3; %NN Structureif S==1 %Step Signalwi=[-0.6394 -0.2696 -0.3756 -0.7023;-0.8603 -0.2013 -0.5024 -0.2596;-1.07...
BP神经网络字符识别C++.zip
06-04
文件包含BP神经网络的训练以及识别代码、简单的字符库。c++编程。运行环境：win7+Opencv+vs2010.
BP神经网络的C++代码实现
03-21
本资源已经过调试，可以运行； 文件包含ann_bp.h ann_bp.cpp main.cpp C++工程需要你自己建，文件添加已有文件就可以了，环境简单，保证头文件包含正确就可以 原文地址BP神经网络原理及C++代码实现： https://blog.csdn.net/ap1005834/article/details/52951501
BP神经网络的c++实现 源码下载
06-02
用c++实现了BP神经网络类，文件中含有测试数据，测试效果良好，关于该BP神经网络类的实现原理，参考本人关于BP神经网络叙述的博客 http://blog.csdn.net/hjkhjk007/article/details/9001304
BP神经网络（python实现）
最新发布
2303_78738507的博客
03-09 1778
BP神经网络的学习属于有监督学习，需要一组已知期望输出的学习样本集。训练时先使用随机值作为权值（即权重，取值在前向传播部分有介绍），输入学习样本得到网络的输出。然后根据输出值与期望输出计算误差，再由误差根据某种准则逐层修改权值，使误差减小。如此反复，直到误差不再下降，网络就完成训练。
C语言实现神经网络
weixin_62562497的博客
09-04 1248
这个例子中，我们实现了一个简单的单层神经网络，它只有一个输入节点和一个输出节点，权重向量有3个元素（对应于输入节点和输出节点之间的3个连接），偏置为0。我们使用sigmoid作为激活函数，使用梯度下降法进行训练。在训练过程中，我们根据期望的输出和实际的输出计算误差，然后根据误差和梯度更新权重和偏置。最后，我们使用训练好的神经网络来计算输入为[1, 1]时的输出，输出结果为0.99。神经网络是一种深度学习的结构，它可以模拟人脑的神经元来进行复杂的学习和预测。下面是一个简单的使用C语言实现神经网络的例子。
C++实现的BP神经网络（代码与详解）
热门推荐
菜鸡也有大佬梦
08-28 4万+
描述部分 什么是BP神经网络 这个百度比较多就不赘述了 在看到我的文章前一定也看了不少了! 开篇先说几点 本文是基于博客"https://blog.csdn.net/ironyoung/article/details/49455343"补充与拓展 本文努力去通俗的阐述bp神经网络原理 与结合实际bp网络图重构其代码 尤其核心算法部分 让bp算法使用更清晰明了 并且下面贴的代码注释非常全 保证每...
C++简单的BP神经网络
qq_31731573的博客
09-25 346
BP神经网络在不同学习率的情况下最终的迭代精度会有所不同，学习率较小时，达到同样精度需要更多的迭代次数，学习率过大时，则会导致迭代精度偏差较大，甚至出现震荡现象，容易导致过拟合，因此在实际情况中应该选择一个合适的学习率，或者根据迭代次数进行学习率的动态变化从而达到更好的效果。
机器学习——BP神经网络的C++简易实现
weixin_43856705的博客
12-13 1418
机器学习，BP神经网络
机器学习--BP神经网络的C++实现
chaoshengmingyue的博客
06-06 1777
激活函数:Sigmoid 使用的是周志华老师的《机器学习》一书上的更新公式。 #include <iostream> #include <cstdlib> #include <ctime> #include <cmath> using namespace std;#define innode 3 //输入结点数 #define outnode 1 //输出结点数 #define
Bp神经网络+C++实现
MasterQKK
10-22 1万+
0 前言　　神经网络在我印象中一直比较神秘，正好最近学习了神经网络，特别是对Bp神经网络有了比较深入的了解，因此，总结以下心得，希望对后来者有所帮助。 　　神经网络在机器学习中应用比较广泛，比如函数逼近，模式识别，分类，数据压缩，数据挖掘等领域。神经网络本身是一个比较庞大的概念，从网络结构类别来划分，大概有：多层前馈神经网络、径向基函数网络（RBF）、自适应谐振理论网络（ART）、自组织映射
BP神经网络 c++完整实现代码
01-08
BP神经网络 c++完整实现代码,加了非常详细的注释，代码可以直接运行
c++实现的bp神经网络
10-19
使用c++实现的bp神经网络，包括隐含层的，和神经元的个数
BP神经网络 C++实现
11-07
利用C++实现BP神经网络，可以调整最大训练次数、训练中允许的误差、网络权值等参数
c++实现的BP神经网络实例
02-25
使用C++实现BP神经网络对一组学习样本进行学习。
BP神经网络C++实现——简单模式识别
12-29
基于MFC的BP神经网络实现的简单模式识别，欢迎各位下载学习。
C++实现神经BP神经网络
12-17
本文实例为大家分享了C++实现神经BP神经网络的具体代码，供大家参考，具体内容如下 BP.h #pragma once #include #include #include #include #include using std::vector; using std::exp; using std::cout; using ...
关于C++实现的BP神经网络（代码）
01-19
#pragma hdrstop 　#include  　#include  　const A=30.0; 　const B=10.0; 　const MAX=500; //训练次数 ... //网络的学习效率 ...//网络的阀值调整效率 ... // 网络训练中的允许误差 ...//网络要求精
C++实现简单BP神经网络
08-19
主要为大家详细介绍了C++实现简单BP神经网络，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
bp神经网络 pid智能控制 c++实现
10-04
BP神经网络（Back Propagation Neural Network）是一种常用的人工神经网络模型，主要用于模式识别和函数逼近等任务。PID智能控制是一种经典的自适应控制算法，可以用于实现对系统的自动调节和控制。本文将介绍如何使用C语言实现BP神经网络和PID智能控制。 首先，我们来介绍BP神经网络的实现。BP神经网络由输入层、隐藏层和输出层组成，其中隐藏层可以有多个。在C语言中，我们可以使用多维数组来表示神经网络的权值和偏置，使用循环来进行神经网络的前向传播和反向传播的计算。具体步骤如下： 1. 初始化神经网络的权值和偏置； 2. 输入样本数据，通过前向传播计算网络的输出值； 3. 计算网络误差，并通过反向传播调整网络的权值和偏置； 4. 重复步骤2和3，直到网络达到收敛。 接下来，我们来介绍PID智能控制的实现。PID控制器由比例控制、积分控制和微分控制三个部分组成。在C语言中，我们可以使用变量和循环来实现PID控制。具体步骤如下： 1. 初始化PID控制器的参数； 2. 获取当前系统的反馈值（例如温度、速度等）； 3. 根据比例控制、积分控制和微分控制计算出控制信号； 4. 通过控制信号对系统进行控制； 5. 重复步骤2到4，直到系统达到期望状态或者满足停止条件。 综上所述，使用C语言可以分别实现BP神经网络和PID智能控制。在实际工程中，我们可以将这两种方法结合起来，使用BP神经网络进行模型学习和参数自动调节，并将学习到的控制模型应用于PID控制中，以实现对复杂系统的智能控制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值