神经网络与深度学习(二)cpp-c++BP神经网络

最新推荐文章于 2023-05-08 13:20:15 发布
最新推荐文章于 2023-05-08 13:20:15 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： 学习笔记 文章标签： 神经网络与深度学习 感知机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_W1997/article/details/54849434
版权

最新在这 http://blog.csdn.net/mr_w1997/article/details/54973376


读到作者用JAVA实现的神经网络解决异或等问题

以下为c++实现版本

接口略有不同

具体关键的更新的证明详见机器学习或大牛博客

有一个关键的地方是 权值的初始化

原本是都初始化0 但是楼主也意识到 这样无论怎样更新 隐层不同神经元对应输入层同一神经元的权值都相同 相当于 仍然用一个线性函数划分 不可线性划分的区域

思考良久就初始化为随机数了 然而不行 后来看了别人的初始化 发现了这个

//关键的初始化权值
		for (int i = 0; i < lastlayerneunum; ++i)
			this->Last_weight[i] = (2.0*(double)rand() / RAND_MAX) - 1;
改了一下 瞬间问题都没了 也很神奇  至于原因  楼主开学要回去问学长  有知道的大神也请赐教

一下为代码  如有bug 欢迎指正

楼主有些懒 成员函数的实现都在类内部了 有点难看 还请别介意


TransferFunc.h  激励函数类及类型的定义

//TransferFunc.h
//created by WK

#ifndef TRANSFERFUNC_H
#define TRANSFERFUNC_H

#include <cmath>

enum Functypes
{
	FUNCTYPE_TANH,
	FUNCTYPE_STEP,
	FUNCTYPE_LINEAR,
	FUNCTYPE_SIGMOID
};

class Function
{
private:
	double Step(double input)
	{
		if (input < 0)
			return 0;
		else
			return 1;
	}
	double Linear(double input)
	{
		return input;
	}
	double Sigmoid(double input)
	{
		return 1.0 / (1.0 + exp(-1.0*input));
	}
public:

	double GetResult(int funcType, double input)
	{
		switch (funcType)
		{
		case FUNCTYPE_TANH:
			return tanh(input);
		case FUNCTYPE_STEP:
			return Step(input);
		case FUNCTYPE_LINEAR:
			return Linear(input);
		case FUNCTYPE_SIGMOID:
			return Sigmoid(input);
		default:
			return input;
		}
	}
};

#endif // !TRANSFERFUNC_H

DataSet.h 数据集类型 

//DateSet.h
//created by WK

#ifndef DATASET_H
#define DATASET_H

#include <vector>

using namespace std;

//数据集
class DataSet
{
private:
	int					InputNum;
	int					OutputNum;
	vector<double*>		DataMap;

public:
	DataSet(int inputnum, int outputnum)
	{
		this->InputNum = inputnum;
		this->OutputNum = outputnum;
	}
	void AddRow(double *inputArray, double *outputArray)
	{
		double *data = new double[this->InputNum + this->OutputNum];
		for (int i = 0; i<this->InputNum; ++i)
		{
			data[i] = inputArray[i];
		}
		for (int i = 0; i<this->OutputNum; ++i)
		{
			data[InputNum + i] = outputArray[i];
		}
		this->DataMap.push_back(data);
	}
	int GetInputNum()
	{
		return this->InputNum;
	}
	int GetOutputNum()
	{
		return this->OutputNum;
	}
	int GetRows()
	{
		return DataMap.size();
	}
	vector<double*> GetDataMap()
	{
		return DataMap;
	}
 
};


#endif // !DATASET_H


MultiLayerPerceptron.cpp神经元定义以及单隐层神经网络定义 以及 异或问题的解决

#include <vector>
#include <iostream>
#include "TransferFunc.h"
#include "DataSet.h"
#include <time.h>
#include <cstdlib>

using namespace std;

#define WINITVALUE 0.001
#define TINITVALUE 0

//神经元
class Neuron
{
private:
	double				Input;
	double				Output;
	double				Threshold;
	double				*Last_weight;			//神经元维护后向的权重
	int					LastLayerNeuNum;
	int					TransferFunctionType;
	Function			Transferfunction;

public:
	Neuron(double threshold, int lastlayerneunum, int funcType)
	{
		this->Input					=	0;
		this->Output				=	0;
		this->Threshold				=	threshold;
		this->LastLayerNeuNum		=	lastlayerneunum;
		this->TransferFunctionType	=	funcType;
		this->Last_weight			=	new double[lastlayerneunum];
		//关键的初始化权值
		for (int i = 0; i < lastlayerneunum; ++i)
			this->Last_weight[i] = (2.0*(double)rand() / RAND_MAX) - 1;
		
	}
	void SetInput(double input)
	{
		this->Input = input;
	}
	double GetOutput()
	{
		this->Output = Transferfunction.GetResult(this->TransferFunctionType, this->Input - this->Threshold);

		return this->Output;
	}
	double* GetThreshold()
	{
		return &this->Threshold;
	}
	double *GetWeight()
	{
		return this->Last_weight;
	}
	void SetFuncType(int functype)
	{
		this->TransferFunctionType = functype;
	}
};

