线性回归预测波士顿房价

林丿子轩

已于 2022-03-08 13:25:10 修改

阅读量2.7k

点赞数 1

分类专栏： CV—Sklean 文章标签：线性回归 sklearn 机器学习

于 2022-02-28 10:47:48 首次发布

本文链接：https://blog.csdn.net/weixin_43005832/article/details/123177408

版权

CV—Sklean 专栏收录该内容

14 篇文章 3 订阅

订阅专栏

波士顿房价数据集（Boston housing prices dataset）

#加载数据集
from sklearn import  datasets
import sklearn
from sklearn import  metrics
import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model
import cv2
%matplotlib inline

bosten  = datasets.load_boston()

在’DESCR’中我们可以获取关于数据集的更多信息，在’data’中找到所有的数据，在’feature_names’中找到所有的特征名称，在’filename’中找到波士顿CSV数据集的物理位置，并在’target’中找到所有的目标值：

dir(bosten)
# ['DESCR', 'data', 'feature_names', 'filename', 'target']
bosten.data.shape#  (506, 13)
bosten.target.shape# (506,) 房价数据

(506,)

训练模型linreg 为线性回归模型的一个对象

主要思想：sklearn.linear_model.LinearRegression求解线性回归方程参数时，首先判断训练集X是否是稀疏矩阵，如果是，就用Golub&Kanlan双对角线化过程方法来求解；否则调用C库中LAPACK中的用基于分治法的奇异值分解来求解。在sklearn中并不是使用梯度下降法求解线性回归，而是使用最小二乘法求解。
sklearn.LinearRegression的fit()方法：

'''  sklearn.LinearRegression.fit(X,Y)
  if sp.issparse(X):#如果X是稀疏矩阵
      if y.ndim < 2:
          out = sparse_lsqr(X, y)
          self.coef_ = out[0]
          self._residues = out[3]
      else:
          # sparse_lstsq cannot handle y with shape (M, K)
          outs = Parallel(n_jobs=n_jobs_)(
              delayed(sparse_lsqr)(X, y[:, j].ravel())
              for j in range(y.shape[1]))
          self.coef_ = np.vstack(out[0] for out in outs)
          self._residues = np.vstack(out[3] for out in outs)
  else:
      self.coef_, self._residues, self.rank_, self.singular_ = \
          linalg.lstsq(X, y)
      self.coef_ = self.coef_.T
'''

'  sklearn.LinearRegression.fit(X,Y)\n  if sp.issparse(X):#如果X是稀疏矩阵\n      if y.ndim < 2:\n          out = sparse_lsqr(X, y)\n          self.coef_ = out[0]\n          self._residues = out[3]\n      else:\n          # sparse_lstsq cannot handle y with shape (M, K)\n          outs = Parallel(n_jobs=n_jobs_)(\n              delayed(sparse_lsqr)(X, y[:, j].ravel())\n              for j in range(y.shape[1]))\n          self.coef_ = np.vstack(out[0] for out in outs)\n          self._residues = np.vstack(out[3] for out in outs)\n  else:\n      self.coef_, self._residues, self.rank_, self.singular_ =           linalg.lstsq(X, y)\n      self.coef_ = self.coef_.T\n'

lasso 回归：https://blog.csdn.net/foneone/article/details/96576990

在真实问题中，一个预测问题可能有上百种特征，并不知道哪一些是高阶多项式的项，就像不知道\theta_{3}和\theta_{4}是高阶的项。所以，如果假设有一百个特征，并不知道如何选择关联度更好的参数，如何缩小参数的数目等等。因此在正则化里，要做的事情，就是把减小损失函数中所有的参数值

此外：还有L2正则化：\lambda \sum_{j=1}^{n} w_{j}^{2}，加了这种正则化的损失函数模型为：脊(岭)回归（Ridge Regression).

asso的复杂程度由λ来控制，λ越大对变量较多的线性模型的惩罚力度就越大，从而最终获得一个变量较少的模型

