简单BP神经网络 - 异或问题分类(C++实现+详细助解)

最新推荐文章于 2021-11-10 11:48:37 发布
最新推荐文章于 2021-11-10 11:48:37 发布
阅读量920 收藏 4
点赞数
分类专栏： 计算机模式识别 文章标签： BP网络 详细助解 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41094315/article/details/114438137
版权
本文详细介绍了神经网络的基本概念，包括隐藏层、输出层的权值初始化，以及BP算法的前向传播、后向传播过程。通过实例代码展示了如何使用BP算法训练一个三层神经网络，并讨论了不同类型的激活函数。适合初学者理解神经网络的实践应用。
摘要由CSDN通过智能技术生成

神经网络概念及基础：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/6883438.html）

#include <iostream>
#include<stdlib.h>
#include <math.h>
#include <string>
using namespace std;
//简单 输入-隐藏-输出 三层Bp网络

#define  innode 2       // 输入层节点数
#define  hiddennode 10   // 隐层节点数
#define  outnode 1      // 输出层节点数
#define  sample 4       // 训练样本数
#define  speed 0.1      // 训练速率
#define  Kernel 1       // 传递函数类型

class BP_Net
{
private:
	double W_Hid[hiddennode]; //隐藏层数据存储
	double W_Out[outnode];    //输出层数据存储
	double W_InToHid [hiddennode][innode];  //输入层到隐藏层的网络权值
	double W_HidToOut[outnode][hiddennode]; //隐藏层到输出层的网络权值
	double W_Rand(double low, double high); //权值随机填充
	
public:
	double Err;                  //临时误差
	double E_Sum;                //总误差
	double R_Predict[outnode];   //预测结果
	BP_Net(const char Name[]);   //构造
	~BP_Net();                   //反构造
	void   BP_Init(double low, double high); //网络权值初始化
	void   BP_Predict(double TestData[]);     //模型数据预测
	//数据模型训练
	void   BP_Train(double InData[sample][innode], double Target[sample][outnode]);
	//激活函数选择  传递方向选择(前向、后向)
	double T_Kernel(unsigned char method,unsigned char T_Direction, double Value);
};

BP_Net::BP_Net(const char Name[]):E_Sum(1),Err(0){
    cout<<Name<<" :"<<endl;
}
BP_Net::~BP_Net(){}

void BP_Net::BP_Init(double low, double high)
{
	unsigned int N_W_InToHid  = hiddennode*innode;
	unsigned int N_W_HidToOut = hiddennode*outnode;
	unsigned int m = max(N_W_InToHid,N_W_HidToOut);
	double* P_Hid  = W_Hid;
	double* P_Out  = W_Out;
	double* P_InToHid  = (double*)W_InToHid;
	double* P_HidToOut = (double*)W_HidToOut;

	for (int i = 0; i < m; i++)
    {
    	if(i < hiddennode)   P_Hid[i]      = W_Rand(low, high);
    	if(i < outnode)      P_Out[i]      = W_Rand(low, high);
    	if(i < N_W_InToHid)  P_InToHid[i]  = W_Rand(low, high);
    	if(i < N_W_HidToOut) P_HidToOut[i] = W_Rand(low, high);
    }
}

double BP_Net::T_Kernel(unsigned char method,unsigned char T_Direction, double Value)
{
		if(method == 1){ //sigmod
			if(T_Direction<0.5)//前向
				return 1.0 / (1 + exp(-Value));
            else  //反向
				return Value*(1 - Value);
		}
		else{ //Tanh
			if(T_Direction<0.5)//反向
				return (exp(Value) - exp(-Value)) / (exp(Value) + exp(-Value));
            else //反向
				return pow((exp(Value) - exp(-Value)) / (exp(Value) + exp(-Value)), 2);
		}
}

double BP_Net::W_Rand(double low, double high)
{
    double val;
    val = ((double)rand() / (double)RAND_MAX)*(high - low) + low;
    return val;
}


