机器学习BP神经网络，任意拓扑结构 （C++）

最新推荐文章于 2025-07-07 10:02:33 发布
最新推荐文章于 2025-07-07 10:02:33 发布
阅读量1.3k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/baidu_23081367/article/details/78166883
该博客介绍了如何使用C++实现具有任意拓扑结构的BP神经网络，针对老板提到的节点导出问题，博主提出了更换激活函数的解决方案，以避免sigmoid函数在多层时导致的梯度爆炸。通过net<10>定义网络含有10个节点，并提供input.txt文件格式说明，用于描述节点间的连接关系，支持任意拓扑结构的网络配置。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这次的版本更优秀了的样子！

按照老板说的，每个节点是单独的导出节点（会导致sigmod训练变慢，原因sigmod层数多了，梯度会下降很快导致爆炸。）


换个激活函数就行了。

net<10>表示网咯有10个节点

然后input.txt里的文件格式大概是

n

0 1

1 2

3 4

....

n表示有n行，每行2个数字，表示2个点有边。（0下标开始，不超过net初始化的节点数量）。任意拓扑结构都可以运行。


#include <bits/stdc++.h>
#include "recordlog.h"
#include <memory>

using std::cin;
using std::endl;
using std::cout;
#define pr(x)	cout<<#x<<" = "<<x<<" "
#define prln(x)	cout<<#x<<" = "<<x<<endl


#define NODE		(neurons[node])
#define NODE_GAIN	(NODE.energy)
#define NODE_THETA	(NODE.loss_energy)			//node节点的theta，也就是阈值
#define NODE_VALUE	(NODE_GAIN + NODE_THETA)	//node节点的实际能量（获得能量+theta）
#define NODE_OUTPUT 	(NODE.output)				//node节点的实际输出
#define NODE_PE		(NODE.partial_derivative)		//node节点output，对最终答案的导数
#define D_NODE		(derivative(NODE_VALUE))		//node节点获得的所有能量（加过theta的），对于node节点output的导数



#define NEXT_NODE		(neurons[nextnode.first])
#define NEXT_NODE_OUTPUT 	(NEXT_NODE.output)				//node节点的实际输出
#define NEXT_NODE_GAIN		(NEXT_NODE.energy)
#define NEXT_NODE_PE		(NEXT_NODE.partial_derivative)			//node节点output，对最终答案的导数
#define NEXT_NODE_THETA		(NEXT_NODE.loss_energy)				//node节点的theta，也就是阈值
#define NEXT_NODE_VALUE		(NEXT_NODE_GAIN + NEXT_NODE_THETA)	//node节点的实际能量（获得能量+theta）
#define D_NEXT_NODE		(derivative(NEXT_NODE_VALUE))			//node节点获得的所有能量（加过theta的），对于node节点output的导数
#define NODE_TO_NEXTNODE_WEIGHT (nextnode.second)

class neuron_t;
typedef std::pair<int, double> 		PID;
typedef std::vector<PID> 		neuron_array_t;
typedef std::vector<int>	  	vector_map_t;
typedef std::unique_ptr<neuron_t>	neuron_ptr_t;

class neuron_t
{
	public:
		double 			energy;
		double			output;
		int 			number;
		double 			loss_energy;
		neuron_array_t 		neuron_array;
		double			partial_derivative;
		bool			is_input;
		bool			is_output;
};

template<int neuron_size>
class net_t
{
	public:
		neuron_t		neurons[neuron_size];
		vector_map_t		vector_map[neuron_size];
		std::string		activation_way;			//激活函数的选择，默认ReLU

		std::vector<double>	input_weight;

		std::vector<int> 	output_number;
		std::vector<int> 	input_number;
		int 			tmp[neuron_size];		//临时数组，生成过n的全排列，和拓扑排序中记录入度。
		int 			height[neuron_size];		//辅助构图的高度数组
		int			topology[neuron_size];		//拓扑序
		double			rate;				//学习率
		int			userful_neuron_size;

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

		static double line(double x)
		{
			return x;
		}

		static double ReLU(double x)
		{
			if (x<=0)	return 0;
			return x;
		}

		double derivative(double x)
		{
			if (activation_way == "sigmoid"){
				return sigmoid(x) * (1 - sigmoid(x));
			}
			if (activation_way == "ReLU"){
				if (x<0)	return 0;
				return 1;
			}
			if (activation_way == "line"){
				return 1;
			}
			cout<<"no activationFunction!"<<endl;
			return 0;
		
		}

