【机器学习与实现】线性回归示例——波士顿房价分析

2024-05-07 18:28
文章标签 示例 波士顿 线性 机器 回归 房价 学习 分析 实现

本文主要是介绍【机器学习与实现】线性回归示例——波士顿房价分析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

    • 一、创建Pandas对象并查看数据的基本情况
    • 二、使用皮尔逊相关系数分析特征之间的相关性
    • 三、可视化不同特征与因变量'MEDV'（房价中值）间的相关性
    • 四、划分训练集和测试集并进行回归分析

一、创建Pandas对象并查看数据的基本情况

boston.csv数据集下载：

在这里插入图片描述

链接：https://pan.quark.cn/s/fc4b2415e371
提取码：ZXjU

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inlinehouse = pd.read_csv("boston.csv")
print("shape=", house.shape)

shape= (506, 14)

house[:5]

在这里插入图片描述

house.describe()
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATMEDV
count506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000
mean3.59376111.36363611.1367790.0691700.5546956.28463468.5749013.7950439.549407408.23715418.455534356.67403212.65306322.532806
std8.59678323.3224536.8603530.2539940.1158780.70261728.1488612.1057108.707259168.5371162.16494691.2948647.1410629.197104
min0.0063200.0000000.4600000.0000000.3850003.5610002.9000001.1296001.000000187.00000012.6000000.3200001.7300005.000000
25%0.0820450.0000005.1900000.0000000.4490005.88550045.0250002.1001754.000000279.00000017.400000375.3775006.95000017.025000
50%0.2565100.0000009.6900000.0000000.5380006.20850077.5000003.2074505.000000330.00000019.050000391.44000011.36000021.200000
75%3.64742212.50000018.1000000.0000000.6240006.62350094.0750005.18842524.000000666.00000020.200000396.22500016.95500025.000000
max88.976200100.00000027.7400001.0000000.8710008.780000100.00000012.12650024.000000711.00000022.000000396.90000037.97000050.000000
house.info()

在这里插入图片描述

二、使用皮尔逊相关系数分析特征之间的相关性

house.corr(method='pearson')

在这里插入图片描述

三、可视化不同特征与因变量’MEDV’（房价中值）间的相关性

#可视化不同特征与因变量'MEDV'（房价中值）间的相关性
fig = plt.figure( figsize=(8, 8), dpi=100 )
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = Falseplt.subplots_adjust(hspace=0.35)
plt.subplot(2, 2, 1)
#s指定点的大小，可用help(plt.scatter)查看帮助
plt.scatter(house['RM'], house['MEDV'], s=1, marker='o', label='RM-MEDV')  
plt.xlabel( r"房间数 - $RM$" )
plt.ylabel( r"房价 - $MEDV$" )
plt.title(r"$\rho=0.695360$")plt.subplot(2, 2, 2)
plt.scatter(house['LSTAT'], house['MEDV'], s=1, marker='o', label='LSTAT-MEDV')
plt.xlabel( r"低层人口比例 - $LSTAT$" )
plt.title(r"$\rho=-0.737663$")plt.subplot(2, 2, 3)
plt.scatter(house['DIS'], house['MEDV'], s=1, marker='o', label='DIS-MEDV')
plt.xlabel( r"距就业中心距离 - $DIS$" )
plt.ylabel( r"房价 - $MEDV$" )
plt.title(r"$\rho=0.249929$")plt.subplot(2, 2, 4)
plt.scatter(house['CHAS'], house['MEDV'], s=1, marker='o', label='CHAS-MEDV')
plt.xlabel( r"河景房 - $CHAS$" )
plt.title(r"$\rho=0.175260$")
plt.show()

在这里插入图片描述

  选取特征’RM’(房间数)，‘LSTAT’(低层人口比例)，‘CHAS’(河景房)和目标’MEDV’(房价中值)形成样本数据。

house1 = house[['RM','LSTAT','CHAS','MEDV']]
house1[:5]

在这里插入图片描述

  如有必要，对数值型特征进行标准化。

  在标准化之前，要使用MinMaxScaler进行特征缩放，这是一个常用的预处理步骤，有助于将数据缩放到一个指定的范围内，通常是[0,1]。

