C++简单的BP神经网络

最新推荐文章于 2024-04-28 20:12:43 发布

芭蕉湾马里奥

最新推荐文章于 2024-04-28 20:12:43 发布

阅读量464

点赞数 2

文章标签： c++ 神经网络开发语言

本文链接：https://blog.csdn.net/qq_31731573/article/details/133274461

版权

基于C++搭建BP神经网络

BP神经网络

包括信号的向前传播和误差的反向传播两个过程。即计算误差输出时按从输入到输出的方向进行，而调整权值和阈值则从输出到输入的方向进行。当实际输出与理想输出之间的误差超过期望时，就需要进入误差的反向传播过程。它首先从输出层开始，误差按照梯度下降的方法对各层权值进行修正，并依次向隐含层、输入层传播。通过不断的信息正向传播和误差反向传播，各层权值会不断进行调整，这就是神经网络的学习训练。当输出的误差减小到期望程度或者预先设定的学习迭代次数时，训练结束，BP神经网络完成学习。

BP神经网络

数据集

采用MNIST数据集，该数据集来自美国国家标准与技术研究所，由来自250个不同人手写的数字构成，其中50%是高中学生，50%来自人口普查局的工作人员。测试集也是同样比例的手写数字数据。

其中，训练数据集包括60000个样本及标签，测试数据集包括10000个样本及标签。

MNIST数据集	训练数据集	测试数据集
数字样本	train-images-idx3-ubyte.gz	t10k-images-idx3-ubyte.gz
数字标签	train-labels-idx1-ubyte.gz	t10k-labels-idx1-ubyte.gz

下载地址（GitHub镜像）（https://521github.com/golbin/TensorFlow-MNIST/tree/master/mnist/data）

MNIST

代码实现

头文件BP.h

#ifndef BP_H_INCLUDED
#define BP_H_INCLUDED
const int INPUT_LAYER = 784; //输入层维度
const int HIDDEN_LAYER = 40; //隐含层维度
const int OUTPUT_LAYER = 10; //输出层维度
const int TRAIN_TIMES = 10; //迭代训练次数
const double LEARN_RATE = 0.3; //学习率
class BP
{
private:
    int input_array[INPUT_LAYER]; //输入向量
    int aim_array[OUTPUT_LAYER]; //目标结果
    double weight1_array[INPUT_LAYER][HIDDEN_LAYER]; //输入层与隐含层之间的权重
    double weight2_array[HIDDEN_LAYER][OUTPUT_LAYER]; //隐含层与输出层之间的权重
    double output1_array[HIDDEN_LAYER]; //隐含层输出
    double output2_array[OUTPUT_LAYER]; //输出层输出
    double deviation1_array[HIDDEN_LAYER]; //隐含层误差
    double deviation2_array[OUTPUT_LAYER]; //输出层误差
    double threshold1_array[HIDDEN_LAYER]; //隐含层阈值
    double threshold2_array[OUTPUT_LAYER]; //输出层阈值
public:
    void Init(); //初始化各参数
    double Sigmoid(double x); //sigmoid激活函数
    void GetOutput1(); //得到隐含层输出
    void GetOutput2(); //得到输出层输出
    void GetDeviation1(); //得到隐含层误差
    void GetDeviation2(); //得到输出层误差
    void Feedback1(); //反馈输入层与隐含层之间的权重
    void Feedback2(); //反馈隐含层与输出层之间的权重
    void Train(); //训练
    void Test(); //测试
};
#endif // BP_H_INCLUDED#pragma once