		double activationFunction(double sum, double theta)
		{
			if (activation_way == "sigmoid"){
				return sigmoid(sum + theta);
			}
			if (activation_way == "ReLU"){
				return ReLU(sum + theta);
			}
			if (activation_way == "line"){	
				return line(sum + theta);
			}
			cout<<"no activationWay !" << endl;
			return 0;
		}

		static double randomDouble(double l, double r)
		{
			return randomInt(l*10000, r * 10000)/10000.0;
		}

		static long long randomInt(long long L, long long R)
		{
			long long tmp = (unsigned long long)rand()
				*(unsigned long long)rand()
				*(unsigned  long long)rand()
				*(unsigned long long)rand() % (R - L + 1);
			return L + tmp;
		}

		~net_t()
		{
		}


		net_t (std::string file_name)
		{
			//初始化新的网络
			FILE *file = fopen(file_name.c_str(), "r");
			printf("[%s]\n", file_name.c_str());
			int n;
			fscanf(file, "%d", &n);
			this -> activation_way = "sigmoid";
			this -> rate = 0.1;	//xuexilv
			for (int i = 0; i < neuron_size; ++ i){
				vector_map[i].clear();
				tmp[i] = i;
				neurons[i].number = i;
				neurons[i].is_input = false;
				neurons[i].is_output = false;
			}
			this -> output_number.clear();
			this -> input_number.clear();
			prln(neuron_size);
			while (n--){
				int s, t;
				fscanf(file, "%d%d", &s, &t);
				cout<<s<<" "<<t<<endl;
				vector_map[s].push_back(t);
				vector_map[t].push_back(s);
			}
			fclose(file);
		}

		net_t()
		{
			*this = net_t("input.txt");
		}

		void initInputNeuron(std::vector<int> &input_num){
			int sz = input_num.size();
			input_weight.resize(sz);
			for (int i = 0; i < sz; ++ i){
				input_weight[i] = randomDouble(-1, 1);
				neurons[input_num[i]].is_input = true;
			}
		}

		void setIO(std::vector<double> &input, std::vector<double> &output, std::vector<int> *input_num = NULL, std::vector<int> *output_num = NULL){
			if (input.size() == 0){
				//throws something TODO
				return;
			}
			if (output.size() == 0){
				//throws something TODO
				return;
			}

			if (input_num && output_num)
			{
				output_number = *output_num;
				input_number = *input_num;
			}
			else
			{
				std::random_shuffle(tmp, tmp + neuron_size);
				printf("output nodes are: ");
				for (int i = 0; i < output.size(); ++ i){
					output_number.push_back(tmp[i]);
					printf("%d ",tmp[i]);
				}
				printf("\n");
				printf("input nodes are:");
				for (int i = output.size(); i < input.size() + output.size(); ++ i){
					input_number.push_back(tmp[i]);
					printf("%d ",tmp[i]);
				}
				printf("\n");
			}
			initInputNeuron(*input_num);
			for (int i = 0; i < output.size(); ++ i){
				neurons[output_number[i]].is_output = true;
				//pr(i),prln(output_number[i]);
			}

			std::queue<int>q[output.size() + input.size()];
			memset(height, -1, sizeof(height));
			int painted = output.size();
			int cnt=0;
			for (auto curnode : output_number){
				q[cnt++].push(curnode);
				height[curnode] = 0;
			}
			for (auto curnode : input_number){
				q[cnt++].push(curnode);
				height[curnode] = neuron_size;
			}
			bool flag = true;
			while (flag){
				int cnt = 0;
				flag = false;
				for (auto curnode : output_number){
					flag |= bfs(q[cnt++], 1);
				}
				for (auto curnode : input_number){
					flag |= bfs(q[cnt++], -1);
				}
			}
			auto build_map = [=](int from, int to){
				neurons[from].neuron_array.push_back(std::make_pair(to, randomDouble(-1,1)));
			};
			for (int i = 0; i < neuron_size; ++ i){
				for (auto curnode : vector_map[i]){
					if (height[i] > height[curnode]){
						build_map(i, curnode);
					}
				}
			}
			for (int i = 0; i < neuron_size; ++ i){
				neurons[i].loss_energy = randomDouble(-1, 1);
			}
			getTopology();
			//至此构造完网络的拓扑结构
		}

