C++实现神经BP神经网络

本文实例为大家分享了C++实现神经BP神经网络的具体代码,供大家参考,具体内容如下

BP.h

#pragma once
#include<vector>
#include<stdlib.h>
#include<time.h>
#include<cmath>
#include<iostream>
using std::vector;
using std::exp;
using std::cout;
using std::endl;
class BP
{
private:
 int studyNum;//允许学习次数
 double h;//学习率
 double allowError;//允许误差
 vector<int> layerNum;//每层的节点数,不包括常量节点1
 vector<vector<vector<double>>> w;//权重
 vector<vector<vector<double>>> dw;//权重增量
 vector<vector<double>> b;//偏置
 vector<vector<double>> db;//偏置增量
 vector<vector<vector<double>>> a;//节点值
 vector<vector<double>> x;//输入
 vector<vector<double>> y;//期望输出

 void iniwb();//初始化w与b
 void inidwdb();//初始化dw与db
 double sigmoid(double z);//激活函数
 void forward();//前向传播
 void backward();//后向传播
 double Error();//计算误差
public:
 BP(vector<int>const& layer_num, vector<vector<double>>const & input_a0,
 vector<vector<double>> const & output_y, double hh = 0.5, double allerror = 0.001, int studynum = 1000);
 BP();
 void setLayerNumInput(vector<int>const& layer_num, vector<vector<double>> const & input);
 void setOutputy(vector<vector<double>> const & output_y);
 void setHErrorStudyNum(double hh, double allerror,int studynum);
 void run();//运行BP神经网络
 vector<double> predict(vector<double>& input);//使用已经学习好的神经网络进行预测
 ~BP();
};

BP.cpp

#include "BP.h"
BP::BP(vector<int>const& layer_num, vector<vector<double>>const & input,
 vector<vector<double>> const & output_y, double hh, double allerror,int studynum)
{
 layerNum = layer_num;
 x = input;//输入多少个节点的数据,每个节点有多少份数据
 y = output_y;
 h = hh;
 allowError = allerror;
 a.resize(layerNum.size());//有这么多层网络节点
 for (int i = 0; i < layerNum.size(); i++)
 {
 a[i].resize(layerNum[i]);//每层网络节点有这么多个节点
 for (int j = 0; j < layerNum[i]; j++)
  a[i][j].resize(input[0].size());
 }
 a[0] = input;
 studyNum = studynum;
}

BP::BP()
{
 layerNum = {};
 a = {};
 y = {};
 h = 0;
 allowError = 0;
}

BP::~BP()
{
}

void BP::setLayerNumInput(vector<int>const& layer_num, vector<vector<double>> const & input)
{
 layerNum = layer_num;
 x = input;
 a.resize(layerNum.size());//有这么多层网络节点
 for (int i = 0; i < layerNum.size(); i++)
 {
 a[i].resize(layerNum[i]);//每层网络节点有这么多个节点
 for (int j = 0; j < layerNum[i]; j++)
  a[i][j].resize(input[0].size());
 }
 a[0] = input;
}

void BP::setOutputy(vector<vector<double>> const & output_y)
{
 y = output_y;
}

void BP::setHErrorStudyNum(double hh, double allerror,int studynum)
{
 h = hh;
 allowError = allerror;
 studyNum = studynum;
}

//初始化权重矩阵
void BP::iniwb()
{
 w.resize(layerNum.size() - 1);
 b.resize(layerNum.size() - 1);
 srand((unsigned)time(NULL));
 //节点层数层数
 for (int l = 0; l < layerNum.size() - 1; l++)
 {
 w[l].resize(layerNum[l + 1]);
 b[l].resize(layerNum[l + 1]);
 //对应后层的节点
 for (int j = 0; j < layerNum[l + 1]; j++)
 {
  w[l][j].resize(layerNum[l]);
  b[l][j] = -1 + 2 * (rand() / RAND_MAX);
  //对应前层的节点
  for (int k = 0; k < layerNum[l]; k++)
  w[l][j][k] = -1 + 2 * (rand() / RAND_MAX);
 }
 }
}

