石狮做网站,网站的建设维护及管理制度,3d建模网站,苏州seo网站优化软件波士顿房价预测案例#xff08;python scikit-learn#xff09;—多元线性回归(多角度实验分析)
这次实验#xff0c;我们主要从以下几个方面介绍#xff1a;
一、相关框架介绍
二、数据集介绍
三、实验结果-优化算法对比实验#xff0c;数据标准化对比实验#xff0…波士顿房价预测案例python scikit-learn—多元线性回归(多角度实验分析)
这次实验我们主要从以下几个方面介绍
一、相关框架介绍
二、数据集介绍
三、实验结果-优化算法对比实验数据标准化对比实验正则化对比试验多项式回归degree对比实验岭回归alpha敏感度实验
一、相关框架介绍
Scikit-learn全称Simple and Efficient Tools for Machine Learning意为“简单高效的机器学习工具”是一个开源的Python机器学习库它提供了简单而高效的工具用于数据挖掘和数据分析。
Scikit-learn主要特点包括丰富的算法库、易于使用、高效的性能、数据预处理和特征选择、模型评估和选择、可扩展性、社区支持。
二、数据集介绍
2.1数据集来源
波士顿房价数据集是一个著名的数据集它在机器学习和统计分析领域中被广泛用于回归问题的实践和研究。这个数据集包含了美国马萨诸塞州波士顿郊区的房价信息这些信息是由美国人口普查局收集的。 该数据集共包括507行数据十三列特征外加一列标签。
2.2数据集特征
数据集的特征 CRIM: 城镇人均犯罪率 ZN: 占地面积超过25,000平方英尺的住宅用地比例 INDUS: 每个城镇非零售业务的比例 CHAS: 查尔斯河虚拟变量如果是河道则为1;否则为0 NOX: 一氧化氮浓度每千万份 RM: 每间住宅的平均房间数 AGE: 1940年以前建造的自住单位比例 DIS: 波士顿的五个就业中心加权距离 RAD: 径向高速公路的可达性指数 TAX: 每10,000美元的全额物业税率 PTRATIO: 城镇的学生与教师比例 B: 1000Bk - 0.63^ 2其中Bk是城镇黑人的比例 LSTAT: 人口状况下降 MEDV: 自有住房的中位数报价, 单位1000美元
三、实验结果-优化算法对比实验数据标准化对比实验正则化对比试验多项式回归degree对比实验岭回归alpha敏感度实验
3.1 优化算法对比实验 # 从 sklearn.datasets 导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量 boston 中。
boston load_boston()
# 输出数据描述。
from matplotlib import pyplot as plt
from matplotlib import font_manager
from matplotlib import pyplot as plt
import numpy as np
import matplotlib
# 参数设置import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei] #设置字体
plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题# 从sklearn.cross_validation 导入数据分割器。
from sklearn.model_selection import train_test_split
# 导入 numpy 并重命名为 np。
import numpy as np
from sklearn.linear_model import Ridge,Lasso
X boston.data
y boston.target
# 随机采样 25% 的数据构建测试样本其余作为训练样本。X_train, X_test, y_train, y_test train_test_split(X, y, random_state33, test_size0.25)
# 分析回归目标值的差异。print(The max target value is, np.max(boston.target))
print(The min target value is, np.min(boston.target))
print(The average target value is, np.mean(boston.target))# 从 sklearn.preprocessing 导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import Normalizer
# 分别初始化对特征和目标值的标准化器。
ss_X StandardScaler()
ss_y StandardScaler()
ssStandardScaler
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
X_train ss_X.fit_transform(X_train)
X_test ss_X.transform(X_test)y_train ss_y.fit_transform(y_train.reshape(-1, 1))y_test ss_y.transform(y_test.reshape(-1, 1))# 从 sklearn.linear_model 导入 LinearRegression。
from sklearn.linear_model import LinearRegression
# 使用默认配置初始化线性回归器 LinearRegression。def train_model():lr LinearRegression()# 使用训练数据进行参数估计。lr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lr_y_predict lr.predict(X_test)# 从 sklearn.linear_model 导入 SGDRegressor。from sklearn.linear_model import SGDRegressor# 使用默认配置初始化线性回归器 SGDRegressor。sgdr SGDRegressor()# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict sgdr.predict(X_test)ridge Ridge(alpha10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict ridge.predict(X_test)# Lassolasso Lasso(alpha0.01)# 使用训练数据进行参数估计。lasso.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lasso_y_predict lasso.predict(X_test)return lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predictdef evaluate(X_test,y_test,lr_y_predict,model):
# 使用 LinearRegression 模型自带的评估模块并输出评估结果。nmsemodel.score(X_test, y_test)print(The value of default measurement of LinearRegression is,nmse )# 从 sklearn.metrics 依次导入 r2_score、mean_squared_error 以及 mean_absoluate_error 用于回归性能的评估。from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error# 使用 r2_score 模块并输出评估结果。r2r2_score(y_test, lr_y_predict)print(The value of R-squared of LinearRegression is,r2 )# 使用 mean_squared_error 模块并输出评估结果。#print(y_test)lr_y_predictlr_y_predict.reshape(len(lr_y_predict),-1)#print(lr_y_predict)#print(mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))msemean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean squared error of LinearRegression is,mse)# 使用 mean_absolute_error 模块并输出评估结果。mae mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean absoluate error of LinearRegression is, mae)return round(nmse,2),round(r2,2),round(mse,2),round(mae,2)def plot(model1,model2):
# 数据classes [ r2, mse, mae]# r2s [87, 85, 89, 81, 78]# mess [85, 98, 84, 79, 82]# nmse [83, 85, 82, 87, 78]# 将横坐标班级先替换为数值x np.arange(len(classes))width 0.2r2s_x xmess_x x widthnmse_x x 2 * widthmae_x x 3 * width# 绘图plt.bar(r2s_x, model1, widthwidth, colorgold, labelLinearRegression)plt.bar(mess_x,model2,widthwidth,colorsilver,labelSGDRegressor)#plt.bar(nmse_x,model3,widthwidth, colorsaddlebrown,labelridge-alpha10)#plt.bar(mae_x,model4,widthwidth, colorred,labellasso-alpha0.01)plt.title(lr,sdgrss性能对比图)#将横坐标数值转换为班级plt.xticks(x width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],vabottom,hacenter,fontsize8)plt.text(mess_x[i],model2[i], model2[i],vabottom,hacenter,fontsize8)#plt.text(nmse_x[i],model3[i], model3[i],vabottom,hacenter,fontsize8)#plt.text(mae_x[i],model4[i], model4[i],vabottom,hacenter,fontsize8)#显示图例plt.legend(locupper right)plt.show()#codinggbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列用来画出线性模型的图形。znp.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),corange,edgecolorsk)plt.plot(z,z,ck)plt.xlabel(y)plt.ylabel(y_hat)plt.title(name)plt.show()lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predicttrain_model()models[lr,sgdr]
r2s[]
mess[]
maes[]
nmse[]
results[]
plot_line(X,y,lr,LinearRegressionss)
plot_line(X,y,sgdr,SGDRegressorss)
#plot_line(X,y,lasso,lassoss)
#plot_line(X,y,ridge,ridgess)
print(sgdr_y_predict)
print(sgdr_y_predict)predicts[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i0
for model in models:resultevaluate(X_test,y_test,predicts[i],model)ii1results.append(result)# r2s.append(result[1])# mess.append(result[2])# maes.append(result[3])# nmse.append(result[0])#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
print(results)#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
plot(results[0][1:4],results[1][1:4])3.2 数据标准化对比实验
# 从 sklearn.datasets 导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量 boston 中。
boston load_boston()
# 输出数据描述。
from matplotlib import pyplot as plt
from matplotlib import font_manager
from matplotlib import pyplot as plt
import numpy as np
import matplotlib
# 参数设置import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei] #设置字体
plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题# 从sklearn.cross_validation 导入数据分割器。
from sklearn.model_selection import train_test_split
# 导入 numpy 并重命名为 np。
import numpy as np
from sklearn.linear_model import Ridge,Lasso
X boston.data
y boston.target
# 随机采样 25% 的数据构建测试样本其余作为训练样本。X_train, X_test, y_train, y_test train_test_split(X, y, random_state33, test_size0.25)
# 分析回归目标值的差异。print(The max target value is, np.max(boston.target))
print(The min target value is, np.min(boston.target))
print(The average target value is, np.mean(boston.target))# 从 sklearn.preprocessing 导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import Normalizer
# 分别初始化对特征和目标值的标准化器。
ss_X StandardScaler()
ss_y StandardScaler()
ssStandardScaler
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
X_train ss_X.fit_transform(X_train)
X_test ss_X.transform(X_test)y_train ss_y.fit_transform(y_train.reshape(-1, 1))y_test ss_y.transform(y_test.reshape(-1, 1))# 从 sklearn.linear_model 导入 LinearRegression。
from sklearn.linear_model import LinearRegression
# 使用默认配置初始化线性回归器 LinearRegression。def train_model():lr LinearRegression()# 使用训练数据进行参数估计。lr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lr_y_predict lr.predict(X_test)# 从 sklearn.linear_model 导入 SGDRegressor。from sklearn.linear_model import SGDRegressor# 使用默认配置初始化线性回归器 SGDRegressor。sgdr SGDRegressor()# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict sgdr.predict(X_test)ridge Ridge(alpha10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict ridge.predict(X_test)# Lassolasso Lasso(alpha0.01)# 使用训练数据进行参数估计。lasso.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lasso_y_predict lasso.predict(X_test)return lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predictdef evaluate(X_test,y_test,lr_y_predict,model):
# 使用 LinearRegression 模型自带的评估模块并输出评估结果。nmsemodel.score(X_test, y_test)print(The value of default measurement of LinearRegression is,nmse )# 从 sklearn.metrics 依次导入 r2_score、mean_squared_error 以及 mean_absoluate_error 用于回归性能的评估。from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error# 使用 r2_score 模块并输出评估结果。r2r2_score(y_test, lr_y_predict)print(The value of R-squared of LinearRegression is,r2 )# 使用 mean_squared_error 模块并输出评估结果。#print(y_test)lr_y_predictlr_y_predict.reshape(len(lr_y_predict),-1)#print(lr_y_predict)#print(mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))msemean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean squared error of LinearRegression is,mse)# 使用 mean_absolute_error 模块并输出评估结果。mae mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean absoluate error of LinearRegression is, mae)return round(nmse,2),round(r2,2),round(mse,2),round(mae,2)def plot(model1,model2):
# 数据classes [ r2, mse, mae]# r2s [87, 85, 89, 81, 78]# mess [85, 98, 84, 79, 82]# nmse [83, 85, 82, 87, 78]# 将横坐标班级先替换为数值x np.arange(len(classes))width 0.2r2s_x xmess_x x widthnmse_x x 2 * widthmae_x x 3 * width# 绘图plt.bar(r2s_x, model1, widthwidth, colorgold, labelLinearRegression)plt.bar(mess_x,model2,widthwidth,colorsilver,labelSGDRegressor)#plt.bar(nmse_x,model3,widthwidth, colorsaddlebrown,labelridge-alpha10)#plt.bar(mae_x,model4,widthwidth, colorred,labellasso-alpha0.01)plt.title(lr,sdgrss性能对比图)#将横坐标数值转换为班级plt.xticks(x width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],vabottom,hacenter,fontsize8)plt.text(mess_x[i],model2[i], model2[i],vabottom,hacenter,fontsize8)#plt.text(nmse_x[i],model3[i], model3[i],vabottom,hacenter,fontsize8)#plt.text(mae_x[i],model4[i], model4[i],vabottom,hacenter,fontsize8)#显示图例plt.legend(locupper right)plt.show()#codinggbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列用来画出线性模型的图形。znp.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),corange,edgecolorsk)plt.plot(z,z,ck)plt.xlabel(y)plt.ylabel(y_hat)plt.title(name)plt.show()lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predicttrain_model()models[lr,sgdr]
r2s[]
mess[]
maes[]
nmse[]
results[]
plot_line(X,y,lr,LinearRegressionss)
plot_line(X,y,sgdr,SGDRegressorss)
#plot_line(X,y,lasso,lassoss)
#plot_line(X,y,ridge,ridgess)
print(sgdr_y_predict)
print(sgdr_y_predict)predicts[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i0
for model in models:resultevaluate(X_test,y_test,predicts[i],model)ii1results.append(result)# r2s.append(result[1])# mess.append(result[2])# maes.append(result[3])# nmse.append(result[0])#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
print(results)#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
plot(results[0][1:4],results[1][1:4])# 从 sklearn.datasets 导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量 boston 中。
boston load_boston()
# 输出数据描述。
from matplotlib import pyplot as plt
from matplotlib import font_manager
from matplotlib import pyplot as plt
import numpy as np
import matplotlib
# 参数设置import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei] #设置字体
plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题# 从sklearn.cross_validation 导入数据分割器。
from sklearn.model_selection import train_test_split
# 导入 numpy 并重命名为 np。
import numpy as np
from sklearn.linear_model import Ridge, RidgeCV
X boston.data
print(X.min(axis0))
print(X.max(axis0))y boston.target
# 随机采样 25% 的数据构建测试样本其余作为训练样本。
X_train, X_test, y_train, y_test train_test_split(X, y, random_state33, test_size0.25)
# 分析回归目标值的差异。print(The max target value is, np.max(boston.target))
print(The min target value is, np.min(boston.target))
print(The average target value is, np.mean(boston.target))# 从 sklearn.preprocessing 导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
# 分别初始化对特征和目标值的标准化器。
ss_X StandardScaler()
ss_y StandardScaler()
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
# X_train ss_X.fit_transform(X_train
# X_test ss_X.transform(X_test)
y_train y_train.reshape(-1, 1)
y_test y_test.reshape(-1, 1)# 从 sklearn.linear_model 导入 LinearRegression。
from sklearn.linear_model import LinearRegression
# 使用默认配置初始化线性回归器 LinearRegression。def train_model():lr LinearRegression()# 使用训练数据进行参数估计。lr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lr_y_predict lr.predict(X_test)# 从 sklearn.linear_model 导入 SGDRegressor。from sklearn.linear_model import SGDRegressor# 使用默认配置初始化线性回归器 SGDRegressor。sgdr SGDRegressor()# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict sgdr.predict(X_test)ridge Ridge(alpha10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict ridge.predict(X_test)return lr,sgdr,ridge,lr_y_predict,sgdr_y_predict,ridge_y_predictdef evaluate(X_test,y_test,lr_y_predict,model):
# 使用 LinearRegression 模型自带的评估模块并输出评估结果。nmsemodel.score(X_test, y_test)print(The value of default measurement of LinearRegression is,nmse )# 从 sklearn.metrics 依次导入 r2_score、mean_squared_error 以及 mean_absoluate_error 用于回归性能的评估。from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error# 使用 r2_score 模块并输出评估结果。r2r2_score(y_test, lr_y_predict)print(The value of R-squared of LinearRegression is,r2 )# 使用 mean_squared_error 模块并输出评估结果。#print(y_test)lr_y_predictlr_y_predict.reshape(len(lr_y_predict),-1)#print(lr_y_predict)#print(mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))msemean_squared_error(y_test, lr_y_predict)print(The mean squared error of LinearRegression is,mse)# 使用 mean_absolute_error 模块并输出评估结果。mae mean_absolute_error(y_test, lr_y_predict)print(The mean absoluate error of LinearRegression is, mae)return round(nmse,2),round(r2,2),round(mse,2),round(mae,2)def plot(model1,model2):
# 数据classes [ r2, mse, mae]# r2s [87, 85, 89, 81, 78]# mess [85, 98, 84, 79, 82]# nmse [83, 85, 82, 87, 78]# 将横坐标班级先替换为数值x np.arange(len(classes))width 0.2r2s_x xmess_x x widthnmse_x x 2 * widthmae_x x 3 * width# 绘图plt.bar(r2s_x, model1, widthwidth, colorgold, labelLinearRegression)plt.bar(mess_x,model2,widthwidth,colorsilver,labelSGDRegressor)# plt.bar(nmse_x,nmse,widthwidth, colorsaddlebrown,labelmse)# plt.bar(mae_x,maes,widthwidth, colorred,labelmae)#将横坐标数值转换为班级plt.xticks(x width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],vabottom,hacenter,fontsize8)plt.text(mess_x[i],model2[i], model2[i],vabottom,hacenter,fontsize8)# plt.text(nmse_x[i],nmse[i], nmse[i],vabottom,hacenter,fontsize8)# plt.text(mae_x[i],maes[i], maes[i],vabottom,hacenter,fontsize8)#显示图例plt.legend(locupper right)plt.show()def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列用来画出线性模型的图形。znp.linspace(0,50,200).reshape(-1,1)plt.scatter(y,model.predict(X),corange,edgecolorsk)print(model.predict(X))plt.plot(z,z,ck)plt.xlabel(y)plt.ylabel(y_hat)plt.title(name)plt.show()
lr,sgdr,ridge,lr_y_predict,sgdr_y_predict,ridge_y_predicttrain_model()models[lr,sgdr,]
r2s[]
mess[]
maes[]
nmse[]
results[]plot_line(X,y,lr,LinearRegression)
plot_line(X,y,sgdr,SGDRegressor)
print(sgdr_y_predict)
print(sgdr_y_predict)predicts[lr_y_predict,sgdr_y_predict]
i0
for model in models:resultevaluate(X_test,y_test,predicts[i],model)ii1results.append(result)# r2s.append(result[1])# mess.append(result[2])# maes.append(result[3])# nmse.append(result[0])#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
print(results)
plot(results[0][1:4],results[1][1:4])3.3 正则化对比试验 # 从 sklearn.datasets 导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量 boston 中。
boston load_boston()
# 输出数据描述。
from matplotlib import pyplot as plt
from matplotlib import font_manager
from matplotlib import pyplot as plt
import numpy as np
import matplotlib
# 参数设置import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei] #设置字体
plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题# 从sklearn.cross_validation 导入数据分割器。
from sklearn.model_selection import train_test_split
# 导入 numpy 并重命名为 np。
import numpy as np
from sklearn.linear_model import Ridge,Lasso
X boston.data
y boston.target
# 随机采样 25% 的数据构建测试样本其余作为训练样本。X_train, X_test, y_train, y_test train_test_split(X, y, random_state33, test_size0.25)
# 分析回归目标值的差异。print(The max target value is, np.max(boston.target))
print(The min target value is, np.min(boston.target))
print(The average target value is, np.mean(boston.target))# 从 sklearn.preprocessing 导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import Normalizer
# 分别初始化对特征和目标值的标准化器。
ss_X StandardScaler()
ss_y StandardScaler()
ssStandardScaler
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
X_train ss_X.fit_transform(X_train)
X_test ss_X.transform(X_test)y_train ss_y.fit_transform(y_train.reshape(-1, 1))y_test ss_y.transform(y_test.reshape(-1, 1))# 从 sklearn.linear_model 导入 LinearRegression。
from sklearn.linear_model import LinearRegression
# 使用默认配置初始化线性回归器 LinearRegression。def train_model():lr LinearRegression()# 使用训练数据进行参数估计。lr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lr_y_predict lr.predict(X_test)# 从 sklearn.linear_model 导入 SGDRegressor。from sklearn.linear_model import SGDRegressor# 使用默认配置初始化线性回归器 SGDRegressor。sgdr SGDRegressor()# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict sgdr.predict(X_test)ridge Ridge(alpha10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict ridge.predict(X_test)# Lassolasso Lasso(alpha0.01)# 使用训练数据进行参数估计。lasso.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lasso_y_predict lasso.predict(X_test)return lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predictdef evaluate(X_test,y_test,lr_y_predict,model):
# 使用 LinearRegression 模型自带的评估模块并输出评估结果。nmsemodel.score(X_test, y_test)print(The value of default measurement of LinearRegression is,nmse )# 从 sklearn.metrics 依次导入 r2_score、mean_squared_error 以及 mean_absoluate_error 用于回归性能的评估。from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error# 使用 r2_score 模块并输出评估结果。r2r2_score(y_test, lr_y_predict)print(The value of R-squared of LinearRegression is,r2 )# 使用 mean_squared_error 模块并输出评估结果。#print(y_test)lr_y_predictlr_y_predict.reshape(len(lr_y_predict),-1)#print(lr_y_predict)#print(mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))msemean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean squared error of LinearRegression is,mse)# 使用 mean_absolute_error 模块并输出评估结果。mae mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean absoluate error of LinearRegression is, mae)return round(nmse,2),round(r2,2),round(mse,2),round(mae,2)def plot(model1,model2,model3,model4):
# 数据classes [ r2, mse, mae]# r2s [87, 85, 89, 81, 78]# mess [85, 98, 84, 79, 82]# nmse [83, 85, 82, 87, 78]# 将横坐标班级先替换为数值x np.arange(len(classes))width 0.2r2s_x xmess_x x widthnmse_x x 2 * widthmae_x x 3 * width# 绘图plt.bar(r2s_x, model1, widthwidth, colorgold, labelLinearRegression)plt.bar(mess_x,model2,widthwidth,colorsilver,labelSGDRegressor)plt.bar(nmse_x,model3,widthwidth, colorsaddlebrown,labelridge-alpha10)plt.bar(mae_x,model4,widthwidth, colorred,labellasso-alpha0.01)plt.title(lr,sdgr,lasso,ridgess性能对比图)#将横坐标数值转换为班级plt.xticks(x width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],vabottom,hacenter,fontsize8)plt.text(mess_x[i],model2[i], model2[i],vabottom,hacenter,fontsize8)plt.text(nmse_x[i],model3[i], model3[i],vabottom,hacenter,fontsize8)plt.text(mae_x[i],model4[i], model4[i],vabottom,hacenter,fontsize8)#显示图例plt.legend(locupper right)plt.show()#codinggbk;def plot_line(X,y,model,name):znp.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),corange,edgecolorsk)plt.plot(z,z,ck)plt.xlabel(y)plt.ylabel(y_hat)plt.title(name)plt.show()lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predicttrain_model()models[lr,sgdr,ridge,lasso]
r2s[]
mess[]
maes[]
nmse[]
results[]
plot_line(X,y,lr,LinearRegressionss)
plot_line(X,y,sgdr,SGDRegressorss)
plot_line(X,y,lasso,lassoss)
plot_line(X,y,ridge,ridgess)
print(sgdr_y_predict)
print(sgdr_y_predict)predicts[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i0
for model in models:resultevaluate(X_test,y_test,predicts[i],model)ii1results.append(result)# r2s.append(result[1])# mess.append(result[2])# maes.append(result[3])# nmse.append(result[0])#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
print(results)#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
plot(results[0][1:4],results[1][1:4],results[2][1:4],results[3][1:4])3.4多项式回归degree对比实验 # 从 sklearn.datasets 导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量 boston 中。
boston load_boston()
# 输出数据描述。
from matplotlib import pyplot as plt
from matplotlib import font_manager
from matplotlib import pyplot as plt
import numpy as np
import matplotlib
# 参数设置
from sklearn.preprocessing import PolynomialFeatures
import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei] #设置字体
plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题# 从sklearn.cross_validation 导入数据分割器。
from sklearn.model_selection import train_test_split
# 导入 numpy 并重命名为 np。
import numpy as np
from sklearn.linear_model import Ridge,Lasso
X boston.data
y boston.target
# 随机采样 25% 的数据构建测试样本其余作为训练样本。X_train, X_test, y_train, y_test train_test_split(X, y, random_state33, test_size0.25)
# 分析回归目标值的差异。print(The max target value is, np.max(boston.target))
print(The min target value is, np.min(boston.target))
print(The average target value is, np.mean(boston.target))# 从 sklearn.preprocessing 导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import Normalizer
# 分别初始化对特征和目标值的标准化器。
ss_X StandardScaler()
ss_y StandardScaler()
ssStandardScaler
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
X_train ss_X.fit_transform(X_train)
X_test ss_X.transform(X_test)
y_train[0]y_train[0]300
y_train ss_y.fit_transform(y_train.reshape(-1, 1))y_test ss_y.transform(y_test.reshape(-1, 1))# 从 sklearn.linear_model 导入 LinearRegression。
from sklearn.linear_model import LinearRegression
# 使用默认配置初始化线性回归器 LinearRegression。def train_model():poly_reg PolynomialFeatures(degree1)# 数据转换 x0--1 x1--x x2--x^2 x3--x^3x_poly poly_reg.fit_transform(X_train)# 建模#lin_reg LinearRegression().fit(x_poly, y_data)lr LinearRegression().fit(x_poly, y_train[:,0])# 使用训练数据进行参数估计。lr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lr_y_predict lr.predict(X_test)# 从 sklearn.linear_model 导入 SGDRegressor。from sklearn.linear_model import SGDRegressor# 使用默认配置初始化线性回归器 SGDRegressor。poly_reg PolynomialFeatures(degree2)# 数据转换 x0--1 x1--x x2--x^2 x3--x^3x_poly poly_reg.fit_transform(X_train)sgdr LinearRegression().fit(x_poly, y_train[:,0])# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict sgdr.predict(X_test)poly_reg PolynomialFeatures(degree3)# 数据转换 x0--1 x1--x x2--x^2 x3--x^3x_poly poly_reg.fit_transform(X_train)ridge LinearRegression().fit(x_poly, y_train[:,0])# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict ridge.predict(X_test)# Lassopoly_reg PolynomialFeatures(degree4)# 数据转换 x0--1 x1--x x2--x^2 x3--x^3x_poly poly_reg.fit_transform(X_train)lasso LinearRegression().fit(x_poly, y_train[:,0])# 使用训练数据进行参数估计。lasso.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lasso_y_predict lasso.predict(X_test)return lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predictdef evaluate(X_test,y_test,lr_y_predict,model):
# 使用 LinearRegression 模型自带的评估模块并输出评估结果。nmsemodel.score(X_test, y_test)print(The value of default measurement of LinearRegression is,nmse )# 从 sklearn.metrics 依次导入 r2_score、mean_squared_error 以及 mean_absoluate_error 用于回归性能的评估。from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error# 使用 r2_score 模块并输出评估结果。r2r2_score(y_test, lr_y_predict)print(The value of R-squared of LinearRegression is,r2 )# 使用 mean_squared_error 模块并输出评估结果。#print(y_test)lr_y_predictlr_y_predict.reshape(len(lr_y_predict),-1)#print(lr_y_predict)#print(mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))msemean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean squared error of LinearRegression is,mse)# 使用 mean_absolute_error 模块并输出评估结果。mae mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean absoluate error of LinearRegression is, mae)return round(nmse,2),round(r2,2),round(mse,2),round(mae,2)def plot(model1,model2,model3,model4):
# 数据classes [ r2, mse, mae]# r2s [87, 85, 89, 81, 78]# mess [85, 98, 84, 79, 82]# nmse [83, 85, 82, 87, 78]# 将横坐标班级先替换为数值x np.arange(len(classes))width 0.2r2s_x xmess_x x widthnmse_x x 2 * widthmae_x x 3 * width# 绘图plt.bar(r2s_x, model1, widthwidth, colorgold, labelploy-degree1)plt.bar(mess_x,model2,widthwidth,colorsilver,labelploy-degree2)plt.bar(nmse_x,model3,widthwidth, colorsaddlebrown,labelploy-degree3)plt.bar(mae_x,model4,widthwidth, colorred,labelploy-degree4)plt.title(不同degree多项式回归ss性能对比图)#将横坐标数值转换为班级plt.xticks(x width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],vabottom,hacenter,fontsize8)plt.text(mess_x[i],model2[i], model2[i],vabottom,hacenter,fontsize8)plt.text(nmse_x[i],model3[i], model3[i],vabottom,hacenter,fontsize8)plt.text(mae_x[i],model4[i], model4[i],vabottom,hacenter,fontsize8)#显示图例plt.legend(locupper right)plt.show()#codinggbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列用来画出线性模型的图形。znp.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),corange,edgecolorsk)plt.plot(z,z,ck)plt.xlabel(y)plt.ylabel(y_hat)plt.title(name)plt.show()lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predicttrain_model()models[lr,sgdr,ridge,lasso]
r2s[]
mess[]
maes[]
nmse[]
results[]
#plot_line(X,y,lr,LinearRegressionss)
#plot_line(X,y,sgdr,SGDRegressorss)
#plot_line(X,y,lasso,lassoss)
#plot_line(X,y,ridge,ridgess)
print(sgdr_y_predict)
print(sgdr_y_predict)predicts[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i0
for model in models:resultevaluate(X_test,y_test,predicts[i],model)ii1results.append(result)# r2s.append(result[1])# mess.append(result[2])# maes.append(result[3])# nmse.append(result[0])#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
print(results)#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
plot(results[0][1:4],results[1][1:4],results[2][1:4],results[3][1:4])截图
3.5 岭回归alpha敏感度实验 # 从 sklearn.datasets 导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量 boston 中。
boston load_boston()
# 输出数据描述。
from matplotlib import pyplot as plt
from matplotlib import font_manager
from matplotlib import pyplot as plt
import numpy as np
import matplotlib
# 参数设置import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei] #设置字体
plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题# 从sklearn.cross_validation 导入数据分割器。
from sklearn.model_selection import train_test_split
# 导入 numpy 并重命名为 np。
import numpy as np
from sklearn.linear_model import Ridge,Lasso
X boston.data
y boston.target
# 随机采样 25% 的数据构建测试样本其余作为训练样本。X_train, X_test, y_train, y_test train_test_split(X, y, random_state33, test_size0.25)
# 分析回归目标值的差异。print(The max target value is, np.max(boston.target))
print(The min target value is, np.min(boston.target))
print(The average target value is, np.mean(boston.target))# 从 sklearn.preprocessing 导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import Normalizer
# 分别初始化对特征和目标值的标准化器。
ss_X StandardScaler()
ss_y StandardScaler()
ssStandardScaler
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
X_train ss_X.fit_transform(X_train)
X_test ss_X.transform(X_test)
y_train[0]y_train[0]300
y_train ss_y.fit_transform(y_train.reshape(-1, 1))y_test ss_y.transform(y_test.reshape(-1, 1))# 从 sklearn.linear_model 导入 LinearRegression。
from sklearn.linear_model import LinearRegression
# 使用默认配置初始化线性回归器 LinearRegression。def train_model():lr Ridge(alpha2)# 使用训练数据进行参数估计。lr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lr_y_predict lr.predict(X_test)# 从 sklearn.linear_model 导入 SGDRegressor。from sklearn.linear_model import SGDRegressor# 使用默认配置初始化线性回归器 SGDRegressor。sgdr Ridge(alpha5)# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict sgdr.predict(X_test)ridge Ridge(alpha10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict ridge.predict(X_test)# Lassolasso Ridge(alpha15)# 使用训练数据进行参数估计。lasso.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。lasso_y_predict lasso.predict(X_test)return lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predictdef evaluate(X_test,y_test,lr_y_predict,model):
# 使用 LinearRegression 模型自带的评估模块并输出评估结果。nmsemodel.score(X_test, y_test)print(The value of default measurement of LinearRegression is,nmse )# 从 sklearn.metrics 依次导入 r2_score、mean_squared_error 以及 mean_absoluate_error 用于回归性能的评估。from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error# 使用 r2_score 模块并输出评估结果。r2r2_score(y_test, lr_y_predict)print(The value of R-squared of LinearRegression is,r2 )# 使用 mean_squared_error 模块并输出评估结果。#print(y_test)lr_y_predictlr_y_predict.reshape(len(lr_y_predict),-1)#print(lr_y_predict)#print(mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))msemean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean squared error of LinearRegression is,mse)# 使用 mean_absolute_error 模块并输出评估结果。mae mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict))print(The mean absoluate error of LinearRegression is, mae)return round(nmse,2),round(r2,2),round(mse,2),round(mae,2)def plot(model1,model2,model3,model4):
# 数据classes [ r2, mse, mae]# r2s [87, 85, 89, 81, 78]# mess [85, 98, 84, 79, 82]# nmse [83, 85, 82, 87, 78]# 将横坐标班级先替换为数值x np.arange(len(classes))width 0.2r2s_x xmess_x x widthnmse_x x 2 * widthmae_x x 3 * width# 绘图plt.bar(r2s_x, model1, widthwidth, colorgold, labelridge-alpha2)plt.bar(mess_x,model2,widthwidth,colorsilver,labelridge-alpha5)plt.bar(nmse_x,model3,widthwidth, colorsaddlebrown,labelridge-alpha10)plt.bar(mae_x,model4,widthwidth, colorred,labelridge-alpha15)plt.title(不同alpha-ridgess性能对比图)#将横坐标数值转换为班级plt.xticks(x width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],vabottom,hacenter,fontsize8)plt.text(mess_x[i],model2[i], model2[i],vabottom,hacenter,fontsize8)plt.text(nmse_x[i],model3[i], model3[i],vabottom,hacenter,fontsize8)plt.text(mae_x[i],model4[i], model4[i],vabottom,hacenter,fontsize8)#显示图例plt.legend(locupper right)plt.show()#codinggbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列用来画出线性模型的图形。znp.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),corange,edgecolorsk)plt.plot(z,z,ck)plt.xlabel(y)plt.ylabel(y_hat)plt.title(name)plt.show()lr,sgdr,ridge,lasso,lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predicttrain_model()models[lr,sgdr,ridge,lasso]
r2s[]
mess[]
maes[]
nmse[]
results[]
plot_line(X,y,lr,LinearRegressionss)
plot_line(X,y,sgdr,SGDRegressorss)
plot_line(X,y,lasso,lassoss)
plot_line(X,y,ridge,ridgess)
print(sgdr_y_predict)
print(sgdr_y_predict)predicts[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i0
for model in models:resultevaluate(X_test,y_test,predicts[i],model)ii1results.append(result)# r2s.append(result[1])# mess.append(result[2])# maes.append(result[3])# nmse.append(result[0])#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
print(results)#evaluate(X_test,y_test,sgdr_y_predict,sgdr)
plot(results[0][1:4],results[1][1:4],results[2][1:4],results[3][1:4])运行结果