from sklearn.preprocessing import MinMaxScaler
mmScaler = MinMaxScaler()		#创建MinMaxScaler对象mmScaler.fit(house1[['RM','LSTAT']])	#对MinMaxScaler对象进行拟合，以便获取特征的最小值和最大值
print("Min=", mmScaler.data_min_, "Max=", mmScaler.data_max_)m = mmScaler.transform(house1[['RM','LSTAT']])		#使用拟合好的MinMaxScaler对象对数据集进行特征缩放
# m = mmScaler.fit_transform(house1[['RM','LSTAT']])
# 创建一个DataFrame来存储特征缩放后的数据，同时保留原始特征'CHAS'和目标变量'MEDV'
house2m = pd.DataFrame(m, columns=['RM','LSTAT'])
house2m[['CHAS','MEDV']] = house1[['CHAS','MEDV']]
house2m[:5]

在这里插入图片描述

  使用 scikit-learn 中的StandardScaler对数据集中的特征进行标准化处理。首先，使用fit方法将标准化器适配到数据上，并打印出了每个特征的均值和方差。然后，使用transform方法对数据进行转换，将标准化后的数据保存到变量z中。接着，将标准化后的特征数据与原始数据集中的其他列（比如CHAS和MEDV）一起合并到新的DataFrame house2z中。

from sklearn.preprocessing import StandardScaler
zScaler = StandardScaler()			#创建一个StandardScaler对象
zScaler.fit(house1[['RM','LSTAT']])		#使用fit方法将StandardScaler对象适配到房屋数据的'RM'和'LSTAT'特征上，并计算它们的均值和方差
print("mean=", zScaler.mean_, "variance=", zScaler.var_)z = zScaler.transform(house1[['RM','LSTAT']])		#使用标准化器对'RM'和'LSTAT'特征进行标准化处理，并保存到变量z中
# z = zScaler.fit_transform(house1[['RM','LSTAT']])
# 创建一个新的DataFrame 'house2z'来保存标准化后的特征数据，并将'CHAS'和'MEDV'列添加到其中
house2z = pd.DataFrame(z, columns=['RM','LSTAT'])
house2z[['CHAS','MEDV']] = house1[['CHAS','MEDV']]
house2z[:5]

在这里插入图片描述

X = house2z[['RM','LSTAT','CHAS']];
X[:5]

在这里插入图片描述

Y = house2z['MEDV']
Y[:5]

在这里插入图片描述

四、划分训练集和测试集并进行回归分析

1、划分训练集和测试集

  使用train_test_split()函数用于按一定比例划分训练集和测试集。

from sklearn.model_selection import train_test_split
# X为特征数据，Y为目标数据
# test_size参数指定测试集的比例，这里设置为0.2表示测试集占总数据集的20%
# random_state参数用于设置随机种子，相同的值得到相同的训练集和测试集划分
X_train,X_test,Y_train,Y_test = train_test_split(X, Y, test_size=0.2, random_state=2020)
# 打印训练集和测试集的形状（样本数，特征数或目标数）
print("X_train:", X_train.shape, "Y_train:", Y_train.shape)
print("X_test:", X_test.shape, "Y_test:", Y_test.shape)

在这里插入图片描述

#help(train_test_split)

2、创建一个线性回归模型并拟合训练数据

  lr.coef_ 是模型的系数，lr.intercept_ 是模型的截距。接下来，将测试数据集的前五个样本用于预测，并将预测结果与实际值一起打印出来。这样可以比较模型的预测效果。

from sklearn.linear_model import LinearRegression
#创建LinearRegression估计器对象
lr = LinearRegression()
lr.fit(X_train, Y_train)
print(lr.coef_, lr.intercept_)XY_test = X_test[:5].copy()
XY_test['MEDV'] = Y_test[:5]
XY_test['MEDV_predict'] = lr.predict(X_test[:5])
XY_test

在这里插入图片描述

3、创建线性回归模型并用训练集数据进行拟合

  接下来，计算训练集和测试集上的R方值（决定系数）和均方误差（MSE）来评估模型的性能。R方值越接近1，表示模型拟合得越好；而均方误差越小，表示模型的预测结果与实际值之间的偏差越小。

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_errorlr = LinearRegression()
lr.fit(X_train, Y_train);  print(lr.coef_, lr.intercept_)print("训练集R方：%f，" % lr.score(X_train, Y_train), end='')
print("训练集MSE：%f" % mean_squared_error( Y_train, lr.predict(X_train)))print("测试集R方：%f，" % lr.score(X_test, Y_test), end='')
print("测试集MSE：%f" % mean_squared_error( Y_test, lr.predict(X_test)))

在这里插入图片描述