		void getTopology()
		{
			memset(tmp, 0, sizeof(tmp));
			for (int i = 0; i < neuron_size; ++ i){
				for (auto nextnode : neurons[i].neuron_array){
					++ tmp[nextnode.first];
				}
			}
			std::queue<int>q;
			for (auto curnode : input_number){
				q.push(curnode);
			}
			int pos = 0;
			while (!q.empty())
			{
				int curnode = q.front();
				q.pop();
				topology[pos++] = curnode;
				for (auto nextnode : neurons[curnode].neuron_array){
					if(-- tmp[nextnode.first] == 0){
						q.push(nextnode.first);
					}
				}
			}
			userful_neuron_size = pos;
			//DEBUG
			//for (int i = 0; i < neuron_size; ++ i)
			//	pr(i),prln(topology[i]);

		}

		bool bfs(std::queue<int> &q, int delta){
			if (q.empty()){
				return false;
			}
			int h = height[q.front()];
			while (!q.empty() && height[q.front()] == h){
				int curnode = q.front();
				q.pop();
				for (auto nextnode : vector_map[curnode]){
					if (height[nextnode] != -1){
						continue;
					}
					height[nextnode] = h + delta;
					q.push(nextnode);
				}
			}
			return true;
		}

		void cal_propagate(int node){
			NODE_OUTPUT = activationFunction(NODE_GAIN, NODE_THETA);
			for (auto nextnode : NODE.neuron_array){
				NEXT_NODE_GAIN += NODE_OUTPUT * NODE_TO_NEXTNODE_WEIGHT;
			}
		}

		void propagate(std::vector<double> &input){
			//TODO
			
			
			/*
			for (int i = 0; i < input_number.size(); ++i)
			{
				input_weight[i] = 1;
			}
			*/
			

			for (int i = 0; i < neuron_size; ++ i){
				neurons[i].energy = 0;
				neurons[i].output = 0;
			}

			for (int i = 0; i != input.size(); ++ i){
				int node = input_number[i];
				NODE_GAIN += input_weight[i] * input[i];
			}

			for (int i = 0; i < userful_neuron_size; ++ i){
				int node = topology[i];
				cal_propagate(node);
			}
		}

		void cal_back(int node){
			for (auto &nextnode : NODE.neuron_array){
				NODE_PE += NEXT_NODE_PE * NODE_TO_NEXTNODE_WEIGHT * D_NEXT_NODE;
			}

			for (auto &nextnode : NODE.neuron_array){
				NODE_TO_NEXTNODE_WEIGHT -= NODE_OUTPUT * D_NEXT_NODE * NEXT_NODE_PE * rate;
			}
			NODE_THETA -= NODE_PE * D_NODE * rate;
		}

		void back(std::vector<double> &input, std::vector<double> &output){
			for (int i = 0; i < neuron_size; ++ i){
				neurons[i].partial_derivative = 0;
			}

			for (int i = 0; i != output.size(); ++ i)
			{
				int node = output_number[i];
				NODE_PE = NODE_OUTPUT - output[i];
				NODE_THETA -= NODE_PE * D_NODE * rate;
			}

			for (int i = userful_neuron_size - 1; i >= 0; -- i){
				int node = topology[i];
				if (NODE.is_output){
					continue;
				}
				else{
					cal_back(node);
				}
			}

			for (int i = 0; i < input.size(); ++ i){
				int node = input_number[i];
				double tmp = input[i] * NODE_PE * D_NODE;
				//prln(tmp);
				//prln(input_weight[i]);
				input_weight[i] -= tmp * rate;
				//prln(input_weight[i]);
			}
		}

		double train(std::vector<double> &input, std::vector<double> &output){
			propagate(input);
			//	outputNetwork();
			back(input, output);
			double error=0;
			for (int i = 0; i < output.size(); ++ i){
				error += 0.5*pow((neurons[output_number[i]].output - output[i]), 2);
			}
			return error;
		}

		void outputNetwork(){
			printf("---------------input nodes------------:\n");
			for (int i = 0; i < input_number.size(); ++ i)
			{
				printf("[%d] weight:(%.7lf) \n", input_number[i], input_weight[i]);
			}
			printf("---------------other nodes------------\n");
			printf("other nodes\n");
			for (int i = 0; i < neuron_size; ++ i){
				pr(topology[i]),prln(i);
				int node = topology[i];
				printf("[%d] gain(%.7lf) theta(%.7lf) par_derivative(%.7lf) output(%.7lf) d(%.7lf)\n", 
						node,
						NODE_GAIN,
						NODE_THETA, 
						NODE_PE, 
						NODE_OUTPUT, 
						D_NODE);
				for (auto nextnode : NODE.neuron_array){
					printf("  -> %d (%.7lf)\n", nextnode.first, nextnode.second);
				}
			}
			printf("=============End====================\n");
		}