//多层感知机
class MultiLayerPerceptron
{
private:
	int			OutTransfetFunctionType;
	int			HideTransfetFunctionType;
	int			InTransfetFunctionType;
	int			InLayerNeuNum;
	int			HideLayerNeuNum;
	int			OutLayerNeuNum;
	double		Speed;
	Neuron		**InputNeurons;
	Neuron		**OutputNeurons;
	Neuron		**HidenNeurons;
public:

	MultiLayerPerceptron(int intransferfunctiontype, int inLayerNeuNum, int hidetransferfunctiontype, int hideLayerNeuNum, int outtransferfunctiontype, int outLayerNeuNum, double speed)
	{
		this->InTransfetFunctionType	=	intransferfunctiontype;
		this->HideTransfetFunctionType	=	hidetransferfunctiontype;
		this->OutTransfetFunctionType	=	outtransferfunctiontype;
		this->InLayerNeuNum				=	inLayerNeuNum;
		this->HideLayerNeuNum			=	hideLayerNeuNum;
		this->OutLayerNeuNum			=	outLayerNeuNum;
		this->Speed						=	speed;

		this->InputNeurons	= (Neuron**)new void*[inLayerNeuNum];
		for (int i = 0; i < inLayerNeuNum; ++i)
			this->InputNeurons[i] = new Neuron(TINITVALUE, 0, intransferfunctiontype);
		this->HidenNeurons	= (Neuron**)new void*[hideLayerNeuNum];
		for (int i = 0; i < hideLayerNeuNum; ++i)
			this->HidenNeurons[i] = new Neuron(TINITVALUE, inLayerNeuNum, hidetransferfunctiontype);
		this->OutputNeurons = (Neuron**)new void*[outLayerNeuNum];
		for (int i = 0; i < outLayerNeuNum; ++i)
			this->OutputNeurons[i] = new Neuron(TINITVALUE, hideLayerNeuNum, outtransferfunctiontype);
	}
	//获取正向的输出
	void GetOutput(double *output)
	{
		double sum;

		for (int i = 0; i < this->HideLayerNeuNum; ++i)
		{
			sum = 0;
			for (int j = 0; j < this->InLayerNeuNum; ++j)
				sum += this->HidenNeurons[i]->GetWeight()[j] * this->InputNeurons[j]->GetOutput();
			this->HidenNeurons[i]->SetInput(sum);
		}
		for (int i = 0; i < this->OutLayerNeuNum; ++i)
		{
			sum = 0;
			for (int j = 0; j < this->HideLayerNeuNum; ++j)
				sum += this->OutputNeurons[i]->GetWeight()[j] * this->HidenNeurons[j]->GetOutput();
			this->OutputNeurons[i]->SetInput(sum);
			output[i] = this->OutputNeurons[i]->GetOutput();
		}
	}

	//学习所有数据一次更新权值以及阈值
	void Learn(DataSet *trainingSet)
	{
		double *expect;
		double *data;
		double *output = new double[this->OutLayerNeuNum];
		for (int i = 0; i < trainingSet->GetRows(); ++i)
		{
			data	= trainingSet->GetDataMap()[i];
			expect	= data + trainingSet->GetInputNum();
			for (int j = 0; j < trainingSet->GetInputNum(); ++j)
				this->InputNeurons[j]->SetInput(data[j]);
			this->GetOutput(output);
			//更改隐藏层到输出层权重以及阈值
			//更新公式详见机器学习
			for (int j = 0; j < this->OutLayerNeuNum; ++j)
			{		
				double delta = this->Speed * output[j] * (1 - output[j]) * (expect[j] - output[j]);

				for (int k = 0; k < this->HideLayerNeuNum; ++k)
					this->OutputNeurons[j]->GetWeight()[k] += (delta * this->HidenNeurons[k]->GetOutput());
				*this->OutputNeurons[j]->GetThreshold() -= delta;
			}
			//更改输入层到隐藏层的权重以及阈值
			//更新公式详见机器学习
			for (int j = 0; j < this->HideLayerNeuNum; ++j)
			{
				double t = 0;
				for (int k = 0; k < this->OutLayerNeuNum; ++k)
					t += (this->OutputNeurons[k]->GetWeight()[j] * output[k] * (1 - output[k])*(expect[k] - output[k]));
				double delta = this->HidenNeurons[j]->GetOutput() * (1 - this->HidenNeurons[j]->GetOutput()) * t;
				for (int k = 0; k < this->InLayerNeuNum; ++k)
					this->HidenNeurons[j]->GetWeight()[k] += (this->Speed * this->InputNeurons[k]->GetOutput() * delta);
				*this->HidenNeurons[j]->GetThreshold() -= (this->Speed * delta);
			}
		}
	}