#help(lr.score)
#help(mean_squared_error)

4、使用K折交叉验证来评估线性回归模型的性能

  在每个折叠中，数据被分成训练集和测试集，模型在训练集上进行拟合，并在测试集上进行评估。这有助于更准确地评估模型的泛化能力。在每次迭代中，打印了训练集和测试集的索引，拟合模型的系数和截距，以及模型在测试集上的R方值和均方误差。

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
lr = LinearRegression()from sklearn.model_selection import KFold
kf = KFold(n_splits=3);  n = 0
for train_index, test_index in kf.split(X):n += 1print(n, "：TRAIN", train_index.shape, "  TEST", test_index.shape)X1_train, X1_test = X.iloc[train_index], X.iloc[test_index]Y1_train, Y1_test = Y.iloc[train_index], Y.iloc[test_index]lr.fit(X1_train, Y1_train);  print(lr.coef_, lr.intercept_)print("测试集R方：%f，" % lr.score(X1_test, Y1_test), end='')print("测试集MSE：%f" % mean_squared_error( Y1_test, lr.predict(X1_test)))

在这里插入图片描述

  使用带有随机重排和指定随机种子的K折交叉验证来评估线性回归模型。在每个折叠中，将数据分为训练集和测试集，并在训练集上拟合模型。

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
lr = LinearRegression()
coef = [0, 0, 0];  intercept = 0from sklearn.model_selection import KFold
kf = KFold(n_splits=3, shuffle=True, random_state=2020);  n = 0
for train_index, test_index in kf.split(X):n += 1X1_train, X1_test = X.iloc[train_index], X.iloc[test_index]Y1_train, Y1_test = Y.iloc[train_index], Y.iloc[test_index]lr.fit(X1_train, Y1_train)coef += lr.coef_;  intercept += lr.intercept_lr.coef_ = coef/n;  lr.intercept_ = intercept/n
print(lr.coef_, lr.intercept_)print("训练集R方：%f，" % lr.score(X_train, Y_train), end='')
print("训练集MSE：%f" % mean_squared_error( Y_train, lr.predict(X_train)))print("测试集R方：%f，" % lr.score(X_test, Y_test), end='')
print("测试集MSE：%f" % mean_squared_error( Y_test, lr.predict(X_test)))

在这里插入图片描述

5、使用岭回归模型（Ridge）来拟合数据

  使用岭回归模型（Ridge）来拟合数据，并计算了模型在训练集和测试集上的R方和均方误差（MSE）。岭回归是一种常见的线性回归的正则化方法，通过引入L2范数惩罚项来控制模型的复杂度，有助于解决特征多重共线性问题。

  设置alpha参数为1.0，这是岭回归中控制正则化强度的参数。较大的alpha值意味着更强的正则化。打印岭回归模型的系数（coef）和截距（intercept），以及在训练集和测试集上的R方和MSE。

from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_errorrd = Ridge(alpha=1.0)
rd.fit(X_train, Y_train)
print(rd.coef_, rd.intercept_)print("训练集R方：%f，" % rd.score(X_train, Y_train), end='')
print("训练集MSE：%f" % mean_squared_error( Y_train, rd.predict(X_train)))print("测试集R方：%f，" % rd.score(X_test, Y_test), end='')
print("测试集MSE：%f" % mean_squared_error( Y_test, rd.predict(X_test)))

在这里插入图片描述
  使用网格搜索（GridSearchCV）来对岭回归（Ridge）模型的正则化参数alpha进行优化，并绘制了正则化系数与交叉验证的均方误差（MSE）之间的关系。

  • 使用GridSearchCV来搜索不同的alpha值，并选出导致最低均方误差的最佳参数。
  • 指定lamda = np.linspace(0, 20, 100)作为网格搜索的候选参数范围。
  • scoring='neg_mean_squared_error'表示用负均方误差作为评分标准。
  • cv=3表示使用3折交叉验证来评估每个alpha值的表现。

  还计算了最佳参数对应的训练集和测试集上的R方（r2_score）和均方误差（neg_mean_squared_error）。最后，用一幅图展示了不同alpha值对应的交叉验证均方误差，以便直观地了解正则化强度与模型表现之间的关系。