		void testOutput(std::vector<double> &input)
		{
			propagate(input);
			cout<<"output: ";
			for (auto curnode : output_number)
			{
				printf("%.7lf ", neurons[curnode].output);
			}
			cout<<endl;
		}

		std::vector<double> getTest(std::vector<double> &input)
		{
			std::vector<double> q;
			for (auto curnode : output_number)
			{
				q.push_back(neurons[curnode].energy);
			}
			return move(q);
		}
};

void doit251()
{
	std::vector<int>in({0,1});
	std::vector<int>out({7});
	net_t<8> net;//("input.txt");
	srand(0);
	std::vector<double>input1({0,0});
	std::vector<double>input2({0,1});
	std::vector<double>input3({1,0});
	std::vector<double>input4({1,1});
	std::vector<double>output1({0});
	std::vector<double>output2({1});
	std::vector<double>output3({1});
	std::vector<double>output4({0});

	net.setIO(input1, output1, &in, &out);
	net.activation_way = "sigmoid";
	net.rate = 20;



	/*
	net.propagate(input3);
	net.outputNetwork();
	net.back(input3, output3);
	net.outputNetwork();
	return;
	*/




	double error=0;
	for (int i = 1;i<=20000;++i){
		error = 0;
		error += net.train(input1, output1);
		error += net.train(input2, output2);
		error += net.train(input3, output3);
		error += net.train(input4, output4);
		error/=4;
		cout<<error<<"\r";
	}
	prln(error);
	//prln(net.userful_neuron_size);
	net.testOutput(input1);
	net.testOutput(input2);
	net.testOutput(input3);
	net.testOutput(input4);
}


int main()
{
	doit251();
	return 0;
}


