0
0

波士顿房价预测——机器学习入门级案例

一、数据处理

1.1 数据集介绍

本实验使用波士顿房价预测数据集，共506条样本数据，每条样本包含了13种可能影响房价的因素和该类房屋价格的中位数，各字段含义如下表所示：
字段名类型含义CRIMfloat该镇的人均犯罪率ZNfloat占地面积超过25,000平方呎的住宅用地比例INDUSfloat非零售商业用地比例CHASint是否邻近 Charles River 1=邻近；0=不邻近NOXfloat一氧化氮浓度RMfloat每栋房屋的平均客房数AGEfloat1940年之前建成的自用单位比例DISfloat到波士顿5个就业中心的加权距离RADint到径向公路的可达性指数TAXint全值财产税率PTRATIOfloat学生与教师的比例Bfloat1000(BK-0.63)^2，其中BK是城镇中黑人的比例LSTATfloat低收入人群占比MEDVfloat同类房屋价格的中位数
数据集下载地址：https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data

1.2 数据导入

（1）波士顿房价预测数据集存储在文本文件中的数据格式为下图所示：
在这里插入图片描述
其中的X就是数据集介绍中的CRIM-LSTAT部分，而Y就是MEDV，即同类房屋价格的中位数，也就是我们后面要预测的值。

（2）使用Numpy从文件导入数据np.fromfile

# 导入需要用到的packageimport numpy as np
import json
# 读入训练数据
datafile ='housing.data'
data = np.fromfile(datafile, sep=' ')

导入结果：
在这里插入图片描述
注释： np.tofile和np.fromfile可以实现数组写到磁盘文件中

print(data.shape)# 输出(7084,)

我们可以发现，我们进行上述代码操作以后，将文件中的数据集生成了一个一维的数组，通过打印data.shape可以发现这个一维数组的长度为7084。
细心的朋友不难发现，7084不就是506 x 14以后的结果吗~

没错，在这时候我们就需要重新将data数据重新处理一下，用reshape()方法将其处理为(506, 14)的二维数组。

# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数
feature_names =['CRIM','ZN','INDUS','CHAS','NOX','RM','AGE','DIS','RAD','TAX','PTRATIO','B','LSTAT','MEDV']
feature_num =len(feature_names)# 将原始数据进行reshape, 变为[N, 14]这样的形状
data = data.reshape([data.shape[0]// feature_num, feature_num])print(data.shape)# 输出(506, 14)# 查看数据
X = data[0]print(X.shape)print(X)# 输出#(14,)# [6.320e-03 1.800e+01 2.310e+00 0.000e+00 5.380e-01 6.575e+00 6.520e+01# 4.090e+00 1.000e+00 2.960e+02 1.530e+01 3.969e+02 4.980e+00 2.400e+01]

由此可以看出每条数据是一个长度为14的一维数组，前13项是影响房价的因素，最后一项是房价。

1.3 数据集划分

在机器学习和深度学习过程中，往往要将数据集划分为训练集和测试集两部分，训练集用来进行训练，一般会取数据集的80%-90%，而测试集用来对训练好的模型性能进行评估，一般只取少量数据集，大概为10%左右。

ratio =0.8
offset =int(data.shape[0]* ratio)
train_data = data[:offset]
test_data = data[offset:]print(train_data.shape)print(test_data.shape)# 输出:# (404, 14)# (102, 14)

波士顿房价预测数据集中原有数据集为506行，经过划分以后，训练集为原来的80%，即404，测试集为原来的20%，即102。

1.4 归一化处理

对特征取值范围进行归一化，有两个好处：

  • 特征训练更高效
  • 特征前的权重大小可代表该变量对预测结果的贡献度

注意：预测时，样本数据同样也需要归一化，以训练样本的均值和极值计算

# 计算train数据集的最大值、最小值和平均值
maxinums, mininums, avgs = data_slice.max(axis=0), data_slice.min(axis=0), data_slice.sum(axis=0)/ data_slice.shape[0]# 对数据进行归一化处理for i inrange(feature_num):# print(maxinums[i], mininums[i], avgs[i])
    data[:, i]=(data[:, i]- avgs[i])/(maxinums[i]- mininums[i])

1.5 将完整代码封装成load_data函数

defload_data():# 从文件导入数据
    datafile ='housing.data'
    data = np.fromfile(datafile, sep=' ')print(data.shape)# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数
    feature_names =['CRIM','ZN','INDUS','CHAS','NOX','RM','AGE','DIS','RAD','TAX','PTRATIO','B','LSTAT','MEDV']
    feature_num =len(feature_names)# 将原始数据进行reshape, 变为[N, 14]这样的形状
    data = data.reshape([data.shape[0]// feature_num, feature_num])print(data.shape)
    X = data[0]print(X.shape)print(X)# 将原数据集拆分成训练集和测试集# 这里使用80%的数据做训练，20%的数据做测试# 测试集和训练集必须是没有交集的
    ratio =0.8
    offset =int(data.shape[0]* ratio)
    data_slice = data[:offset]# 计算train数据集的最大值、最小值和平均值
    maxinums, mininums, avgs = data_slice.max(axis=0), data_slice.min(axis=0), data_slice.sum(axis=0)/ data_slice.shape[0]# 对数据进行归一化处理for i inrange(feature_num):# print(maxinums[i], mininums[i], avgs[i])
        data[:, i]=(data[:, i]- avgs[i])/(maxinums[i]- mininums[i])# 训练集和测试集的划分比例# ratio = 0.8
    train_data = data[:offset]
    test_data = data[offset:]return train_data, test_data

1.6 获取数据

# 获取数据
train_data, test_data = load_data()print(train_data.shape)
x = train_data[:,:-1]
y = train_data[:,-1:]print(x[0])print(y[0])#[-0.02146321  0.03767327 -0.28552309 -0.08663366  0.01289726  0.04634817#  0.00795597 -0.00765794 -0.25172191 -0.11881188 -0.29002528  0.0519112# -0.17590923]#[-0.00390539]

二、设计模型

波士顿房价预测案例是一个非常典型的线性回归问题。

2.1 前向计算

输入x一共有13个变量，y只有1个变量，所以权重w的shape是[13, 1]

  • w可以任意赋初值如下
w =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,-0.1,-0.2,-0.3,-0.4,0.0]
w = np.array(w).reshape([13,1])
  • 取出第1条样本数据，观察它与w相乘之后的结果
x1 = X[0]
t = np.dot(x1, w)print(t)# 输出：[0.03395597]
  • 另外还需要初始化权重b，这里我们给它赋值-0.2观察输出
b =-0.2
z = t + b
print(z)# 输出 [-0.16604403]

2.2 以类的方式实现网络结果（前向计算）

  1. 使用时可以生成多个模型示例
  2. 类成员变量有w和b，在类初始化函数时初始化变量（w随机初始化，b = 0）
  3. 函数成员forward 完成从输入特征x到输出z的计算过程（即前向计算）
classNetWork(object):def__init__(self, num_of_weights):# 随机产生w的初始值# 为了保持程序每次运行结果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights,1)
        self.b =0defforward(self, x):
        z = np.dot(x, self.w)+ self.b

        return z

随机选取一个样本测试下效果

net = NetWork(13)
x1 = x[0]
y1 = y[0]
z = net.forward(x1)print(z)# 输出 [-0.63182506]

此时我们可以看出，现阶段搭建的模型只有一个花架子，并不具备预测的能力，所以还需改进。

三、模型的损失与优化

3.1 模型好坏的衡量指标——损失函数（loss function）

在回归问题中均方误差是一种比较常见的形式，分类问题中通常会采用交叉熵损失函数，后续有机会再给大家讲解，咱们这篇文章主要讲解均方误差。
在这里插入图片描述

3.2 训练配置—同时计算多个样本的损失函数

在训练过程中，我们要计算所有样本的损失，而不是单个样本的损失。
在这里插入图片描述
在此过程中我们用到了Numpy的广播机制，便捷的实现多样本的计算
广播功能：像使用单一变量一样操作数组。

classNetWork(object):def__init__(self, num_of_weights):# 随机产生w的初始值# 为了保持程序每次运行结果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights,1)
        self.b =0defforward(self, x):
        z = np.dot(x, self.w)+ self.b

        return z

    defloss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)return cost

net = NetWork(13)
x1 = x[0:3]
y1 = y[0:3]
z = net.forward(x1)print('predict', z)
loss = net.loss(z, y1)print('loss', loss)# 输出 # predict [[-0.63182506]# [-0.55793096]# [-1.00062009]]# loss 0.7229825055441156

在这里插入图片描述
方案1：
我们在高中的时候就学习过，当一条曲线处于极值点的时候，斜率为0，即导数为0。那么我们就可以根据上图中的导数方程来求解出参数w和b的值，以此来达到损失函数极小值的目的。但是由于并不是所有的函数都是像均方误差这样可逆的，在我们进行机器学习或者深度学习的过程中，遇见最多的就是不可逆函数，不可逆函数简单举个例子就是有一个y=x的方程，我们可以根据y求导解出x，但是却不能根据x求导解出y。也就是说不能反过来求解，这就是不可逆函数。
方案2：
在这里插入图片描述
在梯度下降法中，根据上图我们可以理解为什么我们使用均方误差而不是绝对误差，我们可以看到，绝对值误差画出来的图像没有坡度，是不可微的，而均方误差画出的Loss函数图像可以看出是可微的，这样子就可以让我们在求解过程中更加的方便。
在这里插入图片描述
沿着梯度的反方向可以理解为沿着切线方向下降速度最快的方向，一般切线方向都是向上的，而反方向就是向下的方向。

四、梯度下降代码实现

4.1 训练过程—计算梯度的公式推导

在这里插入图片描述
我们在进行梯度公式的推导之前，引入了1/2的因子，这样做的目的仅仅是为了我们的推导过程更加的简洁，没有别的目的，而且这样做并不影响我们整体的推导过程。

4.1.1 训练过程—计算梯度的公式推导（一个样本）

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

4.1.2 训练过程—基于Numpy广播机制进行梯度计算（多个样本）

  • 基于Numpy的广播机制，扩展参数的维度在这里插入图片描述

4.1.3 训练过程—基于Numpy计算单个样本—>多个样本对梯度的贡献

  • 同样，基于Nupy的广播机制，扩展样本的维度

在这里插入图片描述

4.1.4 训练过程—计算所有样本对梯度的贡献，代码十分简洁

在这里插入图片描述

4.4.5 训练过程—所有样本对梯度的贡献取平均值

  • 参数的更新方向要考虑所有样本的“意见”，总的梯度是所有样本对梯度贡献的平均值在这里插入图片描述
  • 使用Numpy里面的矩阵操作来完成此过程：


因为后续每走一小步都要进行维度的相加，所以（13， ）要加上1维，变成（13，1），使得到梯度的维度和参数的维度一致，但是加上的1维相当于是虚的，因为13 x 1与13是一样的数字。

4.2 前向计算和后向传播的完整代码

  • 全流程的步骤 1.前向计算 2.拿到1（前向计算的结果），才能计算损失 3.拿到1和2，才能计算梯度 4.根据3，更新参数值

注意：其中第4步是反复循环进行的。

classNetWork(object):def__init__(self, num_of_weights):# 随机产生w的初始值# 为了保持程序每次运行结果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights,1)
        self.b =0defforward(self, x):
        z = np.dot(x, self.w)+ self.b

        return z

    defloss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)return cost

    defgradient(self, x, y):
        z = self.forward(x)
        gradient_w =(z - y)* x
        gradient_w = np.mean(gradient_w, axis=0)# axis=0表示把每一行做相加然后再除以总的行数
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b =(z - y)
        gradient_b = np.mean(gradient_b)# 此处b是一个数值，所以可以直接用np.mean得到一个标量（scalar）return gradient_w, gradient_b

    defupdate(self, gradient_w, gradient_b, eta=0.01):# eta代表学习率，是控制每次参数值变动的大小，即移动步长，又称为学习率
        self.w = self.w - eta * gradient_w                 # 相减: 参数向梯度的反方向移动
        self.b = self.b - eta * gradient_b

    deftrain(self, x, y, iterations=1000, eta=0.01):
        losses =[]for i inrange(iterations):# 四步法
            z = self.forward(x)# 前向计算
            L = self.loss(z, y)# 求误差
            gradient_w, gradient_b = self.gradient(x, y)# 求梯度
            self.update(gradient_w, gradient_b, eta)# 更新参数
            losses.append(L)if(i +1)%10==0:print('iter {}, loss {}'.format(i, L))return losses

五、完整代码

import numpy as np
from matplotlib import pyplot as plt

defload_data():# 从文件导入数据
    datafile ='housing.data'
    data = np.fromfile(datafile, sep=' ')print(data.shape)# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数
    feature_names =['CRIM','ZN','INDUS','CHAS','NOX','RM','AGE','DIS','RAD','TAX','PTRATIO','B','LSTAT','MEDV']
    feature_num =len(feature_names)# 将原始数据进行reshape, 变为[N, 14]这样的形状
    data = data.reshape([data.shape[0]// feature_num, feature_num])print(data.shape)# 将原数据集拆分成训练集和测试集# 这里使用80%的数据做训练，20%的数据做测试# 测试集和训练集必须是没有交集的
    ratio =0.8
    offset =int(data.shape[0]* ratio)
    data_slice = data[:offset]# 计算train数据集的最大值、最小值和平均值
    maxinums, mininums, avgs = data_slice.max(axis=0), data_slice.min(axis=0), data_slice.sum(axis=0)/ data_slice.shape[0]# 对数据进行归一化处理for i inrange(feature_num):# print(maxinums[i], mininums[i], avgs[i])
        data[:, i]=(data[:, i]- avgs[i])/(maxinums[i]- mininums[i])# 训练集和测试集的划分比例# ratio = 0.8
    train_data = data[:offset]
    test_data = data[offset:]return train_data, test_data

classNetWork(object):def__init__(self, num_of_weights):# 随机产生w的初始值# 为了保持程序每次运行结果的一致性，此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights,1)
        self.b =0defforward(self, x):
        z = np.dot(x, self.w)+ self.b

        return z

    defloss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)return cost

    defgradient(self, x, y):
        z = self.forward(x)
        gradient_w =(z - y)* x
        gradient_w = np.mean(gradient_w, axis=0)# axis=0表示把每一行做相加然后再除以总的行数
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b =(z - y)
        gradient_b = np.mean(gradient_b)# 此处b是一个数值，所以可以直接用np.mean得到一个标量（scalar）return gradient_w, gradient_b

    defupdate(self, gradient_w, gradient_b, eta=0.01):# eta代表学习率，是控制每次参数值变动的大小，即移动步长，又称为学习率
        self.w = self.w - eta * gradient_w                 # 相减: 参数向梯度的反方向移动
        self.b = self.b - eta * gradient_b

    deftrain(self, x, y, iterations=1000, eta=0.01):
        losses =[]for i inrange(iterations):# 四步法
            z = self.forward(x)
            L = self.loss(z, y)
            gradient_w, gradient_b = self.gradient(x, y)
            self.update(gradient_w, gradient_b, eta)
            losses.append(L)if(i +1)%10==0:print('iter {}, loss {}'.format(i, L))return losses

# 获取数据
train_data, test_data = load_data()print(train_data.shape)
x = train_data[:,:-1]
y = train_data[:,-1:]# 创建网络
net = NetWork(13)
num_iterations =2000# 启动训练
losses = net.train(x, y, iterations=num_iterations, eta=0.01)# 画出损失函数的变化趋势
plot_x = np.arange(num_iterations)
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

训练结果：
在这里插入图片描述

标签： python 人工智能
本文转载自: https://blog.csdn.net/m0_63007797/article/details/128632848
版权归原作者 心无旁骛~ 所有， 如有侵权，请联系我们删除。
登录后发布评论

“波士顿房价预测——机器学习入门级案例”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

ArkTS的进阶语法-1(泛型,工具类型,空安全)

springboot第83集：理解SaaS多租户应用的架构和设计，设备介入，网关设备，安全，实时实现，序列化...

【Linux】进程的生命之旅——诞生、消逝与守候（fork/exit/wait）

【自动化测试_selenium】浏览器驱动汇总

避免 Git 提交混淆：如何管理用户信息和配置

Hadoop3.x单机模式Local(Standalone)模式

前端速通（CSS）

文章导航