	void Test(DataSet *trainingSet)
	{
		double *output = new double[this->OutLayerNeuNum];
		double *expect = new double[this->OutLayerNeuNum];
		
		for (int i = 0; i < trainingSet->GetRows(); ++i)
		{
			for (int j = 0; j < trainingSet->GetInputNum(); ++j)
				this->InputNeurons[j]->SetInput(trainingSet->GetDataMap()[i][j]);
			this->GetOutput(output);
			for (int j = 0; j < trainingSet->GetOutputNum(); ++j)
			{
				cout << "output: ";
				cout << output[j] << "\t";
				cout << "expect: ";
				cout << trainingSet->GetDataMap()[i][trainingSet->GetInputNum()+j]<<"\t";
			}
			cout << endl;
		} 
		cout << endl;
		cout << "in to hide W:" << endl;
		for (int i = 0; i < this->HideLayerNeuNum; ++i)
		{
			for (int j = 0; j < this->InLayerNeuNum; ++j)
			{
				cout << this->HidenNeurons[i]->GetWeight()[j] << "  ";
			}
			cout << endl;
		}
		cout << endl;
		cout << "hide to out W:" << endl;
		for (int i = 0; i < this->OutLayerNeuNum; ++i)
		{
			for (int j = 0; j < this->HideLayerNeuNum; ++j)
			{
				cout << this->OutputNeurons[i]->GetWeight()[j] << "  ";
			}
			cout << endl;
		}
	}
};

int main()
{
	DataSet *trainingSet = new DataSet(2, 1);
	trainingSet->AddRow(new double[2]{ 1,1 }, new double[1]{ 0 });
	trainingSet->AddRow(new double[2]{ 1,0 }, new double[1]{ 1 });
	trainingSet->AddRow(new double[2]{ 0,1 }, new double[1]{ 1 });
	trainingSet->AddRow(new double[2]{ 0,0 }, new double[1]{ 0 });

	//层激励函数类型 神经元个数... 学习速率
	MultiLayerPerceptron *m = new MultiLayerPerceptron(FUNCTYPE_LINEAR, 2, FUNCTYPE_SIGMOID, 5, FUNCTYPE_SIGMOID, 1, 0.9);

	//学习1000次
	for (int i = 0; i < 10000; ++i)
		m->Learn(trainingSet);

	m->Test(trainingSet);

	

	system("pause");

	return 0;
}