void BP::inidwdb()
{
 dw.resize(layerNum.size() - 1);
 db.resize(layerNum.size() - 1);
 //节点层数层数
 for (int l = 0; l < layerNum.size() - 1; l++)
 {
 dw[l].resize(layerNum[l + 1]);
 db[l].resize(layerNum[l + 1]);
 //对应后层的节点
 for (int j = 0; j < layerNum[l + 1]; j++)
 {
  dw[l][j].resize(layerNum[l]);
  db[l][j] = 0;
  //对应前层的节点
  for (int k = 0; k < layerNum[l]; k++)
  w[l][j][k] = 0;
 }
 }
}

//激活函数
double BP::sigmoid(double z)
{
 return 1.0 / (1 + exp(-z));
}

void BP::forward()
{
 for (int l = 1; l < layerNum.size(); l++)
 {
 for (int i = 0; i < layerNum[l]; i++)
 {
  for (int j = 0; j < x[0].size(); j++)
  {

  a[l][i][j] = 0;//第l层第i个节点第j个数据样本
  //计算变量节点乘权值的和
  for (int k = 0; k < layerNum[l - 1]; k++)
   a[l][i][j] += a[l - 1][k][j] * w[l - 1][i][k];
  //加上节点偏置
  a[l][i][j] += b[l - 1][i];
  a[l][i][j] = sigmoid(a[l][i][j]);
  }
 }
 }
}

void BP::backward()
{
 int xNum = x[0].size();//样本个数
 //daP第l层da,daB第l+1层da
 vector<double> daP, daB;

 for (int j = 0; j < xNum; j++)
 {
 //处理最后一层的dw
 daP.clear();
 daP.resize(layerNum[layerNum.size() - 1]);
 for (int i = 0, l = layerNum.size() - 1; i < layerNum[l]; i++)
 {
  daP[i] = a[l][i][j] - y[i][j];
  for (int k = 0; k < layerNum[l - 1]; k++)
  dw[l - 1][i][k] += daP[i] * a[l][i][j] * (1 - a[l][i][j])*a[l - 1][k][j];
  db[l - 1][i] += daP[i] * a[l][i][j] * (1 - a[l][i][j]);
 }

 //处理剩下层的权重w的增量Dw
 for (int l = layerNum.size() - 2; l > 0; l--)
 {
  daB = daP;
  daP.clear();
  daP.resize(layerNum[l]);
  for (int k = 0; k < layerNum[l]; k++)
  {
  daP[k] = 0;
  for (int i = 0; i < layerNum[l + 1]; i++)
   daP[k] += daB[i] * a[l + 1][i][j] * (1 - a[l + 1][i][j])*w[l][i][k];
  //dw
  for (int i = 0; i < layerNum[l - 1]; i++)
   dw[l - 1][k][i] += daP[k] * a[l][k][j] * (1 - a[l][k][j])*a[l - 1][i][j];
  //db
  db[l-1][k] += daP[k] * a[l][k][j] * (1 - a[l][k][j]);
  }
 }

 }

 //计算dw与db平均值
 for (int l = 0; l < layerNum.size() - 1; l++)
 {
 //对应后层的节点
 for (int j = 0; j < layerNum[l + 1]; j++)
 {
  db[l][j] = db[l][j] / xNum;
  //对应前层的节点
  for (int k = 0; k < layerNum[l]; k++)
  w[l][j][k] = w[l][j][k] / xNum;
 }
 }

 //更新参数w与b
 for (int l = 0; l < layerNum.size() - 1; l++)
 {
 for (int j = 0; j < layerNum[l + 1]; j++)
 {
  b[l][j] = b[l][j] - h * db[l][j];
  //对应前层的节点
  for (int k = 0; k < layerNum[l]; k++)
  w[l][j][k] = w[l][j][k] - h * dw[l][j][k];
 }
 }
}

