波士顿房价预测的TensorFlow实现(多元线性回归)

import tensorflow as tf
import numpy as np
import pandas as pd
from sklearn.utils import shuffle
from sklearn.preprocessing import scale
import matplotlib.pyplot as plt%matplotlib inline

获取数据和查看数据

#读取数据
df = pd.read_csv('F:/学习资源/tensorflow/data/boston.csv',header=0)
df.describe()

	CRIM	ZN	INDUS	CHAS	NOX	RM	AGE	DIS	RAD	TAX	PTRATIO	LSTAT	MEDV
count	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000	506.000000
mean	3.613524	11.363636	11.136779	0.069170	0.554695	6.284634	68.574901	3.795043	9.549407	408.237154	18.455534	12.653063	22.532806
std	8.601545	23.322453	6.860353	0.253994	0.115878	0.702617	28.148861	2.105710	8.707259	168.537116	2.164946	7.141062	9.197104
min	0.006320	0.000000	0.460000	0.000000	0.385000	3.561000	2.900000	1.129600	1.000000	187.000000	12.600000	1.730000	5.000000
25%	0.082045	0.000000	5.190000	0.000000	0.449000	5.885500	45.025000	2.100175	4.000000	279.000000	17.400000	6.950000	17.025000
50%	0.256510	0.000000	9.690000	0.000000	0.538000	6.208500	77.500000	3.207450	5.000000	330.000000	19.050000	11.360000	21.200000
75%	3.677082	12.500000	18.100000	0.000000	0.624000	6.623500	94.075000	5.188425	24.000000	666.000000	20.200000	16.955000	25.000000
max	88.976200	100.000000	27.740000	1.000000	0.871000	8.780000	100.000000	12.126500	24.000000	711.000000	22.000000	37.970000	50.000000

CRIM:城镇人均犯罪率
ZN:住宅用地超过25000 sq.ft.的比例
INDUS:城镇非零售商用土地的比例
CHAS:边界是河流为1,否则0
NOX: 一氧化氮浓度
RM:住宅平均房间数
AGE: 1940年之前建成的自用房屋比例
DIS:到波士顿5个中心区域的加权距离
RAD:辐射性公路的靠近指数
TAX:每10000美元的全值财产税率
PTRATIO:城镇师生比例
LSTAT:人口中地位低下者的比例
MEDV:自住房的平均房价，单位:千美元

归一化的必要性

df.decribe()中，12个特征值范围大小相差不一，有些相差很大，

12个特征好比：杭州笋干老鸭汤（原材料的配比：鸭、火腿、笋干、青菜、水、盐、酱油、葱、姜、蒜、胡椒粉…）

如果这12个特征搭配的比例不好，那么这道菜就会不好吃

一样的道理，这12个特征的数据差异不一，如果不进行处理，会在下面优化的时候会出现训练结果异常，（train_loss=nan,valid_loss=nan）

对此，我们需要对数据进行归一化处理

