python 波士顿房价预测

这篇具有很好参考价值的文章主要介绍了python 波士顿房价预测。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

数据集地址:Index of /ml/machine-learning-databases/housing (uci.edu)

数据集中共有506条样本数据,每条样本包含了13个影响房价的特征。

数据集格式

0.00632  18.00   2.310  0  0.5380  6.5750  65.20  4.0900   1  296.0  15.30 396.90   4.98  24.00
0.02731   0.00   7.070  0  0.4690  6.4210  78.90  4.9671   2  242.0  17.80 396.90   9.14  21.60
0.02729   0.00   7.070  0  0.4690  7.1850  61.10  4.9671   2  242.0  17.80 392.83   4.03  34.70
0.03237   0.00   2.180  0  0.4580  6.9980  45.80  6.0622   3  222.0  18.70 394.63   2.94  33.40
0.06905   0.00   2.180  0  0.4580  7.1470  54.20  6.0622   3  222.0  18.70 396.90   5.33  36.20
0.02985   0.00   2.180  0  0.4580  6.4300  58.70  6.0622   3  222.0  18.70 394.12   5.21  28.70
0.08829  12.50   7.870  0  0.5240  6.0120  66.60  5.5605   5  311.0  15.20 395.60  12.43  22.90
0.14455  12.50   7.870  0  0.5240  6.1720  96.10  5.9505   5  311.0  15.20 396.90  19.15  27.10
0.21124  12.50   7.870  0  0.5240  5.6310 100.00  6.0821   5  311.0  15.20 386.63  29.93  16.50

数据读取

np.fromfile()  读取数据没有数据类型和数据的形状。所以这里使用了data.reshape()重新变换成原始的形状。

# 导入需要用到的package
import numpy as np
import json
# 读入训练数据
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)
# 输出(506, 14)

# 查看数据
X = data[0]
print(X.shape)
print(X)

(7084,)
(506, 14)
(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] 

 划分数据集

在机器学习中,数据集通常划分为训练集和测试集,训练集用于训练,测试集用来评估模型的性能。两者的比例大于是8:1

# 导入需要用到的package
import numpy as np
import json
# 读入训练数据
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)
# 输出(506, 14)

# 查看数据
X = data[0]
print(X.shape)
print(X)

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)

(7084,)
(506, 14)
(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]
训练集的大小 (404, 14)
测试集的大小 (102, 14)

数据归一化

# 导入需要用到的package
import numpy as np
import json
# 读入训练数据
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)
# 输出(506, 14)

# 查看数据
X = data[0]
print(X.shape)
print(X)

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)
print('归一化前的数据',train_data[0])
# 计算train数据集的最大值、最小值和平均值
maxinums, mininums, avgs = train_data.max(axis=0), train_data.min(axis=0), train_data.sum(axis=0) / train_data.shape[0]

# 对数据进行归一化处理
for i in range(feature_num):
    # print(maxinums[i], mininums[i], avgs[i])
    train_data[:, i] = (train_data[:, i] - avgs[i]) / (maxinums[i] - mininums[i])
print('归一化后的数据',train_data[0])

(7084,)
(506, 14)
(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]
训练集的大小 (404, 14)
测试集的大小 (102, 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]
归一化后的数据 [-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]

模型

