搭建BP神经网络

已于 2023-09-27 13:21:00 修改
阅读量302 收藏 1
点赞数
文章标签： 神经网络 人工智能 深度学习
于 2023-09-26 22:05:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44708206/article/details/133324213
版权

1.数据集下载
2.C语言代码
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 double LEARN_RATE = 0.3; //学习率
const int TRAIN_TIMES = 10; //迭代训练次数
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

BP.cpp

#include <bits/stdc++.h>
#include<iostream>
#include <ctime>
#include <chrono>
#include "BP.h"
using namespace std;
//初始化各参数
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;
	errno_t err1, err2;

	err1 = fopen_s(&train_images, "train-images.idx3-ubyte", "rb");
	if (err1 != 0) {
		perror("Failed to open train-images.idx3-ubyte");
		return; // 或者采取其他错误处理措施
	}

	err2 = fopen_s(&train_labels, "train-labels.idx1-ubyte", "rb");
	if (err2 != 0) {
		perror("Failed to open train-labels.idx1-ubyte");
		fclose(train_images); // 关闭图像文件
		return; // 或者采取其他错误处理措施
	}

	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();
	}

	
	// 关闭文件
	fclose(train_images);
	fclose(train_labels);
}
//测试
void BP::Test()
{
	FILE *test_images;
	FILE *test_labels;
	errno_t err1, err2;

	err1 = fopen_s(&test_images, "t10k-images.idx3-ubyte", "rb");
	if (err1 != 0) {
		perror("Failed to open t10k-images.idx3-ubyte");
		return; // 或者采取其他错误处理措施
	}

	err2 = fopen_s(&test_labels, "t10k-labels.idx1-ubyte", "rb");
	if (err2 != 0) {
		perror("Failed to open t10k-labels.idx1-ubyte");
		fclose(test_images); // 关闭图像文件
		return; // 或者采取其他错误处理措施
	}

	unsigned char image[784];
	unsigned char label[10];
	unsigned char temp[100];
	//读取文件开头
	fread(temp, 1, 16, test_images);
	fread(temp, 1, 8, test_labels);
	int total_times = 0; //当前测试了几次
	int success_times = 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;
	}
	


	cout << "正确率: " << 100.0 * success_times / total_times << "%" << endl << endl;
	cout << "*************************" << endl << endl;

	// 关闭文件
	fclose(test_images);
	fclose(test_labels);
}
int main(int argc, char * argv[])
{
	// 计时器开始
	auto start_time = std::chrono::high_resolution_clock::now();
	BP bp;
	bp.Init();
	//训练数据反复利用TRAIN_TIMES次
	for (int i = 0; i < TRAIN_TIMES; i++)
	{
		cout << "开始第" << i + 1 << "轮迭代" << endl << endl;
		bp.Train();
	}
	// 计时器结束
	auto end_time = std::chrono::high_resolution_clock::now();
	auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
	std::cout << "总时间: " << duration.count() << " milliseconds" << std::endl;
	return 0;
}

运行截图
在这里插入图片描述

测量迭代10轮所用的时间：在main()函数中添加计时器：std::chrono::high_resolution_clock

学习率0.10.20.3
准确率94.48%95.02%95.15%
时间717.224s869.209s725.855s

正确率的增长逐渐变得缓慢，程序的运行时间也要相应的加长

在这里插入图片描述
在这里插入图片描述