from sklearn.linear_model import Ridge
from sklearn.metrics import r2_score
rd = Ridge()from sklearn.model_selection import GridSearchCV
lamda = np.linspace(0, 20, 100)
grid = {'alpha': lamda}
gs = GridSearchCV(estimator=rd, param_grid=grid,\scoring='neg_mean_squared_error', cv=3)
gs.fit(X_train, Y_train)
print(gs.best_params_, -gs.best_score_)
print("训练集MSE：%f，" % -gs.score(X_train, Y_train), end='')
print("训练集R方：%f" % r2_score( Y_train, gs.predict(X_train)))
print("测试集MSE：%f，" % -gs.score(X_test, Y_test), end='')
print("测试集R方：%f" % r2_score( Y_test, gs.predict(X_test)))fig = plt.figure( figsize=(4, 3), dpi=100 )
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.plot(lamda, -gs.cv_results_['mean_test_score'], linewidth=1)
plt.text(10, 31.58, r"网格搜索：$\alpha$", fontsize=18)
plt.xlabel( r"正则化系数 - $\alpha$" )
plt.ylabel( r"均方误差 - $MSE$" )
plt.show()

在这里插入图片描述

6、使用Lasso回归防止过拟合

  使用了Lasso回归模型，该模型是线性回归的变体，带有L1正则化项。Lasso回归通过缩小回归系数的绝对值来防止过拟合，最终可能导致一些系数变为零，从而实现特征选择的效果。

from sklearn.linear_model import Lasso
from sklearn.metrics import mean_squared_error
# 创建了一个Lasso模型，正则化参数alpha=1.0，最大迭代次数max_iter=1000
las = Lasso(alpha=1.0, max_iter=1000)
las.fit(X_train, Y_train)
print(las.coef_, las.intercept_)	#训练模型后，输出模型的系数和截距
# 计算训练集和测试集上的R方（score方法）和均方误差（mean_squared_error）
print("训练集R方：%f，" % las.score(X_train, Y_train), end='')
print("训练集MSE：%f" % mean_squared_error( Y_train, las.predict(X_train)))print("测试集R方：%f，" % las.score(X_test, Y_test), end='')
print("测试集MSE：%f" % mean_squared_error( Y_test, las.predict(X_test)))

在这里插入图片描述

多项式特征扩展与Lasso回归结合。

  • PolynomialFeatures：这个类用于生成多项式特征，它将输入特征的所有可能的组合作为新的特征。在这里，使用PolynomialFeatures(2, include_bias=False)创建了一个二次多项式特征扩展对象，并将其应用于训练集和测试集，得到了扩展后的特征矩阵X_train_pf和X_test_pf。
  • Lasso：这是Lasso回归模型的调用，使用默认参数alpha=1.0和max_iter=1000。然后，使用扩展后的特征矩阵X_train_pf对模型进行拟合。
  • 输出模型系数和截距：打印了模型的系数和截距，这些系数对应于扩展后的特征空间中的每个特征。
  • 训练集和测试集上的评估：最后，分别计算了训练集和测试集上的R方值和均方误差。R方值（决定系数）用于评估模型对目标变量的拟合程度，均方误差则衡量了模型的预测误差大小。
from sklearn.linear_model import Lasso
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import PolynomialFeaturespoly = PolynomialFeatures(2, include_bias=False)
X_train_pf = poly.fit_transform(X_train)
X_test_pf = poly.fit_transform(X_test)
# X_train的形状是(样本数, 特征数)，而X_train_pf的形状是(样本数, 扩展后的特征数)
print("X_train：", X_train.shape, "，X_train_pf.shape：", X_train_pf.shape)las = Lasso(alpha=1.0, max_iter=1000)
las.fit(X_train_pf, Y_train)
print(las.coef_, las.intercept_)	#模型的系数和截距
# 训练集和测试集上的R方值和均方误差
print("训练集R方：%f，" % las.score(X_train_pf, Y_train), end='')
print("训练集MSE：%f" % mean_squared_error(Y_train, las.predict(X_train_pf)))print("测试集R方：%f，" % las.score(X_test_pf, Y_test), end='')
print("测试集MSE：%f" % mean_squared_error(Y_test, las.predict(X_test_pf)))

在这里插入图片描述

这篇关于【机器学习与实现】线性回归示例——波士顿房价分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/968043。

相关文章

Java设计模式之代理模式2-动态代理（jdk实现）

Java设计模式之代理模式2-动态代理（jdk实现）