double BP::Error()
{
 int l = layerNum.size() - 1;
 double temp = 0, error = 0;
 for (int i = 0; i < layerNum[l]; i++)
 for (int j = 0; j < x[0].size(); j++)
 {
  temp = a[l][i][j] - y[i][j];
  error += temp * temp;
 }
 error = error / x[0].size();//求对每一组样本的误差平均
 error = error / 2;
 cout << error << endl;
 return error;
}

//运行神经网络
void BP::run()
{
 iniwb();
 inidwdb();
 int i = 0;
 for (; i < studyNum; i++)
 {
 forward();
 if (Error() <= allowError)
 {
  cout << "Study Success!" << endl;
  break;
 }
 backward();
 }
 if (i == 10000)
 cout << "Study Failed!" << endl;
}

vector<double> BP::predict(vector<double>& input)
{
 vector<vector<double>> a1;
 a1.resize(layerNum.size());
 for (int l = 0; l < layerNum.size(); l++)
 a1[l].resize(layerNum[l]);
 a1[0] = input;
 for (int l = 1; l < layerNum.size(); l++)
 for (int i = 0; i < layerNum[l]; i++)
 {
  a1[l][i] = 0;//第l层第i个节点第j个数据样本
  //计算变量节点乘权值的和
  for (int k = 0; k < layerNum[l - 1]; k++)
  a1[l][i] += a1[l - 1][k] * w[l - 1][i][k];
  //加上节点偏置
  a1[l][i] += b[l - 1][i];
  a1[l][i] = sigmoid(a1[l][i]);
 }
 return a1[layerNum.size() - 1];
}

验证程序:

#include"BP.h"

int main()
{
 vector<int> layer_num = { 1, 10, 1 };
 vector<vector<double>> input_a0 = { { 1,2,3,4,5,6,7,8,9,10 } };
 vector<vector<double>> output_y = { {0,0,0,0,1,1,1,1,1,1} };

 BP bp(layer_num, input_a0,output_y,0.6,0.001, 2000);
 bp.run();
 for (int j = 0; j < 30; j++)
 {
 vector<double> input = { 0.5*j };
 vector<double> output = bp.predict(input);
 for (auto i : output)
  cout << "j:" << 0.5*j <<" pridict:" << i << " ";
 cout << endl;
 }
 system("pause");
 return 0;
}

