成都创新互联网站制作重庆分公司

C++如何实现简单BP神经网络-创新互联

这篇文章主要讲解了C++如何实现简单BP神经网络,内容清晰明了,对此有兴趣的小伙伴可以学习一下,相信大家阅读完之后会有帮助。

站在用户的角度思考问题,与客户深入沟通,找到华池网站设计与华池网站推广的解决方案,凭借多年的经验,让设计与互联网技术结合,创造个性化、用户体验好的作品,建站类型包括:成都网站建设、网站制作、企业官网、英文网站、手机端网站、网站推广、域名注册雅安服务器托管、企业邮箱。业务覆盖华池地区。

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

实现了一个简单的BP神经网络

使用EasyX图形化显示训练过程和训练结果

使用了25个样本,一共训练了1万次。

该神经网络有两个输入,一个输出端

下图是训练效果,data是训练的输入数据,temp代表所在层的输出,target是训练目标,右边的大图是BP神经网络的测试结果。

C++如何实现简单BP神经网络

以下是详细的代码实现,主要还是基本的矩阵运算。

#include 
#include 
#include 
#include 
#include 

#define uint unsigned short
#define real double

#define threshold (real)(rand() % 99998 + 1) / 100000

// 神经网络的层
class layer{
private:
 char name[20];
 uint row, col;
 uint x, y;
 real **data;
 real *bias;
public:
 layer(){
 strcpy_s(name, "temp");
 row = 1;
 col = 3;
 x = y = 0;
 data = new real*[row];
 bias = new real[row];
 for (uint i = 0; i < row; i++){
  data[i] = new real[col];
  bias[i] = threshold;
  for (uint j = 0; j < col; j++){
  data[i][j] = 1;
  }
 }
 }
 layer(FILE *fp){
 fscanf_s(fp, "%d %d %d %d %s", &row, &col, &x, &y, name);
 data = new real*[row];
 bias = new real[row];
 for (uint i = 0; i < row; i++){
  data[i] = new real[col];
  bias[i] = threshold;
  for (uint j = 0; j < col; j++){
  fscanf_s(fp, "%lf", &data[i][j]);
  }
 }
 }
 layer(uint row, uint col){
 strcpy_s(name, "temp");
 this->row = row;
 this->col = col;
 this->x = 0;
 this->y = 0;
 this->data = new real*[row];
 this->bias = new real[row];
 for (uint i = 0; i < row; i++){
  data[i] = new real[col];
  bias[i] = threshold;
  for (uint j = 0; j < col; j++){
  data[i][j] = 1.0f;
  }
 }
 }
 layer(const layer &a){
 strcpy_s(name, a.name);
 row = a.row, col = a.col;
 x = a.x, y = a.y;
 data = new real*[row];
 bias = new real[row];
 for (uint i = 0; i < row; i++){
  data[i] = new real[col];
  bias[i] = a.bias[i];
  for (uint j = 0; j < col; j++){
  data[i][j] = a.data[i][j];
  }
 }
 }
 ~layer(){
 // 删除原有数据
 for (uint i = 0; i < row; i++){
  delete[]data[i];
 }
 delete[]data;
 }
 layer& operator =(const layer &a){
 // 删除原有数据
 for (uint i = 0; i < row; i++){
  delete[]data[i];
 }
 delete[]data;
 delete[]bias;
 // 重新分配空间
 strcpy_s(name, a.name);
 row = a.row, col = a.col;
 x = a.x, y = a.y;
 data = new real*[row];
 bias = new real[row];
 for (uint i = 0; i < row; i++){
  data[i] = new real[col];
  bias[i] = a.bias[i];
  for (uint j = 0; j < col; j++){
  data[i][j] = a.data[i][j];
  }
 }
 return *this;
 }
 layer Transpose() const {
 layer arr(col, row);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  arr.data[j][i] = data[i][j];
  }
 }
 return arr;
 }
 layer sigmoid(){
 layer arr(col, row);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < x.row; i++){
  for (uint j = 0; j < x.col; j++){
  arr.data[i][j] = 1 / (1 + exp(-data[i][j]));// 1/(1+exp(-z))
  }
 }
 return arr;
 }
 layer operator *(const layer &b){
 layer arr(row, col);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  arr.data[i][j] = data[i][j] * b.data[i][j];
  }
 }
 return arr;
 }
 layer operator *(const int b){
 layer arr(row, col);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  arr.data[i][j] = b * data[i][j];
  }
 }
 return arr;
 }
 layer matmul(const layer &b){
 layer arr(row, b.col);
 arr.x = x, arr.y = y;
 for (uint k = 0; k < b.col; k++){
  for (uint i = 0; i < row; i++){
  arr.bias[i] = bias[i];
  arr.data[i][k] = 0;
  for (uint j = 0; j < col; j++){
   arr.data[i][k] += data[i][j] * b.data[j][k];
  }
  }
 }
 return arr;
 }
 layer operator -(const layer &b){
 layer arr(row, col);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  arr.data[i][j] = data[i][j] - b.data[i][j];
  }
 }
 return arr;
 }
 layer operator +(const layer &b){
 layer arr(row, col);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  arr.data[i][j] = data[i][j] + b.data[i][j];
  }
 }
 return arr;
 }
 layer neg(){
 layer arr(row, col);
 arr.x = x, arr.y = y;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  arr.data[i][j] = -data[i][j];
  }
 }
 return arr;
 }
 bool operator ==(const layer &a){
 bool result = true;
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  if (abs(data[i][j] - a.data[i][j]) > 10e-6){
   result = false;
   break;
  }
  }
 }
 return result;
 }
 void randomize(){
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  data[i][j] = threshold;
  }
  bias[i] = 0.3;
 }
 }
 void print(){
 outtextxy(x, y - 20, name);
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  COLORREF color = HSVtoRGB(360 * data[i][j], 1, 1);
  putpixel(x + i, y + j, color);
  }
 }
 }
 void save(FILE *fp){
 fprintf_s(fp, "%d %d %d %d %s\n", row, col, x, y, name);
 for (uint i = 0; i < row; i++){
  for (uint j = 0; j < col; j++){
  fprintf_s(fp, "%lf ", data[i][j]);
  }
  fprintf_s(fp, "\n");
 }
 }
 friend class network;
 friend layer operator *(const double a, const layer &b);
};