lassoreg = linear_model.Lasso()  #均方误差+ a sum（L1）
ridgereg = linear_model.Ridge() #L2 MSE +a sum（L2）

linreg = linear_model.LinearRegression()

数据分开为x_train,x_test,y_train,y_test
其中输入为 bosten.data 需要预测的输出为bosten.target

x_train,x_test,y_train,y_test = sklearn.model_selection.train_test_split(bosten.data,bosten.target,test_size=0.1,random_state=42)
# random_state 类似于seed（42）
#test_size 分割数据集为 9：1的比例默认为0.25

在scikit-learn中，train函数命名为fit，但是在其他方面，它的行为与在OpenCV中是完全一样的：

linreg.fit(x_train,y_train)
lassoreg.fit(x_train,y_train)
ridgereg.fit(x_train,y_train)
# y_pre = linreg.predict(x_train)
# y_pre_lassor = lassoreg.predict(x_train)
# y_pre_ridger = ridgereg.predict(x_train)

# metrics.mean_squared_error(y_train,y_pre)

Ridge()

这里的score：
The coefficient R2 is defined as (1-(u)/(v)), where u is the residual sum of squares ((y_true - y_pred) ** 2).sum() and v is the total sum of squares ((y_true - y_true.mean()) ** 2).sum().

The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a R2 score of 0.0.
评价系统，模型评分

#  模型评分
linreg.score(x_train,y_train),lassoreg.score(x_train,y_train),ridgereg.score(x_train,y_train)

(0.7375152736886281, 0.6813080948165031, 0.7353661779527543)

legend 是显示图例
用法如下
https://blog.csdn.net/qq_33221533/article/details/81431264
loc默认指向best

#测试集的模型表现
y_test_pre = linreg.predict(x_test)
plt.plot(y_test,linewidth = 3,c = 'b',label = 'ground truth')
plt.plot(y_test_pre,linewidth=3,c ='r',label=' predicted')

plt.legend(loc = 'best')
plt.xlabel('test data points')
plt.ylabel('target value')
plt.show()

y_test_pre_lassor = lassoreg.predict(x_test)
plt.plot(y_test,linewidth = 3,c = 'b',label = 'ground truth')
plt.plot(y_test_pre_lassor,linewidth=3,c ='g',label=' predicted')

plt.legend(loc = 'best')
plt.xlabel('test data points')
plt.ylabel('target value')
plt.show()

y_test_pre_ridge = ridgereg.predict(x_test)
plt.plot(y_test,linewidth = 3,c = 'b',label = 'ground truth')
plt.plot(y_test_pre_lassor,linewidth=3,c ='y',label=' predicted')

plt.legend(loc = 'best')
plt.xlabel('test data points')
plt.ylabel('target value')
plt.show()

在这里插入图片描述

我们通过计算R平方来形式化数据的方差：
我们还绘制了一条对角线作为参考（用黑色虚线’k–’），这我们很快就能看到。可是我们还希望在文本框中显示R2得分和均方误差：

plt.legend 设置图框
plt.text 设置文字说明

y = [y_test_pre,y_test_pre_lassor,y_test_pre_ridge]

scorestr1 = r'R$^2$ = %.3f' % linreg.score(x_test, y_test)
scorestr2 = r'R$^2$ = %.3f' % lassoreg.score(x_test, y_test)
scorestr3 = r'R$^2$ = %.3f' % ridgereg.score(x_test, y_test)
errstr1 = 'MSE = %.3f' % metrics.mean_squared_error(y_test, y_test_pre)
errstr2 = 'MSE = %.3f' % metrics.mean_squared_error(y_test, y_test_pre_ridge)
errstr3 = 'MSE = %.3f' % metrics.mean_squared_error(y_test, y_test_pre_lassor)
score = [scorestr1,scorestr2,scorestr3]  #字符串
errstr = [errstr1,errstr2,errstr3]     #字符串