import numpy as np
class NetWork(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性,此处设置了固定的随机数种子
        np.random.seed(0)
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0

    def forward(self, x):
        z = np.dot(x, self.w) + self.b

        return z

    def loss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)

        return cost

    def gradient(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

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

    def train(self, x, y, iterations=1000, eta=0.01):
        losses = []
        for i in range(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

if __name__=="__main__":
    #定义模型的输入
    input=np.random.randn(1000,13)  #表示有4个样本,每个样本有13个特征
    gt_output=np.random.randn(1000,1) ##真实的标签,后续进行损失计算
    #定义模型
    model=NetWork(13)
    print('模型的初始参数',model.w,model.b)
    for i in range(100):
        #模型的前线传播得到输出
        output=model.forward(input)
        #计算模型的损失
        loss=model.loss(output,gt_output)
        # print(loss)
        #求梯度
        w,b=model.gradient(input,output)
        print('第{}epoch参数'.format(i),model.w,model.b)
        #模型的更新
        model.update(w,b)

 

完整代码

import numpy as np
from matplotlib import pyplot as plt


def load_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 in range(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


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

    def forward(self, x):
        z = np.dot(x, self.w) + self.b

        return z

    def loss(self, z, y):
        error = z - y
        cost = error * error
        cost = np.mean(cost)

        return cost

    def gradient(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

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

    def train(self, x, y, iterations=1000, eta=0.01):
        losses = []
        for i in range(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()

 

 

 参考文献:

波士顿房价预测——机器学习入门级案例_心无旁骛~的博客-CSDN博客文章来源地址https://www.toymoban.com/news/detail-401866.html

到了这里,关于python 波士顿房价预测的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 机器学习 波士顿房价预测 Boston Housing

    目录 一:前言 二:模型预测(KNN算法) 三:回归模型预测比对 波士顿房价 是机器学习中很常用的一个 解决回归问题 的数据集 数据统计于1978年,包括506个房价样本,每个样本包括波士顿不同郊区房屋的13种特征信息, 比如:住宅房间数、城镇教师和学生比例等 标签值是每栋

    2024年02月03日
    浏览(43)
  • 机器学习---使用 TensorFlow 构建神经网络模型预测波士顿房价和鸢尾花数据集分类

    1. 预测波士顿房价 1.1 导包 最后一行设置了TensorFlow日志的详细程度: tf.logging.DEBUG :最详细的日志级别,用于记录调试信息。 tf.logging.INFO :用于记录一般的信息性消息,比如训练过程中的指标和进度。 tf.logging.WARN :用于记录警告消息,表示可能存在潜在问题,但不会导致

    2024年02月08日
    浏览(44)
  • 机器学习(三):基于线性回归对波士顿房价预测

    ✍ 作者简介: i阿极 ,CSDN Python领域新星创作者, 专注于分享python领域知识。 ✍ 本文录入于《机器学习案例》 ,本专栏精选了经典的机器学习算法进行讲解,针对大学生、初级数据分析工程师精心打造ÿ

    2023年04月25日
    浏览(49)
  • 【机器学习】P25 随机森林算法(2) 实现 “波士顿房价” 预测

    随机森林(Random Forest)算法 是一种 集成学习(Ensemble Learning)方法,它由多个决策树组成,是一种分类、回归和特征选择的机器学习算法。 在随机森林中,每个决策树都是独立地训练的,每棵树的建立都是基于随机选取的 特征子集 和随机选取的 训练样本集 。 在分类问题

    2024年02月01日
    浏览(51)
  • 机器学习与深度学习——使用paddle实现随机梯度下降算法SGD对波士顿房价数据进行线性回归和预测

    随机梯度下降(SGD)也称为增量梯度下降,是一种迭代方法,用于优化可微分目标函数。该方法通过在小批量数据上计算损失函数的梯度而迭代地更新权重与偏置项。SGD在高度非凸的损失表面上远远超越了朴素梯度下降法,这种简单的爬山法技术已经主导了现代的非凸优化。

    2024年02月03日
    浏览(54)
  • 计算机视觉学习笔记(二)---传统神经网络之波士顿房价预测

      本文承接pytorch学习笔记(一),以波士顿房价预测为例演示利用pytorch搭建一个简单的传统神经网络   数据集为波士顿房价数据,预测目标为MEDV(标签),其余变量均为特征。由于是csv格式可以直接采用pandas包下的read_csv读取   观察到在输入的数据中,有的特征普遍

    2024年02月04日
    浏览(46)
  • 使用飞桨实现的第一个AI项目——波士顿的房价预测

    part1.首先引入相应的函数库: 值得说明的地方: (1)首先,numpy是一个python库,主要用于提供线性代数中的矩阵或者多维数组的运算函数,利用import numpy as np引入numpy,并将np作为它的别名 part2.(一步步慢慢来,从0到1,只要突破了,就会有1到100的发生,所以,慢慢来)下面

    2024年02月11日
    浏览(45)
  • 多元线性回归的python代码实现(基于sklearn的波士顿房价boston数据集为例)

    基于sklearn自带数据集波士顿房价数据集进行多元线性回归算法代码实现,其数据集包括13个特征向量,共计506个样本集。 本文代码实现步骤如下: 1. 获取数据集 2. 数据集切分,老规矩,80%训练,20%测试 3. 数据预处理(本用例尝试过归一化处理,但发现效果不好,不是每一个

    2024年02月06日
    浏览(48)
  • python-机器学习-波士顿房价回归分析

            以波士顿房价数据集为对象,理解数据和认识数据,掌握 梯度下降法 和 回归分析 的初步方法,掌握 模型正则化 的一般方法,对回归分析的结果解读。         波士顿房价数据集是20世纪70年代中期波士顿郊区房价的中位数,统计了当时城市的13个指标与房价

    2024年02月06日
    浏览(31)
  • 波士顿房价数据集怎么不见了?

     做线性回归的同学大概率会用到一个数据集,即波士顿房价数据集,然而当你从sklearn下载该数据集时,你会惊讶地发现居然下载不了了!!!起初我以为是什么别的原因导致数据集可能被收回了,结果当我看到一篇文章就感觉,算了不做评价,参见这篇文章 消失的波士顿

    2024年02月05日
    浏览(68)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包