void BP_Net::BP_Train(double InData[sample][innode], double Target[sample][outnode])
{
	double I_Out[outnode]; //输出点输入
	double O_Out[outnode]; //输出点输出
	double E_Out[outnode]; //输出点误差
	double I_Hid[hiddennode];
	double O_Hid[hiddennode];
	double E_Hid[hiddennode];

	double Once_In[innode];              //输入结点值
	double Once_Target[outnode];         //输出目标值
	unsigned int M = max(innode,outnode);
	unsigned int M1 = max(outnode,hiddennode);
	for (int i = 0; i < sample; i++)     // 监督数据训练
    {
		for (int j = 0; j < M; j++)      //前期初值准备
		{
			if(j < innode)              //提取一次输入结点数据
            	Once_In[j] = InData[i][j];
			if(j < outnode)
				Once_Target[j] = Target[i][j]; //提取一次拟合目标数据
		}
		
		/*前向传播*/
		for (int j = 0; j < hiddennode; j++)  //输入层到隐藏层的传播
        {
			I_Hid[j] = 0; // 结点累加和 初始化
			for (int k = 0; k < innode; k++) //计算每个隐藏结点的权值和
				I_Hid[j] += Once_In[k] * W_InToHid[j][k];
			O_Hid[j] = T_Kernel(Kernel, 0, I_Hid[j] + W_Hid[j]); //用激活函数得结点输出值
        }
        for (int j = 0; j < outnode; j++)  //隐藏层到输出层的传播
        {
			I_Out[j] = 0;
			for (int k = 0; k < hiddennode; k++)
				I_Out[j] += O_Hid[k] * W_HidToOut[j][k];
			O_Out[j] = T_Kernel(Kernel, 0, I_Out[j] + W_Out[j]);
        }

		/*后向传播*/
		for (int j = 0; j < outnode; j++)  //输出层到隐藏层的传播
        {
		 	double E_Temp = Once_Target[j] - O_Out[j]; //每个输出节点的误差
			Err += pow(E_Temp,2);            //模型总输出误差
			// 偏导 (总误差E_Sum)/(某输出结点O_Out)  *  偏导 (某输出结点O_Out)/(激发函数运算Net)
        	E_Out[j] =  (E_Temp) * T_Kernel(Kernel, 1, O_Out[j]);
	 		for (int k = 0; k < hiddennode; k++) //输出层到隐藏层每条网络权值更新
				// E_Out[j] * 偏导 (激发函数运算Net)/(某输条网络权值W)
				W_HidToOut[j][k] += E_Out[j] * O_Hid[k] * speed;
        }
		E_Sum = Err*0.5;
        for (int j = 0; j < hiddennode; j++)
        {
        	E_Hid[j] = 0;
        	for (int k = 0; k < outnode; k++) //输出层到隐藏层的传播
				// 偏导 (某输出结点E_Out)/(激发函数运算Net) * 偏导 (激发函数运算Net)/(某输条网络新输入值)
				E_Hid[j] += E_Out[k] * W_HidToOut[k][j];

			// 偏导 (某输出结点E_Out)/(某隐层结点O_Hid) * 偏导 (某隐层结点O_Hid)/(激发函数运算Net)
			E_Hid[j] = E_Hid[j] * T_Kernel(Kernel, 1, O_Hid[j]);
			for (int k = 0; k < innode; k++)//隐藏层到输入层每条网络权值更新
				 // E_Hid[j] * 偏导 (激发函数运算Net)/(某输条网络权值W)
				 W_InToHid[j][k] += E_Hid[j] * Once_In[k] * speed;
        }
        
        //更新各个节点本身的值
		for (int j = 0; j < M1; j++)
		{
			if(j < outnode)     W_Out[j] = E_Out[j] * speed;
			if(j < hiddennode)  W_Hid[j] = E_Hid[j] * speed;
        }
    }
}

void BP_Net::BP_Predict(double TestData[])
{
    double I_Out[outnode]; //输出点输入
	double O_Out[outnode]; //输出点输出
 	double I_Hid[hiddennode];
 	double O_Hid[hiddennode];
	/*前向传播*/
	for (int j = 0; j < hiddennode; j++)  //输入层到隐藏层的传播
    {
		I_Hid[j] = 0; // 结点累加和 初始化
		for (int k = 0; k < innode; k++) //计算每个隐藏结点的权值和
			I_Hid[j] += TestData[k] * W_InToHid[j][k];
		O_Hid[j] = T_Kernel(Kernel, 0, I_Hid[j] + W_Hid[j]); //用激活函数得结点输出值
    }
    for (int j = 0; j < outnode; j++)  //隐藏层到输出层的传播
    {
		I_Out[j] = 0;
		for (int k = 0; k < hiddennode; k++)
			I_Out[j] += O_Hid[k] * W_HidToOut[j][k];
		O_Out[j] = T_Kernel(Kernel, 0, I_Out[j] + W_Out[j]);
		R_Predict[j] = O_Out[j];
		cout<<R_Predict[j]<<endl;
    }
}

/***************<使用示例>*****************/
//训练样本
double X[sample][innode] = {
    {1,1},
    {1,0},
    {0,1},
    {0,0}
};
//训练样本对应标签
double Y[sample][outnode] = {
    {1},
    {0},
    {0},
    {1}
};

int main(int argc, char*argv[])
{
	BP_Net bp("BP1");
	bp.BP_Init(-1.0,1.0);
	int t = 0;
    while (bp.E_Sum > 0.001 && t <30000)
    {
  		bp.Err = 0.0;
        bp.BP_Train(X, Y);
        t++;
    }
    double m[2] = { 0,1 };
    bp.BP_Predict(m);
	return 0;
}

 

EMB看灯夜
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【神经网络】BP算法解决XOR异或问题MATLAB版
weixin_34060299的博客
06-15 1526
 第一种 %% %用神经网络解决异或问题 clear clc close ms=4;%设置4个样本 a=[0 0;0 1;1 0;1 1];%设置输入向量 y=[0,1,1,0];%设置输出向量 n=2;%输入量的个数 m=3;%隐层量的个数 k=1;%输出层的个数 w=rand(n,m);%为输入层到隐层的权值赋初值 v=rand(m,k);%为隐层到输出层的权...