bp神经网络模型拓扑结构,bp神经网络模型结构图
shirley67269的博客
08-14 5061
一、BP模型概述误差逆传播(ErrorBack-Propagation)神经网络模型简称为BP(Back-Propagation)网络模型。PallWerbas博士于1974年在他的博士论文中提出了误差逆传播学习算法。完整提出并被广泛接受误差逆传播学习算法的是以Rumelhart和McCelland为首的科学家小组。他们在1986年出版“ParallelDistributedProcessing，ExplorationsintheMicrostructureofCognition”(《并行分布信息处理》)一
BP神经网络的结构
热门推荐
vili_sky的博客
04-03 1万+
BP（Back Propagation）神经网络是1986年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用梯度下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模
算法与数据结构基础10：C++实现——拓扑排序
寒风的技术博客
12-08 5360
一 定义 拓扑排序是对有向无环图(Directed Acyclic Graph简称DAG)顶点的一种排序， 它使得如果存在一条从顶点A到顶点B的路径，那么在排序中B出现在A的后面。 二 先决条件 能够进行拓扑排序图有两个先决条件：有向、无环，即有向无环图。 三 偏序全序 连通图：任意两点之间都存在至少一条边 偏序：非连通图（有向无环图满足偏序关系） 全序：单连通图
BP神经网络：机器学习算法的实现与应用
最新发布
weixin_31419153的博客
07-07 748
人工神经网络（ANN）是一类模仿生物神经网络行为特征，进行信息处理的数学模型。其中，BP神经网络（Backpropagation Neural Network）是一种按误差逆传播算法训练的多层前馈神经网络。BP网络通过输入层接收数据，中间经过一个或多个隐藏层，最后输出结果。在机器学习尤其是神经网络训练过程中，过拟合（Overfitting）与欠拟合（Underfitting）是两个常见的问题。
网络拓扑图绘制（C++）
01-15
在某个开源网站下载的，分享之。用c++编写的绘制网络拓扑图的软件，基本功能都有！
C++ 元编程之代码生成：设计并实现拓扑结构 DSL
Hsuesh的博客
09-08 971
对比 来看看这幅图， 原先方式是需要这样描述： tf::Taskflow taskflow; tf::Task A = taskflow.emplace([] () {}).name("A"); tf::Task B = taskflow.emplace([] () {}).name("B"); tf::Task C = taskflow.emplace([] () {}).name("C"); tf::Task D = taskflow.emplace([] () {}).name("
bp神经网络模型拓扑结构,bp神经网络模型是什么
神经网络爱好者
08-12 2916
BP（BackPropagation）神经网络是1986年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hiddenlayer)和输出层(outputlayer)。...
BP神经网络的C语言实现_bp识别_visualc_Vc_
10-01
BP神经网络，全称为Backpropagation Neural Network，是一种在机器学习领域广泛应用的多层前馈神经网络。这种网络通过反向传播算法来调整权重，从而实现对复杂非线性问题的学习。在本项目中，"BP神经网络的C语言实现...
C++环境下bp神经网络的实现及应用
在C++中实现BP神经网络需要对神经网络的基本原理有所理解，包括神经元的工作原理、激活函数的选择、网络结构的设计、前向传播和误差反向传播的过程、权重更新的机制等。 首先，C++实现BP神经网络需要定义网络结构，...
手写神经网络程序分享：适合初学者的机器学习实践
2. **纯手写神经网络程序**：说明这些神经网络的实现是基于编程语言（如Python、MATLAB、C++等）直接编写的，没有使用现成的机器学习库或框架（如TensorFlow、PyTorch、scikit-learn等）。这种方式对于学习和理解...
C++实现遗传算法与BP神经网络代码详解
BP神经网络算法的C++实现包括以下几个步骤： 1. **初始化（Initialization）**：随机初始化网络中所有神经元的连接权重和偏置。 2. **前向传播（Forward Propagation）**：输入数据经过输入层，通过隐藏层，最终...
拓扑排序C++实现+实例解析（详解 兄弟们冲呀呀呀呀呀呀呀）
qq_48508278的博客
07-29 1077
一：引言 既然是一种排序，那么肯定是按照某种规则进行排序，那么这么想的话，先了解基本知识，再来实战演练 1. AOV网（Activity On Vertex Network)【顶点——表示活动】 是一个——有向无回路的图 顶点——表示活动 用弧——表示活动间的优先关系的有向图称为-顶点表示活动的网 即如果a->b,那么a是b的先决条件 求拓扑序列就是AOV 2. 用邻接矩阵存储时 每一列表示这个顶点的入度（有向图中） 二:上码 /* 1. AOV网（Activity On Vertex Net
bp神经网络模型拓扑结构,bp神经网络模型的建立
Supermen333的博客
09-07 794
表示人脸N_train=5;
神经网络一般架构（BP）
weixin_44546905的博客
03-14 2285
目录专业词汇1.神经网络概述2.简单的神经网络感知机多层网络3.误差逆传播算法输出层&输入层神经元个数损失函数反向梯度分配 专业词汇 神经网络(neural networks) 神经元(neuro） "阈值" (threshold) "激活函数" (activation function) "挤压函数" (squashig ...
【机器学习】BP神经网络基本结构
鑫宝的博客
08-06 3334
BP神经网络是一种监督学习算法，它通过最小化预测输出与实际目标之间的误差来调整网络参数。BP算法的核心思想是将输出误差沿网络反向传播，从而指导各层权重的调整。
神经网络bp算法应用,bp神经网络动量因子
aifamao6的博客
08-20 2491
由于目前研究的各种数学模型或多或少存在使用条件的局限性，或使用方法的复杂性等问题，预测效果均不十分理想，距离实际应用仍有较大差距。NNT是Matlab中较为重要的一个工具箱，在实际应用中，BP网络用的最广泛。神经网络具有综合能力强，对数据的要求不高，适时学习等突出优点，其操作简便，节省时间，网络初学者即使不了解其算法的本质，也可以直接应用功能丰富的函数来实现自己的目的。因此，易于被基层单位预防工作者掌握和应用。以下几个问题是建立理想的因素与疾病之间的神经网络模型的关键：（1）资料选取应尽可能地选取所研究地区
BP神经网络
zhongkeli的专栏
07-08 2190
＃三层BP神经网络三层网络结构图 xx为输入向量，yy为隐藏层的神经元，zz为输出层, dd为目标真实值, 本文默认zz不经过sigmod处理。x-y的权重为ww,y-z的权重为vv。BP算法推导yj=∑ixiwij(1)y_j=\sum_ix_iw_{ij} \tag1 Oyi=f(yj)(2)O_{y_i}=f(y_j) \tag2 其中激励函数f(x)=11+e−xf(x)=\frac{
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值