这篇是接着上一篇继续介绍java设计模式之代理模式。下面讲解的是jdk实现动态代理。 1.）首先我们要声明一个动态代理类，实现InvocationHandler接口 package com.zhong.pattern.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;/*** 演
阅读更多...
Java中的SOLID原则及示例

Java中的SOLID原则及示例

类是任何Java应用程序的构建块。如果这些区块不强，那么建筑（即应用）将来将面临艰难时期。这实际上意味着，当应用程序范围上升或应用程序在生产或维护中面临某些设计问题时，不那么好的编写会导致非常困难的情况。 另一方面，一组精心设计和编写的类可以加速编码过程的突飞猛进，同时减少错误的数量。 在本教程中，我们将使用 5个最推荐的设计原则的示例来讨论Java中的SOLID原则，在编写类时我们应该记住这
阅读更多...
Java比较和交换示例 - CAS算法

Java比较和交换示例 - CAS算法

Java比较和交换示例 - CAS算法 由Lokesh Gupta | 提起下：多线程 一个Java 5中最好添加的是支持类，如原子操作AtomicInteger，AtomicLong等等。这些课程帮助您最大限度地减少复杂的（非必要）需要多线程的，如增加一些基本的操作代码或递减的值在多个线程之间共享。这些类内部依赖于名为CAS（比较和交换）的算法。在本文中，我将详细讨论这个概念。 1.乐观和
阅读更多...
使用Array实现Java堆栈

使用Array实现Java堆栈

本教程给出了使用Array 实现Stack数据结构的示例。堆栈提供将新对象放在堆栈上（方法push（））并从堆栈中获取对象（方法pop（））。堆栈根据后进先出（LIFO）返回对象。请注意，JDK提供了一个默认的Java堆栈实现作为类java.util.Stack。 适用于所有堆栈实现的两个强制操作是： push（）：数据项放置在堆栈指针指向的位置。pop（）：从堆栈指针指向的位置删除并返回数据
阅读更多...
Redis利用zset数据结构如何实现多字段排序，score的调整（finalScore = score*MAX_NAME_VALUE + getIntRepresentation(name) ）

Redis利用zset数据结构如何实现多字段排序，score的调整（finalScore = score*MAX_NAME_VALUE + getIntRepresentation(name) ）

1、原文：   2、使用sql很容易实现多字段的排序功能，比如： select * from user order by score desc,name desc； 3、问题：用两个字段（score，name）排序。在redis中应该怎么做？   4、使用按分数排序的redis集合。你必须根据你的需要准备分数。 finalScore = score*MAX_NAME_VALUE +
阅读更多...
Linux命令学习之二

Linux命令学习之二

每日一结 ​               命令置换：是将一个命令的输出作为另一个命令的参数，命令格式如下： commond1 `command2` 其中，命令command2的输出将作为命令command1的参数，需要注意的是， 命令置换的单引号为ESC键下方的 ` 其意思就是说，先运行单引号内的命令，再将其命令作为
阅读更多...
Linux命令学习之一

Linux命令学习之一

每日一结                                                                                        注：当用户不确定一个软件包的类型时， 可使用file命令查看文件类型
阅读更多...
关于 ZigBee WiFi Bluetooth 的分析

关于 ZigBee WiFi Bluetooth 的分析

ZigBee： Zigbee是IEEE 802.15.4协议的代名词。根据这个协议规定的技术是一种短距离、低功耗的无线通信技术。其特点是近距离、低复杂度、自组织、低功耗、低数据速率、低成本。主要适合用于自动控制和远程控制领域，可以嵌入各种设备。简而言之，ZigBee就是一种便宜的，低功耗的近距离无线组网通讯技术。             ZigBee的主要优势：
阅读更多...
字符串处理函数strchr和strstr的实现

字符串处理函数strchr和strstr的实现

1，strchr函数 函数功能：查找一个字符。在一个字符串中查找一个特定的字符。 函数原型：char *strchr(char const *str,int ch); 函数说明：strchr在字符串str中查找字符ch第一次出现的位置，找到后返回一个指向该位置的指针。如果该字符不存在于字符串中，则返回一个NULL指针。注意：第二个参数是一个整型值，但是，它包含了一个字符串值。
阅读更多...
Android图片轮播的实现总结

Android图片轮播的实现总结

前言： 在很多app中，我们都可以看到几张图片每隔一段时间就切换一下，这就是我们所称的图片轮播的功能，其主要实现就是用到了ViewPager， 下面我们来着重讲解一下其具体实现 效果图： 步骤一：在XML中添加ViewPager控件 比如： <?xml version="1.0" encoding="utf-8"?><RelativeLayout xmlns:a
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2