Mr_W1997
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BP神经网络异或分类VC++6.0实现
05-20
VC++6.0环境下实现BP神经网络异或分类 自己写的程序，可以运行，分享~~
C++实现BP算法_单隐层_异或(可模拟各种函数并验证)
hanshuning的专栏
12-13 1714
#include #include using namespace std; #define innode 2 //输入结点数 #define hidenode 3//隐含结点数 #define outnode 1 //输出结点数 #define trainsample 4//BP训练样本数 class BpNet { public:
简单BP神经网络 - 异或问题分类(C++实现+详细助解)
du98看灯夜的博客
03-06 865
神经网络概念及基础：https://www.cnblogs.com/maybe2030/p/5597716.html 本例具体公式使用按步推导参照：https://www.cnblogs.com/charlotte77/p/5629865.html 激活函数（激励函数）理解与总结：https://blog.csdn.net/tyhj_sf/article/details/79932893 废话不多说上代码！（代码来源参考至：https://www.cnblogs.com/semen/p/6883.
用BP神经网络解决异或问题
weixin_43272605的博客
12-01 6612
初步的神经网络入门分为三篇 1：神经网络简析 2：Back Propagation算法 3：用BP神经网络解决异或问题 这一篇主要是讲解一下关于用BP神经网络解决异或问题 对于我们的输入 [0,0]，[0,1]，[1,0]，[1,1] 对于我们的输出 0或1 这里我们需要借用上一篇文章的一张图片 构建双层神经网络 #导入numpy import numpy as ...
C/C++数据结构练习题[2023-05-08]
code helper
05-08 8834
目的：字符串是一种基础且广泛使用的数据结构，与字符串相关的题目既可 以考察基本程序设计能力和技巧，也可以考查算法设计能力。 题目：求字符串之间距离 要求：设有字符串 X，称在 X 的头尾及中间插入任意多个空格后构成的新 字符串为 X 的扩展串，如字符串 X 为“abcbcd”，则字符串“abcb□cd”，“□a□bcbcd□” 和“abcb□cd□”都是 X 的扩展串，这里“□”代表空格字符。如果 A1 是字符串 A 的 扩展串，B1 是字符串 B 的扩展串，A1 与 B1 具有相同的长度，那么定义字符串
神经网络与深度学习(三)CPP神经网络库
Mr_W1997的博客
05-16 997
经过一段时间的沉淀，楼主终于写出了一份自己比较满意的代码(其实还有很多瑕疵挑战着楼主的强迫症) 这份实现并非只是一个网络，而更像是神经网络库 大家可以使用它对每一层的封装建立自己的神经网络 代码链接: https://github.com/Wchenguang/ShadowNet 简单的介绍： 1.总体上的架构是，将全连接层，输出层进行封装，同时引入了connector的数据结
[深度学习系列之一] C++ 实现神经网络
热门推荐
wutongthucs的专栏
09-13 2万+
百行C实现神经网络 介绍 训练程序的基本框架 Logistic Regression Model Vanilla Neural Network forward back propagation 基本程序库 实战数字识别 数据准备 mnist数字识别训练程序 logistic regression配置文件 运行命令 LR训练的结果 2个隐藏层的NN配置文件 运行命令 NN训练60多轮结果百行C++实现
神经网络与深度学习cpp(一)
Mr_W1997的博客
01-30 713
第二章，只为理解感知机 代码较随意 隐藏一些问题，并未深究 核心计算变量名按书 较简 #include #include #include #include using namespace std; //数据集 class DataSet { private: int InputNum; int OutputNum; vector DataMap; public: Da
cpp简单实现一下BP神经网络
qq_40708167的博客
01-10 369
激活函数 σ(x)=11+e−x \sigma (x)=\frac{1}{1+e^{-x}} σ(x)=1+e−x1​ 正向传播 Xi=σ(Mi∗Xi−1+Bi) {\large X}_{i}=\sigma({\large M}_{i}* {\large X}_{i-1}+{\large B}_{i}) Xi​=σ(Mi​∗Xi−1​+Bi​) 反向传播 误差函数ε=∑(Xi−Di)2 \text{误差函数}\qquad\varepsilon=\sum_{}{{\left(X_{i}-D_{i}\rig
神经网络30个经典案例
09-12
神经网络30个经典案例
c++版神经网络实现
06-19
c++版神经网络的实现，内部实现了矩阵运算，前向传播，反向传播的基本逻辑，使用的是交叉熵损失函数，二分类问题，数据集是64*64*3的猫的图片，已被展成12288向量存于txt文件中，由于数据量大训练时间可能较长
深度学习C++源码(DBN)
05-21
网上很多深度学习C++源码下载后都无法使用，总是有这样活那样的错误，但本源码可定好用，只要装了VS 2013就行，没用第三方库。 这是一个深度学习--深度信念网络(Deep Belief Network)的C++源码，例子中带有数据，直接编译就可以使用，也可以断点调试，非常方便。
Visual-CPP-Version.zip_人工智能/神经网络/深度学习_Visual_C++_
08-11
A*算法的具体实现以及EXE测试程序，适合学习或者研究。
A-Method-of-Using-CPP.rar_人工智能/神经网络/深度学习_Visual_C++_
08-11
介绍了混合编程开发专家系统的一般方法及其优越性
genetic_1.zip_人工智能/神经网络/深度学习_Visual_C++_
08-10
遗传算法解方程的一个例子，用Viual studio或者记事本打开，只是cpp文件，需要新建工程后导入。
CPP-LM-BP.rar_BP LM_LM BP_LM神经网络_bp神经网络 lm_优化算法BP
07-15
利用LM训练算法来优化BP神经网络算法。
bpC++_bp神经网络测试文件C++_源码
10-02
为一个样本文件，里面有cpp、h文件整体，供初学者使用
bp神经网络c++实例
最新发布
07-27
以下是一个使用C++实现的简单的BP神经网络实例： ```cpp #include #include #include using namespace std; // 定义激活函数 double sigmoid(double x) { return 1 / (1 + exp(-x)); } // 定义BP神经网络类 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值