运用BP神经网络预测波士顿房价（两层隐含层）

最新推荐文章于 2023-05-29 20:38:01 发布
最新推荐文章于 2023-05-29 20:38:01 发布
阅读量2.7k 收藏 33
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_51489074/article/details/117392011
版权

机器学习 神经网络 c语言 深度学习 算法

前言

程序中的最大学习次数，训练结束条件，学习率，隐含层神经元个数可以一步调整，所以读者可自行拿去测试，我下面的程序里隐含层神经元个数较多，运行时间会较长。另外，如果读者能对房价预测的精度提高给出建议，我将倍感荣幸，期待与你的交流。
至于BP神经网络的原理及公式推导，此处不加阐释。数据文件可在我之前的文章中找到，链接如下：多元线性回归求解波士顿房价问题

源程序

#include<math.h>
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define Data 380				//训练样本个数
#define TestData 126			//测试样本个数
#define In 13					//输入层神经元个数
#define Out 1					//输出层神经元个数
#define Neuron1 40				//隐含层1神经元个数 (程序运行需要很久)
#define Neuron2 40				//隐含层2神经元个数 (程序运行需要很久)
#define TrainC 100000			//训练次数
#define WAlta 0.1			//权值w（隐含层2到输出层）学习率
#define V1Alta 0.5				//权值v1（输入层到隐含层1）学习率
#define V2Alta 0.5				//权值v2（隐含层1到隐含层2）学习率
#define FeatureNumber 14		//特征个数加房价
char FeatureName[FeatureNumber][15]; 	//存储特征名字
double d_in[Data+TestData][In];			//存储输入数据用于乱序，并分出训练集和测试集
double d_out[Data+TestData][Out];		//存储输出数据用于乱序，并分出训练集和测试集	
double t_in[TestData][In];				//存储测试集输入
double t_out[TestData][Out];			//存储测试集输出
double pre[TestData][Out];				//存储预测样本的输出
double v1[Neuron1][In];					//存储输入层到隐含层1的权值
double v2[Neuron2][Neuron1];			//存储隐含层1到隐含层2的权值
double Y1[Neuron1];						//存储隐含层1的输出
double Y2[Neuron2];						//存储隐含层2的输出
double w[Out][Neuron2];					//存储隐含层2到输出层的权值
double Maxin[In], Minin[In];			//存储样本输入的最大，最小值
double Maxout[Out], Minout[Out];		//存储样本输出的最大，最小值
double OutputData[Out];					//存储神经网络的输出
double dw[Out][Neuron2], dv2[Neuron2][Neuron1], dv1[Neuron1][In];//存储各权值的修正值
double mse;								//存储均方误差
double rmse;							//存储均方根误差
void ReadData() {						//读取数据
	srand((int)time(0));
	int i, j, k;
	FILE* fp;
	if ((fp = fopen("housing.txt", "r")) == NULL) {		//打开数据文件
		printf("不能打开文件！\n");
		exit(0);
	}
	for (i = 0; i < FeatureNumber; ++i) {			//输入13个房价特征的名字以及房价MEDV
		fscanf(fp, "%s", FeatureName[i]);
	}
	for (i = 0; i < Data+TestData; ++i) {			//文件中数据转移到数组
		for (j = 0; j < In; ++j) {
			fscanf(fp, "%lf", &d_in[i][j]);
		}
		for (k = 0; k < Out; ++k) {
			fscanf(fp, "%lf", &d_out[i][k]);
		}
	}
	for (i = 0; i < Data + TestData; ++i) {			//打乱数据集顺序
		int k = rand() % (Data + TestData);
		for (int l = 0; l < In; ++l) {
			double tmp = d_in[i][l];
			d_in[i][l] = d_in[k][l];
			d_in[k][l] = tmp;
		}
		for (int l = 0; l < Out; ++l) {
			double tmp = d_out[i][l];
			d_out[i][l] = d_out[k][l];
			d_out[k][l] = tmp;
		}
	}
	for (i = Data; i < TestData+Data; ++i) {		//从数据集中分出训练集和测试集
		for (j = 0; j < In; ++j) {
			t_in[i-Data][j] = d_in[i][j];
		}
		for (k = 0; k < Out; ++k) {
			t_out[i-Data][k] = d_out[i][k];
		}
	}
	fclose(fp);
}
void InitBPNetwork() {									//初始化
	int i, j;	
	srand((int)time(0));
	for (i = 0; i < In; ++i) {							//寻找训练集各输入（各特征）最大最小值
		Minin[i] = Maxin[i] = d_in[0][i];
		for (j = 0; j < Data; ++j) {
			Maxin[i] = Maxin[i] > d_in[j][i] ? Maxin[i] : d_in[j][i];
			Minin[i] = Minin[i] < d_in[j][i] ? Minin[i] : d_in[j][i];
		}
	}				
	for (i = 0; i < Out; ++i) {							//寻找训练集输出（房价）最大最小值
		Minout[i] = Maxout[i] = d_out[0][i];
		for (j = 0; j < Data; ++j) {
			Maxout[i] = Maxout[i] > d_out[j][i] ? Maxout[i] : d_out[j][i];
			Minout[i] = Minout[i] < d_out[j][i] ? Minout[i] : d_out[j][i];
		}
	}
	for (i = 0; i < In; ++i) {							//训练集输入数据归一化
		for (j = 0; j < Data; ++j) {
			d_in[j][i] = (d_in[j][i] - Minin[i]) / (Maxin[i] - Minin[i]);
		}
	}
	for (i = 0; i < Out; ++i) {							//训练集输出数据归一化
		for (j = 0; j < Data; ++j) {
			d_out[j][i] = (d_out[j][i] - Minout[i]) / (Maxout[i] - Minout[i]);
		}
	}
	for (i = 0; i < Neuron1; ++i) {						//初始化输入层到隐含层1的权值与修正值
		for (j = 0; j < In; ++j) {
			v1[i][j] = rand() * 2.0 / RAND_MAX - 1;
			dv1[i][j] = 0;
		}
	}
	for (i = 0; i < Neuron2; ++i) {						//初始化隐含层1到隐含层2的权值与修正值
		for (j = 0; j < Neuron1; ++j) {
			v2[i][j] = rand() * 2.0 / RAND_MAX - 1;
			dv2[i][j] = 0;
		}
	}
	for (i = 0; i< Out; ++i) {							//初始化隐含层2到输出层的权值与修正值
		for (j = 0; j < Neuron2; ++j) {
			w[i][j] = rand() * 2.0 / RAND_MAX - 1;
			dw[i][j] = 0;
		}
	}
}
void ComputO(int var) {								//前向传播
	int i, j;
	double sum;
	for (i = 0; i < Neuron1; ++i) {					//计算隐含层1的输出
		sum = 0;
		for (j = 0; j < In; ++j) {
			sum += d_in[var][j] * v1[i][j];
		}
		Y1[i] = 1 / (1 + exp(-1 * sum));
	}
	for (i = 0; i < Neuron2; ++i) {					//计算隐含层2的输出
		sum = 0;
		for (j = 0; j < Neuron1; ++j) {
			sum += Y1[j] * v2[i][j];
		}
		Y2[i] = 1 / (1 + exp(-1 * sum));
	}
	for (i = 0; i < Out; ++i) {						//计算输出层的输出
		sum = 0;
		for (j = 0; j < Neuron2; ++j) {
			sum += Y2[j] * w[i][j];
		}
		OutputData[i] = 1 / (1 + exp(-1 * sum));	//神经网络的输出
	}
}
void BackUpdata(int var) {							//反向传播的权值修正
	int i, j, k;
	double s;
	double t = 0;
	for (k = 0; k < Neuron1; ++k) {
		s = 0;
		for (i = 0; i < Neuron2; ++i) {
			t = 0;
			for (j = 0; j < Out; ++j) {
				dw[j][i] = WAlta * (d_out[var][j] - OutputData[j]) * OutputData[j] * (1 - OutputData[j]) * Y2[i];//计算权值w的修正值
				t += (d_out[var][j] - OutputData[j]) * OutputData[j] * (1 - OutputData[j]) * w[j][i];
			}
			for (j = 0; j < Neuron1; ++j) {
				dv2[i][j] = V2Alta * t * Y2[i] * (1 - Y2[i]) * Y1[j];//计算权值v2的修正值
			}
			s += t * Y2[i] * (1 - Y2[i]) * v2[i][k];
		}
		for (i = 0; i < In; ++i) {
			dv1[k][i] = V1Alta * s * Y1[k] * (1 - Y1[k]) * d_in[var][i];//计算权值v1的修正值
		}
	}
	for (i = 0; i < In; ++i) {						//修正各权值
		for (j = 0; j < Neuron1; ++j) {
			v1[j][i] += dv1[j][i];
		}
	}
	for (i = 0; i < Neuron1; ++i) {
		for (j = 0; j < Neuron2; ++j) {
			v2[j][i] += dv2[j][i];
		}
	}
	for (i = 0; i < Neuron2; ++i) {
		for (j = 0; j < Out; ++j) {
			w[j][i] += dw[j][i];
		}
	}
}
void TrainNetwork() {							//神经网络的训练
	int count = 1;
	int i, j;
	do {
		mse = 0;
		for (i = 0; i < Data; ++i) {
			ComputO(i);
			BackUpdata(i);
			for (j = 0; j < Out; ++j) {
				double tmp1 = OutputData[j] * (Maxout[j] - Minout[j]) + Minout[j];
				double tmp2 = d_out[i][j] * (Maxout[j] - Minout[j]) + Minout[j];
				mse += (tmp1 - tmp2) * (tmp1 - tmp2);	//累计均方误差
			}
		}
		mse /= (double)Data * Out;				//计算均方误差
		if (count % 1000 == 0) {					//观测
			printf("训练次数:%d\t均方误差:%lf\n", count, mse);
		}
		count++;
	} while (count <= TrainC && mse >= 1);
	printf("\n训练结束\n\n");
}
void TestNetwork() {							//测试
	int i, j, k;
	double sum;
	for (i = 0; i < In; ++i) {					//测试集输入数据归一化
		for (j = 0; j < TestData; ++j) {
			t_in[j][i] = (t_in[j][i] - Minin[i]) / (Maxin[i] - Minin[i]);
		}
	}
	for (k = 0; k< TestData; ++k) {				//计算神经网络的输出
		for (i = 0; i < Neuron1; ++i) {
			sum = 0;
			for (j = 0; j < In; ++j) {
				sum += t_in[k][j] * v1[i][j];
			}
			Y1[i] = 1 / (1 + exp(-1 * sum));
		}
		for (i = 0; i < Neuron2; ++i) {
			sum = 0;
			for (j = 0; j < Neuron1; ++j) {
				sum += Y1[j] * v2[i][j];
			}
			Y2[i] = 1 / (1 + exp(-1 * sum));
		}
		for (i = 0; i < Out; ++i) {
			sum = 0;
			for (j = 0; j < Neuron2; ++j) {
				sum += Y2[j] * w[i][j];
			}
			pre[k][i] = (double)1 / (1 + exp(-1 * sum)) * (Maxout[i] - Minout[i]) + Minout[i];	//计算预测值
			printf("编号:%d  \t预测值:%lf   实际值:%lf\n", k + 1, pre[k][i], t_out[k][i]);		//预测值与实际值比较
		}
	}
	rmse = 0.0;
	for (k = 0; k < TestData; ++k) {
		for (i = 0; i < Out; ++i) {
			rmse += (pre[k][i] - t_out[k][i]) * (pre[k][i] - t_out[k][i]);
		}
	}
	rmse = sqrt(rmse / TestData / Out);		//均方根误差
	printf("\nrmse: %.4lf\n", rmse);
}
int main() {
	ReadData();
	InitBPNetwork();
	TrainNetwork();
	TestNetwork();
	return 0;
}