for index,data in enumerate(y):
    plt.figure(figsize=(10, 6))
    plt.plot(y_test,data , 'o')
    plt.plot([-10, 60], [-10, 60], 'k--')
    plt.text(-5, 50, score[index], fontsize=12)
    plt.text(-5, 45, errstr[index], fontsize=12)
    plt.axis([-10, 60, -10, 60])
    plt.xlabel('ground truth')
    plt.ylabel('predicted')
    plt.show()

在这里插入图片描述

如果我们的模型是完美的，那么所有的数据点都应该位于虚线对角线上，因为y_pred总是等于y_true。对角线上的偏差表明模型存在一定的误差，或者数据中存在一些模型无法解释的偏差。例如第一张图中R2表明我们能够解释76.3%的数据分散，均方误差是（MSE）18.645。这些是我们可以用来比较线性回归模型和一些更复杂的模型的性能指标。

–22/3/8日 --更新内容

我们还可以试试使用决策树模拟回归曲线
一个小的区别是基尼系数和熵的拆分标准不适用于回归任务。但scikit-learn提供了两种不同的拆分标准：
mse：这个标准计算实际值和预测值之间的均方误差（Mean Squared Error，MSE），并拆分产生最小均方误差的节点。
mae：这个标准计算实际值和预测值之间的平均绝对误差（Mean Absolute Error，MAE），并拆分产生最小平均绝对误差的节点.

如下示例中我们加入了

from sklearn import  tree
reg_tree4 = tree.DecisionTreeRegressor(max_depth= 4)
reg_tree4.fit(x_train,y_train)
reg_tree10 = tree.DecisionTreeRegressor(max_depth=10)
reg_tree10.fit(x_train,y_train)
reg_tree2 = tree.DecisionTreeRegressor(max_depth=2)
reg_tree2.fit(x_train,y_train)

y_tree2 = reg_tree2.predict(x_test)
y_tree4 = reg_tree4.predict(x_test)
y_tree10 = reg_tree10.predict(x_test)


plt.plot(y_test,linewidth = 3,c = 'b',label = 'ground truth')
plt.plot(y_tree2,linewidth=3,c ='r',label=' y_tree2')
plt.text(25,45,f'accuracy_score:{reg_tree2.score(x_test,y_test):.2f}')
plt.legend(loc = 'best')
plt.xlabel('test data points')
plt.ylabel('target value')
plt.show()

plt.plot(y_test,linewidth = 3,c = 'b',label = 'ground truth')
plt.plot(y_tree4,linewidth=3,c='r',label=' y_tree4')
plt.text(25,45,f'accuracy_score:{reg_tree4.score(x_test,y_test):.2f}')
plt.legend(loc = 'best')
plt.xlabel('test data points')
plt.ylabel('target value')
plt.show()


plt.plot(y_test,linewidth = 3,c = 'b',label = 'ground truth')
plt.plot(y_tree10,linewidth=3,c='g',label=' y_tree10')
plt.text(25,45,f'accuracy_score:{reg_tree10.score(x_test,y_test):.2f}')
plt.legend(loc = 'best')
plt.xlabel('test data points')
plt.ylabel('target value')
plt.show()

在这里插入图片描述

在这里插入图片描述
由上图对比可知随着决策树的细腻度的提升，拟合的曲线也变得越来越精细

其他文章
决策树的实现与可视化
 决策树初探 - 建立一颗简单的决策树
 主成分分析，独立成分分析，+t-SNE 分布随机可视化降维的对比
 线性回归预测波士顿房价
 基于逻辑回归的鸢尾花分类
 数据表示和特征工程

引用文档
机器学习使用OpenCV、Python和scikit-learn进行智能图像处理(原书第2版)-(elib.cc) by (印)阿迪蒂亚·夏尔马(Aditya Sharma)(印)维什韦什·拉维·什里马利(Vishwesh Ravi Shrimali)(美)迈克尔·贝耶勒(Michael Beyeler)