川河w
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python纯手动搭建BP神经网络--手写数字识别
C橘子
11-04 6631
1 实验介绍 实验要求： 实现一个手写数字识别程序， 如下图所示， 要求神经网络包含一个隐层， 隐层的神经元个数为 15。 整体思路：主要参考西瓜书第五章神经网络部分的介绍，使用批量梯度下降对神经网络进行训练。 Tip: 整体代码及数据集链接在文末 2 读取并处理数据 数据读取思路： 数据集中给出的图片为28*28的灰度图，利用plt.imread()函数将图片读取出来后为 28x28 的数组，如果使用神经网络进行训练的话，我们可以将每一个像素视为一个特征，所以将图片利用numpy.reshape方法将
基于BP神经网络的模式识别（matlab）
04-21
基于BP神经网络的模式识别（matlab）
BP神经网络（python实现）
2303_78738507的博客
03-09 4072
BP神经网络的学习属于有监督学习，需要一组已知期望输出的学习样本集。训练时先使用随机值作为权值（即权重，取值在前向传播部分有介绍），输入学习样本得到网络的输出。然后根据输出值与期望输出计算误差，再由误差根据某种准则逐层修改权值，使误差减小。如此反复，直到误差不再下降，网络就完成训练。
Python学习记录 搭建BP神经网络实现手写数字识别
喵呜
05-13 6755
搭建BP神经网络实现手写数字识别 通过之前的文章我们知道了，构建一个简单的神经网络需要以下步骤 准备数据 初始化假设 输入神经网络进行计算 输出运行结果 这次，我们来通过sklearn的手写数字数据集，来搭建一个BP神经网络，实现手写数字识别 背景 搭建的是一个2层的神经网络，包含一个输入层（输入层一般不计入网络的层数里面），一个隐藏层和一个输出层 每个样本包含64个特征，标签进行了独热化处理（独热化处理就会将每种标签转化成一个只包含0和1，长度为10的数组，例如：数字0的标签就为[1,0,0,0,0
BP神经网络预测matlab代码讲解与实现步骤
热门推荐
CJ-leaf的博客
12-07 21万+
文章目录1. BP神经网络的简介和结构参数1.1 BP神经网络的结构组成1.2 BP神经网络训练界面的参数解读2. 实现BP网络的步骤3. matlab代码编写4. BP代码运行结果4.1 预测值和真实值的误差计算（MAE、MSE、MRSE）4.2 BP网络训练的性能分析图像5. 结语6. MATLAB代码 1. BP神经网络的简介和结构参数 神经网络是机器学习中一种常见的数学模型，通过构建类似于大脑神经突触联接的结构，来进行信息处理。在应用神经网络的过程中，处理信息的单元一般分为三类：输入单元、输出单元和
simulink搭建BP神经网络在线辨识心得
叮当说的博客
12-20 3312
bp 神经网络通常是离线训练，然后使用的，但是有些场合却会要求在线训练然后进行辨识 其实在线辨识的意义和离线辨识基本相同，就是在训练过程中就开始使用权重了，然后不管其权重是否准确，这样会产生输出，该输出和实际要求的输出进行做差再来重新调整权重。 我们大概可以理解为，其架构如下： 这个模块理解上很简单，就是一个模块使用权重产生输出，另外一个模块根据输出数值的差异调整权重，以供另外一个模块来使用。 然后在很多论文中并非使用这样的架构，而是使用一个元件： unit delay :单周期延时控件.
BP神经网络的搭建
qq_46721967的博客
08-11 4382
1. BP神经网络的简介和结构参数 神经网络是机器学习中一种常见的数学模型，通过构建类似于大脑神经突触联接的结构，来进行信息处理。在应用神经网络的过程中，处理信息的单元一般分为三类：输入单元、输出单元和隐含单元。 顾名思义：输入单元接受外部给的信号与数据；输出单元实现系统处理结果的输出；隐含单元处在输入和输出单元之间，从网络系统外部是无法观测到隐含单元的结构的。除了上述三个处理信息的单元之外，神经元间的连接强度大小由权值等参数来决定。 1.1 BP神经网络的结构组成 下图是训练神经网络时经常出现的一个
【Python深度学习系列】基于Sequential方法搭建BP神经网络实现分类任务（附源码和实现效果）
数据杂坛
10-24 1274
基于Sequential方法搭建BP神经网络实现分类任务（附源码和实现效果）
Python纯手动搭建BP神经网络（手写数字识别）
学姐带你玩AI的博客
01-27 2437
Python纯手动搭建BP神经网络
神经网络——Python实现BP神经网络算法（理论+例子+程序）
Linyun2tt的博客
11-27 7万+
一、基于BP算法的多层感知器模型 采用BP算法的多层感知器是至今为止应用最广泛的神经网络，在多层感知器的应用中，以图3-15所示的单隐层网络的应用最为普遍。一般习惯将单隐层前馈网称为三层感知器，所谓三层包括了输入层、隐层和输出层。 算法最终结果采用梯度下降法，具体详细过程此处就省略了！ 二、BP算法的程序实现流程 三、标准BP算法的改进——增加动量项 标准BP算法在调整权值时，只按t时刻误差的梯度降方向调整，而没有考虑t时刻以前的梯度方向，从而常使训练过程发生振荡，收敛缓慢。为了提
(完整)基于BP神经网络的手写数字识别实验报告.docx
06-16
《基于BP神经网络的手写数字识别实验报告》 在当今信息爆炸的时代，光学字符识别（OCR）技术在信息录入和转换中扮演着至关重要的角色，尤其是手写数字的识别，其应用广泛，如邮政编码、统计报表、银行票据等，具有...
BP神经网络实现手写数字输入识别python
01-20
BP神经网络实现手写数字输入识别python 代码可以在下面链接中下载： https://gitee.com/cloud_maple/python_machine_learning.git 训练集和测试集都可以在下面链接中下载： 链接：...
用BP神经网络实现minist手写数字识别
01-07
**BP神经网络实现MNIST手写数字识别** MNIST（Modified National Institute of Standards and Technology）是一个广泛用于机器学习和深度学习领域，特别是图像识别的数据库。它包含了60,000个训练样本和10,000个...
BP神经网络啤酒种类预测
06-02
BP神经网络，全称为Backpropagation Neural Network，是一种在机器学习领域广泛应用的多层前馈神经网络。这种网络设计灵感来源于人脑的生物神经元结构，通过模拟神经元之间的连接和信号传递，来处理复杂的非线性问题...
认识神经网络【多层感知器数学原理】
逐梦苍穹的博客
07-24 1402
简单认识神经网络，学习多层感知器的数学原理和公式
昇思25天学习打卡营第1天|快速入门
07-28 655
昇思大模型平台是一个集算法选型、创意分享、模型实验和大模型在线体验为一体的AI学习与实践社区，而且还内置了AI实验室，它覆盖多领域任务，体验全流程开发，支持用户在线训练和推理可视化，可创建自己的项目空间对待开发者很友好，提供云上开发环境，无需配置环境，既可灵活调试运行代码，每天免费使用8个小时。
MOE模式：或将是最好的大模型应用开发路径
AI相关从业分享
07-28 646
MOE（Mixture of Experts，混合专家）是一种机器学习模型架构，旨在通过结合多个专家网络来提高模型的性能和泛化能力。以下是传统模型和大模型中MOE模式的相关介绍及其优势。传统模型中的MOEGate网络：决定输入数据应该被路由到哪一个专家网络。Gate网络可以根据输入数据的特征来动态分配数据。Expert网络：一系列专门的网络，每个网络都是针对特定数据分布进行训练的。Expert网络可以是对特定问题有深入理解的小模型。组合层：将所有Expert网络的输出进行组合，形成最终的预测结果。
带并行卷积的水下图像背景前景分割方法
最新发布
renhongxia1的博客
07-30 570
图6，7为不同照度条件下水下图像及在不同分割方法的实验结果，其中第1，4行的原始图像为13.826 lx照度下采集的，第2，5行为6.947 lx照度下采集的，第3，6行为0.925 lx照度下采集的。在进行图像采集时，图6，7中，目标距离采集设备分别为1.4，1 m。图5是相机距目标1.4 m处采集的图像，图5a）为空气中的图像，图5b）为照度为13.826 lx条件下采集的水下图像，图5c）为照度为6.947 lx条件下采集的水下图像，图5d）为照度为0.925 lx条件下采集的水下图像。
python 搭建bp神经网络
05-15
Python 搭建 BP 神经网络一般可以通过如下步骤实现： 1.导入必要的库：NumPy、Pandas 等。 2.准备数据集：将数据集分为训练集和测试集，并对数据进行归一化处理。 3.初始化神经网络参数：设置输入层、输出层、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值