输出:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C++实现简单BP神经网络

    本文实例为大家分享了C++实现简单BP神经网络的具体代码,供大家参考,具体内容如下 实现了一个简单的BP神经网络 使用EasyX图形化显示训练过程和训练结果 使用了25个样本,一共训练了1万次. 该神经网络有两个输入,一个输出端 下图是训练效果,data是训练的输入数据,temp代表所在层的输出,target是训练目标,右边的大图是BP神经网络的测试结果. 以下是详细的代码实现,主要还是基本的矩阵运算. #include <stdio.h> #include <stdlib.h>

  • C++实现神经BP神经网络

    本文实例为大家分享了C++实现神经BP神经网络的具体代码,供大家参考,具体内容如下 BP.h #pragma once #include<vector> #include<stdlib.h> #include<time.h> #include<cmath> #include<iostream> using std::vector; using std::exp; using std::cout; using std::endl; class BP

  • Python实现的三层BP神经网络算法示例

    本文实例讲述了Python实现的三层BP神经网络算法.分享给大家供大家参考,具体如下: 这是一个非常漂亮的三层反向传播神经网络的python实现,下一步我准备试着将其修改为多层BP神经网络. 下面是运行演示函数的截图,你会发现预测的结果很惊人! 提示:运行演示函数的时候,可以尝试改变隐藏层的节点数,看节点数增加了,预测的精度会否提升 import math import random import string random.seed(0) # 生成区间[a, b)内的随机数 def rand(

  • python实现BP神经网络回归预测模型

    神经网络模型一般用来做分类,回归预测模型不常见,本文基于一个用来分类的BP神经网络,对它进行修改,实现了一个回归模型,用来做室内定位.模型主要变化是去掉了第三层的非线性转换,或者说把非线性激活函数Sigmoid换成f(x)=x函数.这样做的主要原因是Sigmoid函数的输出范围太小,在0-1之间,而回归模型的输出范围较大.模型修改如下: 代码如下: #coding: utf8 '''' author: Huangyuliang ''' import json import random impo

  • 基于python的BP神经网络及异或实现过程解析

    BP神经网络是最简单的神经网络模型了,三层能够模拟非线性函数效果. 难点: 如何确定初始化参数? 如何确定隐含层节点数量? 迭代多少次?如何更快收敛? 如何获得全局最优解? ''' neural networks created on 2019.9.24 author: vince ''' import math import logging import numpy import random import matplotlib.pyplot as plt ''' neural network

  • Python机器学习应用之基于BP神经网络的预测篇详解

    目录 一.Introduction 1 BP神经网络的优点 2 BP神经网络的缺点 二.实现过程 1 Demo 2 基于BP神经网络的乳腺癌分类预测 三.Keys 一.Introduction 1 BP神经网络的优点 非线性映射能力:BP神经网络实质上实现了一个从输入到输出的映射功能,数学理论证明三层的神经网络就能够以任意精度逼近任何非线性连续函数.这使得其特别适合于求解内部机制复杂的问题,即BP神经网络具有较强的非线性映射能力. 自学习和自适应能力:BP神经网络在训练时,能够通过学习自动提取输

  • Python使用numpy实现BP神经网络

    本文完全利用numpy实现一个简单的BP神经网络,由于是做regression而不是classification,因此在这里输出层选取的激励函数就是f(x)=x.BP神经网络的具体原理此处不再介绍. import numpy as np class NeuralNetwork(object): def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate): # Set number of nodes in i

  • 用Python实现BP神经网络(附代码)

    用Python实现出来的机器学习算法都是什么样子呢? 前两期线性回归及逻辑回归项目已发布(见文末链接),今天来讲讲BP神经网络. BP神经网络 全部代码 https://github.com/lawlite19/MachineLearning_Python/blob/master/NeuralNetwok/NeuralNetwork.py 神经网络model 先介绍个三层的神经网络,如下图所示 输入层(input layer)有三个units( 为补上的bias,通常设为1) 表示第j层的第i个

  • python 使用Tensorflow训练BP神经网络实现鸢尾花分类

    Hello,兄弟们,开始搞深度学习了,今天出第一篇博客,小白一枚,如果发现错误请及时指正,万分感谢. 使用软件 Python 3.8,Tensorflow2.0 问题描述 鸢尾花主要分为狗尾草鸢尾(0).杂色鸢尾(1).弗吉尼亚鸢尾(2). 人们发现通过计算鸢尾花的花萼长.花萼宽.花瓣长.花瓣宽可以将鸢尾花分类. 所以只要给出足够多的鸢尾花花萼.花瓣数据,以及对应种类,使用合适的神经网络训练,就可以实现鸢尾花分类. 搭建神经网络 输入数据是花萼长.花萼宽.花瓣长.花瓣宽,是n行四列的矩阵. 而输

  • 基于Matlab实现BP神经网络交通标志识别

    目录 一.BP神经网络交通标志识别简介 二.部分源代码 三.运行结果 一.BP神经网络交通标志识别简介 道路交通标志用以禁止.警告.指示和限制道路使用者有秩序地使用道路, 保障出行安全.若能自动识别道路交通标志, 则将极大减少道路交通事故的发生.但是由于道路交通错综复杂, 且智能识别技术尚未成熟, 为了得到高效实用的道路标志识别系统, 仍需进行大量的研究.限速交通标志的检测识别作为道路交通标志识别系统的一个重要组成部分, 对它的研究具有非常重要的意义. 目前国内已有不少学者针对道路交通标志牌的智

随机推荐