基于C++编程的BP神经网络实现异或问题
01-14
利用C++语言设计BP神经网络来解决非线性的异或问题
C++实现BP算法_单隐层_异或(可模拟各种函数并验证)
hanshuning的专栏
12-13 1728
#include #include using namespace std; #define innode 2 //输入结点数 #define hidenode 3//隐含结点数 #define outnode 1 //输出结点数 #define trainsample 4//BP训练样本数 class BpNet { public:
BP神经网络解决异或问题
01-17
一个比较典型的神经元网络，方便学习.一定可以使用
BP神经网络实现异或功能(C++).docx
03-11
BP神经网络实现异或功能（C++） BP神经网络是一种常用的神经网络模型，它可以用来实现异或（XOR）功能。异或门是一个基本的逻辑门电路，它可以将两个输入信号进行逻辑异或操作。BP神经网络可以通过调整权值和阈值来...
BP神经网络实现异或功能(C++).pdf
03-11
在异或问题中，由于异或逻辑是非线性的，传统的逻辑门无法直接解决，而BP神经网络可以利用其多层结构和权重调整能力来模拟异或功能。 首先，我们看到代码中定义了几个关键的参数，如`N`表示学习样本的数量，`T_N`...
BP神经网络解决异或问题_BP算法_
10-03
在Visual C++环境下实现BP神经网络，首先需要理解C++的基本语法和面向对象编程思想。然后，你需要定义神经网络的结构，包括输入层、隐藏层和输出层，以及它们之间的连接权重。每个神经元都有一个激活函数，如Sigmoid...
BP神经网络实现异或功能C++.pdf
03-11
在这个C++代码中，BP神经网络被用来实现异或（XOR）功能，这是一个经典的神经网络示例，因为异或逻辑门的输出无法通过简单的线性模型来预测。 异或门的输入是两个二进制位，如果输入相同则输出为0，如果输入不同则...
C++实现的简单BP神经网络
未命名专栏
06-14 2603
实现了一个简单的BP神经网络算法 使用EasyX图形化显示训练过程和训练结果 使用了25个数据集，一共训练了1万次。 该神经网络有两个输入，一个输出端 下图是训练效果，data是训练的输入数据，temp代表所在层的输出，target是训练目标，右边的大图是BP神经网络的测试结果。 以下是详细的代码实现，主要还是矩阵的加减，数乘，转置，点乘运算。#include <stdio.h> #i
C++实现的BP神经网络算法实现奇偶检验运算
11-09
使用C++编写的多层前向NN的BP算法，各层节点数、隐藏层数均为任意整数。训练数据为3个数字的奇偶检验运算程序。程序使用VS2015编写，有cpp源代码及头文件，代码中配有注释。
BP神经网络异或分类VC++6.0实现
05-20
VC++6.0环境下实现BP神经网络异或分类 自己写的程序，可以运行，分享~~
采用bp解决xor问题
06-21
本文中介绍了bp的基本原理和实现过程，并给出实验结果的分析及matlab代码，是一份完整的实验报告，给出解决xor问题的实例
BP神经网络解决异或问题BP神经网络解决异或问题
12-14
BP神经网络解决异或问题BP神经网络解决异或问题
BP神经网络-XOR运算
蓦然回首
12-03 1806
import numpy as np x = np.array([[1,0,0], [1,0,1], [1,1,0], [1,1,1]]) y = np.array([[0,1,1,0]]) v = np.random.random((3,4))*2-1 w = np.random.random((4,1))*2-1 pr
BP神经网络算法实现 C++
lin的博客
09-17 2710
BP神经网络基本原理： 误差逆传播(back propagation, BP)算法是一种计算单个权值变化引起网络性能变化的较为简单的方法。由于BP算法过程包含从输出节点开始，反向地向第一隐含层(即最接近输入层的隐含层)传播由总误差引起的权值修正，所以称为“反向传播”。 BP神经网络是有教师指导训练方式的多层前馈网络，其基本思想是：从网络输入节点输入的样本信号向前传播，经隐含层节点和输出层节点处...
代码笔记 | BP神经网络的C语言代码
代码屠夫CodePudge
09-01 1564
#include #include #include #include typedef enum {CUSTOM,SIGMOD} ActionType; typedef double(*Function)(double); typedef struct { int cbSize; //神经网络所占用的内存空间 int szLayer;
BP神经网络——异或问题（实践）
shanshuyue的博客
11-10 899
import numpy as np #输入数据 X = np.array([[1,0,0], [1,0,1], [1,1,0], [1,1,1]]) #标签 Y = np.array([[0,1,1,0]]) #权值初始化，取值范围-1到1 V = np.random.random((3,4))*2-1 W = np.random.random((4,1))*2-1 print(V) print(W) #学习率设置..
python bp神经网络 异或_BP神经网络求解异或问题(Python实现)
最新发布
05-21
好的，下面是一个简单的 Python 实现 BP 神经网络求解异或问题的例子： ```python import numpy as np # 定义 sigmoid 函数和它的导数 def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x):...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值