源文件BP.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "BP.h"
#include <iostream>
#include <fstream>   
#include <string> 
#include<stdio.h>
#include<ctime>
using namespace std;
//初始化各参数
int total_times = 0; //当前测试了几次
int success_times = 0; //当前正确了几次
double rate = 0.0, best_rate = 0.0;
time_t time1, time2, time3;
void BP::Init()
{
    srand(time(NULL));
    for (int i = 0; i < INPUT_LAYER; i++)
        for (int j = 0; j < HIDDEN_LAYER; j++)
            weight1_array[i][j] = rand() / (double)(RAND_MAX) * 2 - 1;
    for (int i = 0; i < HIDDEN_LAYER; i++)
        for (int j = 0; j < OUTPUT_LAYER; j++)
            weight2_array[i][j] = rand() / (double)(RAND_MAX) * 2 - 1;
    for (int i = 0; i < HIDDEN_LAYER; i++)
        threshold1_array[i] = rand() / (double)(RAND_MAX) * 2 - 1;
    for (int i = 0; i < OUTPUT_LAYER; i++)
        threshold2_array[i] = rand() / (double)(RAND_MAX) * 2 - 1;
}
//sigmoid激活函数
double BP::Sigmoid(double x)
{
    return 1.0 / (1.0 + exp(-x));
}
//得到隐含层输出
void BP::GetOutput1()
{
    for (int j = 0; j < HIDDEN_LAYER; j++)
    {
        double total = threshold1_array[j];
        for (int i = 0; i < INPUT_LAYER; i++)
            total += input_array[i] * weight1_array[i][j];
        output1_array[j] = Sigmoid(total);
    }
}
//得到输出层输出
void BP::GetOutput2()
{
    for (int j = 0; j < OUTPUT_LAYER; j++)
    {
        double total = threshold2_array[j];
        for (int i = 0; i < HIDDEN_LAYER; i++)
            total += output1_array[i] * weight2_array[i][j];
        output2_array[j] = Sigmoid(total);
    }
}
//得到隐含层误差
void BP::GetDeviation1()
{
    for (int i = 0; i < HIDDEN_LAYER; i++)
    {
        double total = 0;
        for (int j = 0; j < OUTPUT_LAYER; j++)
            total += weight2_array[i][j] * deviation2_array[j];
        deviation1_array[i] = (output1_array[i]) * (1.0 - output1_array[i]) * total;
    }
}
//得到输出层误差
void BP::GetDeviation2()
{
    for (int i = 0; i < OUTPUT_LAYER; i++)
        deviation2_array[i] = (output2_array[i]) * (1.0 - output2_array[i]) * (output2_array[i] - aim_array[i]);
}
//反馈输入层与隐含层之间的权重
void BP::Feedback1()
{
    for (int j = 0; j < HIDDEN_LAYER; j++)
    {
        threshold1_array[j] -= LEARN_RATE * deviation1_array[j];
        for (int i = 0; i < INPUT_LAYER; i++)
            weight1_array[i][j] = weight1_array[i][j] - LEARN_RATE * input_array[i] * deviation1_array[j];
    }
}
//反馈隐含层与输出层之间的权重
void BP::Feedback2()
{
    for (int j = 0; j < OUTPUT_LAYER; j++)
    {
        threshold2_array[j] = threshold2_array[j] - LEARN_RATE * deviation2_array[j];
        for (int i = 0; i < HIDDEN_LAYER; i++)
            weight2_array[i][j] = weight2_array[i][j] - LEARN_RATE * output1_array[i] * deviation2_array[j];
    }
}

//训练
void BP::Train()
{
    FILE* train_images;
    FILE* train_labels;
  //  FILE* test_labels;
  //  FILE* test_images;
    train_images = fopen("train-images.idx3-ubyte", "rb");
    train_labels = fopen("train-labels.idx1-ubyte", "rb");


    unsigned char image[INPUT_LAYER];
    unsigned char label[OUTPUT_LAYER];
    unsigned char temp[100];
    //读取文件开头
    fread(temp, 1, 16, train_images);
    fread(temp, 1, 8, train_labels);

    int times = 0; //当前训练了几次
   
    cout << "开始训练..." << endl << endl;
    while (!feof(train_images) && !feof(train_labels))
    {
        fread(image, 1, INPUT_LAYER, train_images);
        fread(label, 1, 1, train_labels);
        //设置输入向量
        for (int i = 0; i < INPUT_LAYER; i++)
        {
            if ((unsigned int)image[i] < 64)
                input_array[i] = 0;
            else
                input_array[i] = 1;
        }
        //设置目标值
        int index = (unsigned int)label[0];
        memset(aim_array, 0, sizeof(aim_array));
        aim_array[index] = 1;
        GetOutput1(); //得到隐含层输出
        GetOutput2(); //得到输出层输出
        GetDeviation2(); //得到输出层误差
        GetDeviation1(); //得到隐含层误差
        Feedback1(); //反馈输入层与隐含层之间的权重
        Feedback2(); //反馈隐含层与输出层之间的权重
        ++times;
        if (times % 2000 == 0)
            cout << "已训练 " << times << "组" << endl;
        if (times % 10000== 0) //每10000组就测试一下
           Test();
    }
}


void BP::Test()
{
    FILE* test_images;
    FILE* test_labels;
    test_images = fopen("t10k-images.idx3-ubyte", "rb");
    test_labels = fopen("t10k-labels.idx1-ubyte", "rb");
    

    if (test_images == NULL || test_labels == NULL)
    {
        cout << "open training file error!" << endl;
        exit(0);
    }
    unsigned char image[784];
    unsigned char label[10];
    unsigned char temp[100];
    //读取文件开头
    fread(temp, 1, 16, test_images);
    fread(temp, 1, 8, test_labels);

    total_times = 0; //当前测试了几次
    success_times = 0; //当前正确了几次
    rate = 0.0;

    cout << "开始测试..." << endl;
    while (!feof(test_images) && !feof(test_labels))
    {
        fread(image, 1, INPUT_LAYER, test_images);
        fread(label, 1, 1, test_labels);
        //设置输入向量
        for (int i = 0; i < INPUT_LAYER; i++)
        {
            if ((unsigned int)image[i] < 64)
                input_array[i] = 0;
            else
                input_array[i] = 1;
        }
        //设置目标值
        memset(aim_array, 0, sizeof(aim_array));
        int index = (unsigned int)label[0];
        aim_array[index] = 1;
        GetOutput1(); //得到隐含层输出
        GetOutput2(); //得到输出层输出
        //以输出结果中最大的那个值所对应的数字作为预测的数字
        double maxn = -99999999;
        int max_index = 0;
        for (int i = 0; i < OUTPUT_LAYER; i++)
        {
            if (output2_array[i] > maxn)
            {
                maxn = output2_array[i];
                max_index = i;
            }
        }
        //如果预测正确
        if (aim_array[max_index] == 1)
            ++success_times;
        ++total_times;
        if (total_times % 2000 == 0)
            cout << "已测试：" << total_times << "组" << endl;
    }
    rate = 100.0 * success_times / total_times;
    if (rate > best_rate)
        best_rate = rate;
    cout << "正确率: " << rate << "%" << endl << endl;
    cout << "*************************" << endl << endl;

}