运行截图

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

由于最后得到的均方误差过大，怀疑可能是过度拟合的情况，把训练结束的条件改为mse>10,得到结果如下，进一步证明。
在这里插入图片描述
在这里插入图片描述

Kinano
关注
DL练习1：基于boston_house_prices的BP神经网络
m0_37957160的博客
05-09 488
基于波士顿房价的预测的BP神经网络 在Pycharm上测试可以跑的通。 # -*- coding: utf-8 -*- # Import libraries necessary for this project # 载入此项目所需要的库 import numpy as np import pandas as pd # 双曲正切函数,该函数为奇函数 def tanh(x): #numpy.exp()：返回e的幂次方 e_p = np.exp(x) e_m = np.exp(-
基于神经网络的深度学习模型：深度玻尔兹曼机DBN网络基本概念和工作原理
最新发布
AI天才研究院
08-04 1203
随着深度学习的火热以及模型复杂度的提升，基于神经网络的深度学习模型逐渐受到越来越多学者的关注。而深度玻尔兹曼机(Deep Boltzmann Machines,DBMs)就属于这一类代表性模型。DBM是一种无监督、非生成模型，可以用来模拟数据生成过程并进行预测分析，其优点在于参数个数少、训练速度快、预测能力强。虽然DBM具有很高的拟合能力，但对于给定数据的预测能力不足。在实际应用中，人们需要对DBM的输出结果做进一步处理，比如将概率转换为决策或者学习到的特征表示进行降维或聚类等。
房价预测的BP神经网络实现_python代码
08-29
波士顿房价预测的BP神经网络实现 1) 训练数据 housing.csv 使用波士顿房价数据 2) 使用Python代码实现前向和后向传播 3) 损失函数使用方差
tensorflow BP神经网络 波士顿房价预测
qq_41663800的博客
12-30 6699
前言 啥也别说了，上代码 code # 根据波士顿房价信息进行预测，多元线性回归 + 特征数据归一化 + 可视化 + TensorBoard可视化 #读取数据 from sklearn.metrics import mean_squared_error #均方误差 from sklearn.metrics import mean_absolute_error #平方绝对误差 from sklear...
波士顿房价预测数据集
12-06
对波士顿房价数据进行了预处理，满足收看网易云课堂以房价预测案例为例介绍神经网络中的BP算法的代码复现需求
波士顿房屋价格预测
06-02
这是一个波士顿房屋价格预测，包含了我做的作答，仅供参考
BP神经网络用于波士顿房屋数据集上预测
qq_21905401的博客
09-06 9269
一、BP神经网络的matlab工具箱 1.1、 BP神经网络创建函数 自R2010b版本以后，matlab神经网络工具箱对BP网络的创建函数进行了更新，更新后的函数如下： net = feedforwardnet(hiddenSizes,trainFcn) 参数说明：     hiddenSizes：为一个行向量，表征一个或多个隐藏层所包含的神经元个数（默认为10，即
BP神经网络预测RMSProp算法：高效处理稀疏梯度
BP神经网络（Back Propagation Neural Network）是一种多层前馈神经网络，由输入层、隐含层和输出层组成。其学习过程包括正向传播和反向传播两个阶段。正向传播中，输入数据从输入层逐层向输出层传递，并在输出层...
基于MATLAB的遗传算法优化的神经网络房价预测实战（附完整代码）
热门推荐
weixin_43788358的博客
01-24 2万+
本文利用BP神经网络对美国波士顿的房价进行预测，并针对BP神经网络存在的易陷入局部极小值，收敛速度慢，网络拓扑结构不稳定等问题，提出运用GA遗传算法对BP神经网络的初始权值和阈值进行优化。分别对传统神经网络和GA_BP进行训练和仿真，结果表明，经遗传算法优化后的神经网络可以加快网络收敛速度，提高预测房价的精度。 概述 随着房地产市场行业快速迅猛的发展，人们越来越关注放价的走势。从宏观上来看，影响...
机器学习的实验
qq_56751933的博客
08-21 4080
目录 BP神经网络预测波士顿房价 1.神经网络基本概念 1.1概念 1.2发展 CNN RNN GAN 2.神经网络基本框架 2.1单元/神经元 2.2 连接/权重/参数 2.3偏置项 2.4超参数 2.5激活函数 2.6层 3.神经网络算法 4.算法方案 5.实验 6.参考文献 BP神经网络预测波士顿房价 1.神经网络基本概念 1.1概念 神经网络是一种运算模型，由大量的...
matlab实现的两层隐含层BP神经网络
01-18
两层隐含层BP神经网络，梯度下降法，反向权值更新
预测波士顿房价
01-08
在这个项目中，你将利用马萨诸塞州波士顿郊区的房屋信息数据训练和测试一个模型，并对模型的性能和预测能力进行测试。通过该数据训练后的好的模型可以被用来对房屋做特定预测—尤其是对房屋的价值。对于房地产经纪等人的日常工作来说，这样的预测模型被证明非常有价值。
波斯顿房价预测数据集
03-24
包含13个特征：CRIM, ZN ,INDUS ,CHAS,NOX,RM,AGE,DIS,RAD,TAX,PTRATIO,LSTAT,MEDV，csv格式
波士顿房价预测数据集-数据集
03-29
Tensorflow波士顿房价预测学习记录
12-21
Tensorflow波士顿房价预测学习记录 第一.导入需要的库 import numpy as np import matplotlib.pyplot as plt import tensorflow as tf numpy数组用来初始化（后文） matplotlib用来画图，可以更加明显的突出数据的变化 第二.加载波士顿地价 介绍 波士顿房价数据集是统计的20世纪70年代中期波士顿郊区房价的中位数，统计了当时教区部分的犯罪率、房产税等共计13个指标，统计出房价，试图能找到那些指标与房价的关系。本例子明显的是属于回归模型的案例。在数据集中包含506组数据，其中404是训练样本，剩下的102组
深度学习入门——波士顿房价预测
Barbara‘s Blog
04-21 2万+
基于神经网络模型的波士顿房价预测 波士顿房价预测是一个经典的机器学习任务，类似于程序员世界的“Hello World”。以“波士顿房价预测”任务为例，我们学习如何使用Python语言和Numpy库来构建神经网络模型。 波士顿地区的房价受诸多因素影响。该数据集统计了13种可能影响房价的因素和该类型房屋的均价，期望构建一个基于13个因素进行房价预测的模型，如下所示。 对于预测问题，可以根据预测输出的类型是连续的实数值，还是离散的标签，区分为回归任务和分类任务。因为房价是一个连续值，所以房价预测是一个回归任务。
神经网络模型-波士顿房价预测
zyb的博客
12-01 675
数据拆分 数据归一化 模型设计 模型的损失与优化 训练过程 采用均方误差，求导不是一个常量，可以看到下降趋势 梯度下降 特征尺度归一的另外原因是为了统一步长(学习率) ...
BP神经网络波士顿房价预测
qq_44479403的博客
11-21 6611
数据集存在表格中 导入数据库 import numpy as np import tensorflow as tf from sklearn.model_selection import train_test_split import matplotlib.pyplot as plt 数据集预处理 data_X = [] data_Y = [] with open('boston_house_...
构建波士顿房价预测任务的神经网络模型
Bruce_zfh的博客
05-29 660
从本地或URL读取数据，并完成预处理操作（如数据校验，格式转化等），保证模型可读性。：网络结构设计，相当于模型的假设空间，即模型能够表达的关系的集合。：设定模型采用的寻解算法，即优化器，并指定计算资源。：循环调用训练过程，每轮都包括前向计算，损失函数（优化目标）和后向传播三个步骤。：将训练好的模型保存，模型预测时调用。正是由于深度学习的建模和训练过程存在通用性，在构建不同的模型时，只有模型的三要素不同，其他步骤基本一致。下面，将会按照步骤进行讲解。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值