归一化 = (特征值 - 特征值最小值) / (特征值最大值 - 特征值最小值）（使得数据在0-1之间）
在获取了12个特征数据后就可以对其进行归一化

for i in range(12): x_data[:,i]=(x_data[:,i]-x_data[:,i].min()) / (x_data[:,i].max()-x_data[:,i].min())

在sklearn.preprocessing里提供了scale()方法可以直接应用。在scale()里执行的转换公式如下面公式所示:
xi′=xi−mean(x)std(x)x_i'=\frac{x_i-mean(x)}{std(x)}xi′=std(x)xi−mean(x)
将下面数据类型转换代码改为：
x_train = tf.cast(scale(x_train), dtype = tf.float32) x_valid = tf.cast(scale(x_valid), dtype = tf.float32) x_test = tf.cast(scale(x_test), dtype = tf.float32)

ds = df.values #数据集以数组形式输出
ds

输出：
array([[6.3200e-03, 1.8000e+01, 2.3100e+00, ..., 1.5300e+01, 4.9800e+00,2.4000e+01],[2.7310e-02, 0.0000e+00, 7.0700e+00, ..., 1.7800e+01, 9.1400e+00,2.1600e+01],[2.7290e-02, 0.0000e+00, 7.0700e+00, ..., 1.7800e+01, 4.0300e+00,3.4700e+01],...,[6.0760e-02, 0.0000e+00, 1.1930e+01, ..., 2.1000e+01, 5.6400e+00,2.3900e+01],[1.0959e-01, 0.0000e+00, 1.1930e+01, ..., 2.1000e+01, 6.4800e+00,2.2000e+01],[4.7410e-02, 0.0000e+00, 1.1930e+01, ..., 2.1000e+01, 7.8800e+00,1.1900e+01]])

df.shape

输出：
(506, 13)

#从df.shape得该数据有12个特征数据，1个标签数据
## 数据归一化前的前12列特征数据
x_data = ds[:,:12] ## 数据归一化前的最后1列标签数据
y_data = ds[:,12]print('x_data shape=',x_data.shape)
print('y_data shape=',y_data.shape)

输出：
x_data shape= (506, 12)
y_data shape= (506,)

#归一化 = (特征值 - 特征值最小值) / (特征值最大值 - 特征值最小值）
'''for i in range(12):x_data[:,i]=(x_data[:,i]-x_data[:,i].min()) / (x_data[:,i].max()-x_data[:,i].min())
'''

划分数据集

1）构建和训练机器学习模型是希望对新的数据做出良好预测

如何去保证训练的实效，可以应对以前未见过的数据呢？

一种方法是将数据集分成两个子集：

训练集 - 用于训练模型的子集

测试集 - 用于测试模型的子集
通常，在测试集上表现是否良好是衡量能否在新数据上表现良好的有用指标，前提是：

测试集足够大(规模足够大，可产生具有统计意义的结果)

不会反复使用相同的测试集来作假(能代表整个数据集，测试集的特征应该与训练集的特征相同)

2)这种划分方法存在着问题：多次重复执行该流程可能导致模型不知不觉地拟合了特定测试集的特性，对此可以使用以下的这种划分方式

训练集 - 用于训练模型的子集

验证集 - 用于验证模型的子集

测试集 - 用于测试模型的子集
通过将数据集划分为三个子集，可以大幅降低过拟合的发生几率

#数据集数目的划分(训练集-验证集-测试集)
train_num = 300 #训练集的数目
valid_num = 100 #测试集的数目
test_num = len(x_data) - train_num - valid_num #测试集的数目#训练集划分
x_train = x_data[:train_num]
y_train = y_data[:train_num]#验证集划分
x_valid = x_data[train_num:train_num + valid_num]
y_valid = y_data[train_num:train_num + valid_num]#测试集划分
x_test = x_data[train_num + valid_num:train_num + valid_num + test_num]
y_test = y_data[train_num + valid_num:train_num + valid_num + test_num]

#数据类型转换为float32
#x_train = tf.cast(x_train, dtype = tf.float32)
#x_valid = tf.cast(x_valid, dtype = tf.float32)
#x_test = tf.cast(x_test, dtype = tf.float32)
x_train = tf.cast(scale(x_train), dtype = tf.float32)
x_valid = tf.cast(scale(x_valid), dtype = tf.float32)
x_test = tf.cast(scale(x_test), dtype = tf.float32)

构建模型

def model(x,w,b):return tf.matmul(x,w) + b

#创建待优化变量
##构建模型中的变量w，对应线性函数的斜率
w = tf.Variable(tf.random.normal([12,1],mean=0.0,stddev=1.0,dtype = tf.float32))
##构建模型中的变量b，对应线性函数的截距
b = tf.Variable(tf.zeros(1),tf.float32)
print(w)
print(b)

输出：：
<tf.Variable 'Variable:0' shape=(12, 1) dtype=float32, numpy=
array([[-1.1732008 ],[-0.5502269 ],[ 0.31437123],[-0.08397377],[ 0.19697414],[ 1.4187226 ],[ 1.2413857 ],[-0.06344446],[ 0.900218  ],[ 0.9474691 ],[-0.73457223],[ 0.21238331]], dtype=float32)>
<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([0.], dtype=float32)>

#定义损失函数---均方差MSE
def loss(x,y,w,b):err = model(x,w,b)-y  #预测值与真实值的差值squared_err = tf.square(err) #求平方，得出方差return tf.reduce_mean(squared_err) #求均值，得出均方差

#训练模型,使用MBGD（小批量梯度下降算法）进行优化
## 设置训练超参数
training_epochs = 50 #迭代次数
learning_rate = 0.001 #学习率
batch_size = 10 #批量训练一次的样本数

## 计算梯度函数
def grad(x,y,w,b): #计算样本数据（x，y）在参数[w,b]点上的梯度with tf.GradientTape() as tape: #上下文管理器封装需要求导的计算步骤，并使用其 gradient() 方法求导loss_ = loss(x,y,w,b)return tape.gradient(loss_,[w,b])  #返回梯度向量（求导）