layer operator *(const double a, const layer &b){
 layer arr(b.row, b.col);
 arr.x = b.x, arr.y = b.y;
 for (uint i = 0; i < arr.row; i++){
 for (uint j = 0; j < arr.col; j++){
  arr.data[i][j] = a * b.data[i][j];
 }
 }
 return arr;
}

// 神经网络
class network{
 int iter;
 double learn;
 layer arr[3];
 layer data, target, test;
 layer& unit(layer &x){
 for (uint i = 0; i < x.row; i++){
  for (uint j = 0; j < x.col; j++){
  x.data[i][j] = i == j ? 1.0 : 0.0;
  }
 }
 return x;
 }
 layer grad_sigmoid(layer &x){
 layer e(x.row, x.col);
 e = x*(e - x);
 return e;
 }
public:
 network(FILE *fp){
 fscanf_s(fp, "%d %lf", &iter, &learn);
 // 输入数据
 data = layer(fp);
 for (uint i = 0; i < 3; i++){
  arr[i] = layer(fp);
  //arr[i].randomize();
 }
 target = layer(fp);
 // 测试数据
 test = layer(2, 40000);
 for (uint i = 0; i < test.col; i++){
  test.data[0][i] = ((double)i / 200) / 200.0f;
  test.data[1][i] = (double)(i % 200) / 200.0f;
 }
 }
 void train(){
 int i = 0;
 char str[20];
 data.print();
 target.print();
 for (i = 0; i < iter; i++){
  sprintf_s(str, "Iterate:%d", i);
  outtextxy(0, 0, str);
  // 正向传播
  layer l0 = data;
  layer l1 = arr[0].matmul(l0).sigmoid();
  layer l2 = arr[1].matmul(l1).sigmoid();
  layer l3 = arr[2].matmul(l2).sigmoid();
  // 显示输出结果
  l1.print();
  l2.print();
  l3.print();
  if (l3 == target){
  break;
  }
  // 反向传播
  layer l3_delta = (l3 - target ) * grad_sigmoid(l3);
  layer l2_delta = arr[2].Transpose().matmul(l3_delta) * grad_sigmoid(l2);
  layer l1_delta = arr[1].Transpose().matmul(l2_delta) * grad_sigmoid(l1);
  // 梯度下降法
  arr[2] = arr[2] - learn * l3_delta.matmul(l2.Transpose());
  arr[1] = arr[1] - learn * l2_delta.matmul(l1.Transpose());
  arr[0] = arr[0] - learn * l1_delta.matmul(l0.Transpose());
 }
 sprintf_s(str, "Iterate:%d", i);
 outtextxy(0, 0, str);
 // 测试输出
 // selftest();
 }
 void selftest(){
 // 测试
 layer l0 = test;
 layer l1 = arr[0].matmul(l0).sigmoid();
 layer l2 = arr[1].matmul(l1).sigmoid();
 layer l3 = arr[2].matmul(l2).sigmoid();
 setlinecolor(WHITE);
 // 测试例
 for (uint j = 0; j < test.col; j++){
  COLORREF color = HSVtoRGB(360 * l3.data[0][j], 1, 1);// 输出颜色
  putpixel((int)(test.data[0][j] * 160) + 400, (int)(test.data[1][j] * 160) + 30, color);
 }
 // 标准例
 for (uint j = 0; j < data.col; j++){
  COLORREF color = HSVtoRGB(360 * target.data[0][j], 1, 1);// 输出颜色
  setfillcolor(color);
  fillcircle((int)(data.data[0][j] * 160) + 400, (int)(data.data[1][j] * 160) + 30, 3);
 }
 line(400, 30, 400, 230);
 line(400, 30, 600, 30);
 }
 void save(FILE *fp){
 fprintf_s(fp, "%d %lf\n", iter, learn);
 data.save(fp);
 for (uint i = 0; i < 3; i++){
  arr[i].save(fp);
 }
 target.save(fp);
 }
};

另外有需要云服务器可以了解下创新互联建站www.cdcxhl.com,海内外云服务器15元起步,三天无理由+7*72小时售后在线,公司持有idc许可证,提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案,具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势,专为企业上云打造定制,能够满足用户丰富、多元化的应用场景需求。


当前文章:C++如何实现简单BP神经网络-创新互联
本文网址:http://cxhlcq.com/article/gghdd.html

其他资讯

在线咨询

微信咨询

电话咨询

028-86922220(工作日)

18980820575(7×24)

提交需求

返回顶部