int main(int argc, char* argv[])
{
    BP bp;
    bp.Init();
    time_t start_time = time(nullptr);
    //训练数据反复利用TRAIN_TIMES次
    best_rate = 0.0
    for (int i = 0; i < TRAIN_TIMES; i++)
    {   
        time1 = time(nullptr);
        cout << "开始第" << i + 1 << "轮迭代" << endl << endl;
        bp.Train();
        time2 = time(nullptr);
        time3 = time2 - time1;
        cout << "第"<<i+1<<"次迭代时间为 " << time3 << " 秒" << std::endl;
        cout << "此次迭代最佳精度为" << best_rate << "%" << endl;
    }
    time_t end_time = time(nullptr);
    time_t elapsed_time = end_time - start_time;
    cout << "程序运行时间为 " << elapsed_time << " 秒" << std::endl;

    return 0;
}

实验遇到的问题

由于编译器软件的问题，Visual Studio 2022不支持bits/stdc++.h头文件，因此根据代码要求进行头文件的添加，依次添加了iostream、fstream、string、stdio.h、ctime
编译器Visual Studio认为fopen函数存在安全风险，实验报错，因此在源文件开头添加上宏定义 _CRT_SECURE_NO_WARNINGS
使用fopen函数时，注意文件名称应当正确，否则会出现ERROR_FILE_NOT_FOUND,推荐复制文件名，用相对路径的方法打开文件即可减少此错误发生的概率
从GitHub上下载的数据集是四个压缩文件，因此需要先进行文件解压操作，如果没有解压直接使用fopen函数，则会导致FILE指针读取不了文件，解决方法：
1. 通过vckpg下载zlib库，然后在源文件中添加上zlib头文件，再将fopen、fread函数替换为与之对应的gzopen和gzlib函数。不过此方法较为繁琐，不推荐使用。
2. 将训练数据集和测试数据集依次解压，解压后可直接使用fopen、fread函数进行操作，更加简洁。

实验结果

每次迭代使用全部的60000组数据进行训练，每训练10000组时进行一次测试操作，一共进行十次迭代，记录每次迭代的最佳精度、每次迭代的时长以及10次迭代的总时长。分别在学习率为0.1 0.3和3下进行了实验，以下是实验数据：

学习率=0.1

迭代轮数	时长	最佳精度
一	23 秒	89.7207%
二	21 秒	91.5008%
三	22 秒	92.4708%
四	22 秒	93.1007%
五	21 秒	93.3607%
六	21 秒	93.6506%
七	21 秒	93.8306%
八	21 秒	93.9906%
九	22 秒	94.0606%
十	21 秒	94.1806%

总时长	215 秒

0.1

学习率=0.3

迭代轮数	时长	最佳精度
一	21 秒	91.1809%
二	21 秒	92.9207%
三	21 秒	93.6406%
四	21 秒	94.1206%
五	21 秒	94.1306%
六	21 秒	94.4706%
七	21 秒	94.6805%
八	21 秒	94.5705%
九	21 秒	94.9505%
十	21 秒	94.5505%

总时长	213 秒

0.3

学习率=3

迭代轮数	时长	最佳精度
一	22 秒	64.2336%
二	22 秒	67.3833%
三	21 秒	70.6029%
四	21 秒	69.3631%
五	21 秒	70.6529%
六	22 秒	73.9626%
七	21 秒	72.0128%
八	22 秒	73.5026%
九	21 秒	73.7626%
十	21 秒	75.3125%

总时长	214 秒

总结

BP神经网络在不同学习率的情况下最终的迭代精度会有所不同，学习率较小时，达到同样精度需要更多的迭代次数，学习率过大时，则会导致迭代精度偏差较大，甚至出现震荡现象，容易导致过拟合，因此在实际情况中应该选择一个合适的学习率，或者根据迭代次数进行学习率的动态变化从而达到更好的效果。

芭蕉湾马里奥

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
C++简单的BP神经网络

BP神经网络在不同学习率的情况下最终的迭代精度会有所不同，学习率较小时，达到同样精度需要更多的迭代次数，学习率过大时，则会导致迭代精度偏差较大，甚至出现震荡现象，容易导致过拟合，因此在实际情况中应该选择一个合适的学习率，或者根据迭代次数进行学习率的动态变化从而达到更好的效果。
复制链接

扫一扫