选择优化器

使用tf.keras.optimizers.SGD()声明了一个梯度下降优化器（Optimizer），其学习率通过参数指定。

优化器可以帮助根据计算出的求导结果更新模型参数，从而最小化损失函数，具体使用方式是调用其apply_gradients()方法。

optimizer = tf.keras.optimizers.SGD(learning_rate) #创建优化器指定学习率

loss_list_train = []    #用于保存训练集的loss值的列表
loss_list_valid = []    #用于保存验证集的loss值的列表
total_step = int(train_num/batch_size)
for epoch in range(training_epochs):for step in range(total_step):xs = x_train[step*batch_size:(step+1)*batch_size,:]ys = y_train[step*batch_size:(step+1)*batch_size]grads = grad(xs,ys,w,b)optimizer.apply_gradients(zip(grads,[w,b])) # 优化器根据梯度自动调整w和bloss_train = loss(x_train, y_train, w, b).numpy()loss_valid = loss(x_valid, y_valid, w, b).numpy()loss_list_train.append(loss_train)loss_list_valid.append(loss_valid)print("epoch={:3d},train_loss={:.4f},valid_loss={:.4f}".format(epoch+1,loss_train,loss_valid))

输出：
epoch=  1,train_loss=660.1863,valid_loss=464.3738
epoch=  2,train_loss=595.7922,valid_loss=411.7638
epoch=  3,train_loss=539.5142,valid_loss=367.2811
epoch=  4,train_loss=489.9636,valid_loss=329.2233
epoch=  5,train_loss=446.1474,valid_loss=296.4343
epoch=  6,train_loss=407.3090,valid_loss=268.0826
epoch=  7,train_loss=372.8414,valid_loss=243.5360
epoch=  8,train_loss=342.2372,valid_loss=222.2891
epoch=  9,train_loss=315.0607,valid_loss=203.9230
epoch= 10,train_loss=290.9305,valid_loss=188.0809
epoch= 11,train_loss=269.5101,valid_loss=174.4536
epoch= 12,train_loss=250.5001,valid_loss=162.7705
epoch= 13,train_loss=233.6337,valid_loss=152.7927
epoch= 14,train_loss=218.6730,valid_loss=144.3094
epoch= 15,train_loss=205.4058,valid_loss=137.1337
epoch= 16,train_loss=193.6427,valid_loss=131.1004
epoch= 17,train_loss=183.2151,valid_loss=126.0633
epoch= 18,train_loss=173.9728,valid_loss=121.8930
epoch= 19,train_loss=165.7821,valid_loss=118.4753
epoch= 20,train_loss=158.5241,valid_loss=115.7098
epoch= 21,train_loss=152.0932,valid_loss=113.5078
epoch= 22,train_loss=146.3957,valid_loss=111.7913
epoch= 23,train_loss=141.3482,valid_loss=110.4920
epoch= 24,train_loss=136.8768,valid_loss=109.5499
epoch= 25,train_loss=132.9160,valid_loss=108.9124
epoch= 26,train_loss=129.4076,valid_loss=108.5337
epoch= 27,train_loss=126.3000,valid_loss=108.3735
epoch= 28,train_loss=123.5476,valid_loss=108.3971
epoch= 29,train_loss=121.1100,valid_loss=108.5739
epoch= 30,train_loss=118.9510,valid_loss=108.8776
epoch= 31,train_loss=117.0389,valid_loss=109.2853
epoch= 32,train_loss=115.3456,valid_loss=109.7773
epoch= 33,train_loss=113.8461,valid_loss=110.3364
epoch= 34,train_loss=112.5182,valid_loss=110.9479
epoch= 35,train_loss=111.3425,valid_loss=111.5992
epoch= 36,train_loss=110.3015,valid_loss=112.2796
epoch= 37,train_loss=109.3798,valid_loss=112.9799
epoch= 38,train_loss=108.5638,valid_loss=113.6922
epoch= 39,train_loss=107.8415,valid_loss=114.4100
epoch= 40,train_loss=107.2022,valid_loss=115.1278
epoch= 41,train_loss=106.6364,valid_loss=115.8409
epoch= 42,train_loss=106.1358,valid_loss=116.5455
epoch= 43,train_loss=105.6928,valid_loss=117.2385
epoch= 44,train_loss=105.3010,valid_loss=117.9175
epoch= 45,train_loss=104.9545,valid_loss=118.5803
epoch= 46,train_loss=104.6482,valid_loss=119.2254
epoch= 47,train_loss=104.3774,valid_loss=119.8517
epoch= 48,train_loss=104.1381,valid_loss=120.4582
epoch= 49,train_loss=103.9268,valid_loss=121.0444
epoch= 50,train_loss=103.7402,valid_loss=121.6099

plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(loss_list_train,'b',label='Train Loss')
plt.plot(loss_list_valid,'r',label='Valid Loss')
plt.legend(loc=1)

<matplotlib.legend.Legend at 0x2420abb1b70>

print("Test_loss:{:.4f}".format(loss(x_test,y_test,w,b).numpy()))

输出：
Test_loss:113.9060

模型应用

test_house_id = np.random.randint(0,test_num)
y = y_test[test_house_id]
y_pred = model(x_test,w,b)[test_house_id]
y_predit = tf.reshape(y_pred,()).numpy()
print("House id",test_house_id,"Actual value",y,"Predited value",y_predit)

输出：
House id 26 Actual value 10.2 Predited value 24.10615

波士顿房价预测的TensorFlow实现(多元线性回归)相关推荐

MOOC网深度学习应用开发1——Tensorflow基础、多元线性回归:波士顿房价预测问题Tensorflow实战、MNIST手写数字识别：分类应用入门、泰坦尼克生存预测
Tensorflow基础 tensor基础当数据类型不同时,程序做相加等运算会报错,可以通过隐式转换的方式避免此类报错. 单变量线性回归监督式机器学习的基本术语线性回归的Tensorflow实战 ...
机器学习（11）线性回归（2）实战 -- 正规方程优化、梯度下降优化（波士顿房价预测）
目录一.波士顿房价预测(正规方程优化) API 1.获取数据集 2.划分数据集 3.标准化 4. 创建预估器,得到模型 5.模型评估(均方差评估) 代码二.波士顿房价预测(正规方程优化) API ...
线性回归之案例：波士顿房价预测
线性回归之案例:波士顿房价预测数据介绍 [13个特征值,1个目标值] 给定的这些特征,是专家们得出的影响房价的结果属性.此阶段不需要自己去探究特征是否有用,只需要使用这些特征.到后面量化很多特征 ...
使用线性回归实现波士顿房价预测
使用线性回归实现波士顿房价预测本文不进行线性回归基础知识讲解,只提供三种方法对波士顿房价进行预测,这三种方法分别是: 1.使用正规方程的优化方法对波士顿房价进行预测 2.使用梯度下降的优化方法对波士 ...
机器学习入门实践——线性回归模型（波士顿房价预测）
机器学习入门实践--线性回归模型(波士顿房价预测) 一.背景介绍给定一个大小为 n n n的数据集 { y i , x i 1 , . . . , x i d } i = 1 n {\{y_{i}, ...
线性回归算法从认知到实战内含波士顿房价预测案例
文章目录 2.1 线性回归简介学习目标 1 线性回归应用场景 2 什么是线性回归 2.1 定义与公式 2.2 线性回归的特征与目标的关系分析 3 小结 2.2 线性回归api初步使用学习目标 1 ...
机器学习线性回归实践，波士顿房价预测，手写梯度下降
波士顿房价预测,手写梯度下降,python实现数据集介绍每条数据包含房屋以及房屋周围的详细信息.其中包含城镇犯罪率,一氧化氮浓度,住宅平均房间数,到中心区域的加权距离以及自住房平均房价等等. CR ...
Tensorflow实现多元线性回归
上一篇使用tensorflow实现了简单的线性回归,这次在简单的线性回归基础上,通过在权重和占位符声明中修改来对相同的数据进行多元线性回归. 同样以波士顿房价数据为例波士顿房价数据集可从http: ...
波士顿房价预测（TensorFlow2.9实践）
波士顿房价预测(TensorFlow2.9实践) 波士顿房价数据集包括506个样本,每个样本包括12个特征变量和该地区的平均房价.房价(单价)显然和多个特征变量相关,不是单变量线性回归(一元线性回归) ...

波士顿房价预测的TensorFlow实现(多元线性回归)

获取数据和查看数据

归一化的必要性

划分数据集

构建模型

选择优化器

模型应用

波士顿房价预测的TensorFlow实现(多元线性回归)相关推荐

最新文章

热门文章