波士顿房价预测案例(python scikit-learn)---多元线性回归(多角度实验分析)

波士顿房价预测案例(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: 1000(Bk - 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_state=33, test_size=0.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()
ss="StandardScaler"
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
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(alpha=10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict = ridge.predict(X_test)# Lassolasso = Lasso(alpha=0.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 模型自带的评估模块,并输出评估结果。nmse=model.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 模块,并输出评估结果。r2=r2_score(y_test, lr_y_predict)print('The value of R-squared of LinearRegression is',r2 )# 使用 mean_squared_error 模块,并输出评估结果。#print(y_test)lr_y_predict=lr_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)))mse=mean_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, width=width, color='gold', label='LinearRegression')plt.bar(mess_x,model2,width=width,color="silver",label="SGDRegressor")#plt.bar(nmse_x,model3,width=width, color="saddlebrown",label="ridge-alpha=10")#plt.bar(mae_x,model4,width=width, color="red",label="lasso-alpha=0.01")plt.title("lr,sdgr+"+ss+"性能对比图")#将横坐标数值转换为班级plt.xticks(x + width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],va="bottom",ha="center",fontsize=8)plt.text(mess_x[i],model2[i], model2[i],va="bottom",ha="center",fontsize=8)#plt.text(nmse_x[i],model3[i], model3[i],va="bottom",ha="center",fontsize=8)#plt.text(mae_x[i],model4[i], model4[i],va="bottom",ha="center",fontsize=8)#显示图例plt.legend(loc="upper right")plt.show()#coding=gbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列,用来画出线性模型的图形。z=np.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),c="orange",edgecolors='k')plt.plot(z,z,c="k")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_predict=train_model()models=[lr,sgdr]
r2s=[]
mess=[]
maes=[]
nmse=[]
results=[]
plot_line(X,y,lr,'LinearRegression+'+ss)
plot_line(X,y,sgdr,'SGDRegressor+'+ss)
#plot_line(X,y,lasso,'lasso'+ss)
#plot_line(X,y,ridge,'ridge'+ss)
print("sgdr_y_predict")
print(sgdr_y_predict)predicts=[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i=0
for model in models:result=evaluate(X_test,y_test,predicts[i],model)i=i+1results.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_state=33, test_size=0.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()
ss="StandardScaler"
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
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(alpha=10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict = ridge.predict(X_test)# Lassolasso = Lasso(alpha=0.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 模型自带的评估模块,并输出评估结果。nmse=model.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 模块,并输出评估结果。r2=r2_score(y_test, lr_y_predict)print('The value of R-squared of LinearRegression is',r2 )# 使用 mean_squared_error 模块,并输出评估结果。#print(y_test)lr_y_predict=lr_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)))mse=mean_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, width=width, color='gold', label='LinearRegression')plt.bar(mess_x,model2,width=width,color="silver",label="SGDRegressor")#plt.bar(nmse_x,model3,width=width, color="saddlebrown",label="ridge-alpha=10")#plt.bar(mae_x,model4,width=width, color="red",label="lasso-alpha=0.01")plt.title("lr,sdgr+"+ss+"性能对比图")#将横坐标数值转换为班级plt.xticks(x + width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],va="bottom",ha="center",fontsize=8)plt.text(mess_x[i],model2[i], model2[i],va="bottom",ha="center",fontsize=8)#plt.text(nmse_x[i],model3[i], model3[i],va="bottom",ha="center",fontsize=8)#plt.text(mae_x[i],model4[i], model4[i],va="bottom",ha="center",fontsize=8)#显示图例plt.legend(loc="upper right")plt.show()#coding=gbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列,用来画出线性模型的图形。z=np.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),c="orange",edgecolors='k')plt.plot(z,z,c="k")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_predict=train_model()models=[lr,sgdr]
r2s=[]
mess=[]
maes=[]
nmse=[]
results=[]
plot_line(X,y,lr,'LinearRegression+'+ss)
plot_line(X,y,sgdr,'SGDRegressor+'+ss)
#plot_line(X,y,lasso,'lasso'+ss)
#plot_line(X,y,ridge,'ridge'+ss)
print("sgdr_y_predict")
print(sgdr_y_predict)predicts=[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i=0
for model in models:result=evaluate(X_test,y_test,predicts[i],model)i=i+1results.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(axis=0))
print(X.max(axis=0))y = boston.target
# 随机采样 25% 的数据构建测试样本,其余作为训练样本。
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.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(alpha=10)# 使用训练数据进行参数估计。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 模型自带的评估模块,并输出评估结果。nmse=model.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 模块,并输出评估结果。r2=r2_score(y_test, lr_y_predict)print('The value of R-squared of LinearRegression is',r2 )# 使用 mean_squared_error 模块,并输出评估结果。#print(y_test)lr_y_predict=lr_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)))mse=mean_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, width=width, color='gold', label='LinearRegression')plt.bar(mess_x,model2,width=width,color="silver",label="SGDRegressor")# plt.bar(nmse_x,nmse,width=width, color="saddlebrown",label="mse")# plt.bar(mae_x,maes,width=width, color="red",label="mae")#将横坐标数值转换为班级plt.xticks(x + width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],va="bottom",ha="center",fontsize=8)plt.text(mess_x[i],model2[i], model2[i],va="bottom",ha="center",fontsize=8)# plt.text(nmse_x[i],nmse[i], nmse[i],va="bottom",ha="center",fontsize=8)# plt.text(mae_x[i],maes[i], maes[i],va="bottom",ha="center",fontsize=8)#显示图例plt.legend(loc="upper right")plt.show()def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列,用来画出线性模型的图形。z=np.linspace(0,50,200).reshape(-1,1)plt.scatter(y,model.predict(X),c="orange",edgecolors='k')print(model.predict(X))plt.plot(z,z,c="k")plt.xlabel('y')plt.ylabel("y_hat")plt.title(name)plt.show()
lr,sgdr,ridge,lr_y_predict,sgdr_y_predict,ridge_y_predict=train_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]
i=0
for model in models:result=evaluate(X_test,y_test,predicts[i],model)i=i+1results.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_state=33, test_size=0.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()
ss="StandardScaler"
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
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(alpha=10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict = ridge.predict(X_test)# Lassolasso = Lasso(alpha=0.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 模型自带的评估模块,并输出评估结果。nmse=model.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 模块,并输出评估结果。r2=r2_score(y_test, lr_y_predict)print('The value of R-squared of LinearRegression is',r2 )# 使用 mean_squared_error 模块,并输出评估结果。#print(y_test)lr_y_predict=lr_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)))mse=mean_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, width=width, color='gold', label='LinearRegression')plt.bar(mess_x,model2,width=width,color="silver",label="SGDRegressor")plt.bar(nmse_x,model3,width=width, color="saddlebrown",label="ridge-alpha=10")plt.bar(mae_x,model4,width=width, color="red",label="lasso-alpha=0.01")plt.title("lr,sdgr,lasso,ridge+"+ss+"性能对比图")#将横坐标数值转换为班级plt.xticks(x + width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],va="bottom",ha="center",fontsize=8)plt.text(mess_x[i],model2[i], model2[i],va="bottom",ha="center",fontsize=8)plt.text(nmse_x[i],model3[i], model3[i],va="bottom",ha="center",fontsize=8)plt.text(mae_x[i],model4[i], model4[i],va="bottom",ha="center",fontsize=8)#显示图例plt.legend(loc="upper right")plt.show()#coding=gbk;def plot_line(X,y,model,name):z=np.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),c="orange",edgecolors='k')plt.plot(z,z,c="k")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_predict=train_model()models=[lr,sgdr,ridge,lasso]
r2s=[]
mess=[]
maes=[]
nmse=[]
results=[]
plot_line(X,y,lr,'LinearRegression+'+ss)
plot_line(X,y,sgdr,'SGDRegressor'+ss)
plot_line(X,y,lasso,'lasso'+ss)
plot_line(X,y,ridge,'ridge'+ss)
print("sgdr_y_predict")
print(sgdr_y_predict)predicts=[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i=0
for model in models:result=evaluate(X_test,y_test,predicts[i],model)i=i+1results.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_state=33, test_size=0.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()
ss="StandardScaler"
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
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(degree=1)# 数据转换 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(degree=2)# 数据转换 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(degree=3)# 数据转换 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(degree=4)# 数据转换 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 模型自带的评估模块,并输出评估结果。nmse=model.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 模块,并输出评估结果。r2=r2_score(y_test, lr_y_predict)print('The value of R-squared of LinearRegression is',r2 )# 使用 mean_squared_error 模块,并输出评估结果。#print(y_test)lr_y_predict=lr_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)))mse=mean_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, width=width, color='gold', label='ploy-degree=1')plt.bar(mess_x,model2,width=width,color="silver",label="ploy-degree=2")plt.bar(nmse_x,model3,width=width, color="saddlebrown",label="ploy-degree=3")plt.bar(mae_x,model4,width=width, color="red",label="ploy-degree=4")plt.title("不同degree多项式回归+"+ss+"性能对比图")#将横坐标数值转换为班级plt.xticks(x + width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],va="bottom",ha="center",fontsize=8)plt.text(mess_x[i],model2[i], model2[i],va="bottom",ha="center",fontsize=8)plt.text(nmse_x[i],model3[i], model3[i],va="bottom",ha="center",fontsize=8)plt.text(mae_x[i],model4[i], model4[i],va="bottom",ha="center",fontsize=8)#显示图例plt.legend(loc="upper right")plt.show()#coding=gbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列,用来画出线性模型的图形。z=np.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),c="orange",edgecolors='k')plt.plot(z,z,c="k")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_predict=train_model()models=[lr,sgdr,ridge,lasso]
r2s=[]
mess=[]
maes=[]
nmse=[]
results=[]
#plot_line(X,y,lr,'LinearRegression+'+ss)
#plot_line(X,y,sgdr,'SGDRegressor'+ss)
#plot_line(X,y,lasso,'lasso'+ss)
#plot_line(X,y,ridge,'ridge'+ss)
print("sgdr_y_predict")
print(sgdr_y_predict)predicts=[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i=0
for model in models:result=evaluate(X_test,y_test,predicts[i],model)i=i+1results.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_state=33, test_size=0.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()
ss="StandardScaler"
# 分别对训练和测试数据的特征以及目标值进行标准化处理。
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(alpha=2)# 使用训练数据进行参数估计。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(alpha=5)# 使用训练数据进行参数估计。sgdr.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。sgdr_y_predict = sgdr.predict(X_test)ridge = Ridge(alpha=10)# 使用训练数据进行参数估计。ridge.fit(X_train, y_train[:,0])# 对测试数据进行回归预测。ridge_y_predict = ridge.predict(X_test)# Lassolasso =Ridge(alpha=15)# 使用训练数据进行参数估计。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 模型自带的评估模块,并输出评估结果。nmse=model.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 模块,并输出评估结果。r2=r2_score(y_test, lr_y_predict)print('The value of R-squared of LinearRegression is',r2 )# 使用 mean_squared_error 模块,并输出评估结果。#print(y_test)lr_y_predict=lr_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)))mse=mean_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, width=width, color='gold', label='ridge-alpha=2')plt.bar(mess_x,model2,width=width,color="silver",label="ridge-alpha=5")plt.bar(nmse_x,model3,width=width, color="saddlebrown",label="ridge-alpha=10")plt.bar(mae_x,model4,width=width, color="red",label="ridge-alpha=15")plt.title("不同alpha-ridge+"+ss+"性能对比图")#将横坐标数值转换为班级plt.xticks(x + width, classes)#显示柱状图的高度文本for i in range(len(classes)):plt.text(r2s_x[i],model1[i], model1[i],va="bottom",ha="center",fontsize=8)plt.text(mess_x[i],model2[i], model2[i],va="bottom",ha="center",fontsize=8)plt.text(nmse_x[i],model3[i], model3[i],va="bottom",ha="center",fontsize=8)plt.text(mae_x[i],model4[i], model4[i],va="bottom",ha="center",fontsize=8)#显示图例plt.legend(loc="upper right")plt.show()#coding=gbk;def plot_line(X,y,model,name):#--------------------------------------------------------------#z是我们生成的等差数列,用来画出线性模型的图形。z=np.linspace(0,50,200).reshape(-1,1)plt.scatter(y,ss_y.inverse_transform(model.predict(ss_X.transform(X)).reshape(len(X),-1)),c="orange",edgecolors='k')plt.plot(z,z,c="k")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_predict=train_model()models=[lr,sgdr,ridge,lasso]
r2s=[]
mess=[]
maes=[]
nmse=[]
results=[]
plot_line(X,y,lr,'LinearRegression+'+ss)
plot_line(X,y,sgdr,'SGDRegressor'+ss)
plot_line(X,y,lasso,'lasso'+ss)
plot_line(X,y,ridge,'ridge'+ss)
print("sgdr_y_predict")
print(sgdr_y_predict)predicts=[lr_y_predict,sgdr_y_predict,ridge_y_predict,lasso_y_predict]
i=0
for model in models:result=evaluate(X_test,y_test,predicts[i],model)i=i+1results.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])

运行结果:
在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.hqwc.cn/news/589900.html

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

标题:巨控GRM560:医药行业设备管理的预警的革新者

描述:在快速发展的医药行业中,设备的稳定性和安全性至关重要。巨控GRM560模块作为一种前沿的数据采集和故障提醒系统,已经成为该行业内不可或缺的一部分。本文将深入探讨GRM560模块的功能及其在医药行业中的应用。 正文: 在当今…

29.使线程以固定顺序输出结果

借助wait和notify方法控制线程以固定的顺序执行: /*** 控制输出字符的顺序,必须是固定顺序2,1* 采用wait-notify实现* param args*/public static void main(String[] args) {new Thread(() -> {synchronized (lock) {while (!isPrint2) {try {lock.…

【漏洞复现】科立讯指挥调度管理平台存在命令注入漏洞

0x01 产品简介 科立讯指挥调度管理平台是一个专业针对通信行业的管理平台。该产品旨在提供高效的指挥调度喝管理解决方案,以帮助通信运营商或相关机构实现更好的运营效率和服务质量。该平台提供强大的指挥调度功能,可以实时监控和管理通信网络设备、维护人员和工作任务等。用…

C语言:文件操作(一)

目录 前言 1、为什么使用文件 2、什么是文件 2.1 程序文件 2.2 数据文件 2.3 文件名 3、文件的打开和关闭 3.1 文件指针 3.2 文件的打开和关闭 结(一) 前言 本篇文章将介绍C语言的文件操作,在后面的内容讲到:为什么使用文…

C++的并发世界(五)——线程状态切换

0.线程状态 初始化:该线程正在被创建; 就绪:该线程在列表中就绪,等待CPU调度; 运行:该线程正在运行; 阻塞:该线程被阻塞挂机,Blocked状态包括:pend&#xff…

Apache DolphinScheduler 【安装部署】

前言 今天来学习一下 DolphinScheduler ,这是一个任务调度工具,现在用的比较火爆。 1、安装部署 1.0、准备工作 1.0.1、集群规划 dolphinscheduler 比较吃内存,所以尽量给 master 节点多分配一点内存,桌面和虚拟机里能关的应用…

Golang 开发实战day07 - Functions

Golang 教程07 - Functions 1. Functions 1.1 什么是函数? 在 Golang 中,函数就像是代码的超级组合体,可以将一段代码封装成一个独立的单元,以便重复使用。 1.2 函数声明 func funcName(parameter1 type1, parameter2 type2)…

Leetcode刷题-数组(二分法、双指针法、窗口滑动)

数组 1、二分法 704. 二分查找 - 力扣&#xff08;LeetCode&#xff09; 需要注意区间的问题。首先在最外面的循环判断条件是left<right。那就说明我们区间规定的范围就是【left,right】 属于是左闭右闭&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&…

一文让你彻底理解 AdaBoost 自适应提升算法 | AdaBoost 的关键要点、基本原理、优缺点和实际应用

&#x1f349; CSDN 叶庭云&#xff1a;https://yetingyun.blog.csdn.net/ 一、关键要点 AdaBoost&#xff0c;即自适应提升&#xff08;Adaptive Boosting&#xff09;算法的缩写&#xff0c;是一种基于 Boosting 策略的集成学习方法&#xff0c;旨在降低偏差。AdaBoost 的 “…

【面试HOT200】链表篇

系列综述&#xff1a; &#x1f49e;目的&#xff1a;本系列是个人整理为了秋招面试coding部分的&#xff0c;整理期间苛求每个算法题目&#xff0c;平衡可读性与代码性能&#xff08;leetcode运行复杂度均打败80%以上&#xff09;。 &#x1f970;来源&#xff1a;材料主要源于…

softmax函数的功能及用法

Softmax函数是一种常用的激活函数&#xff0c;通常用于多分类问题的输出层。其功能是将一个具有任意实数值的向量&#xff08;通常称为“logits”&#xff09;转换为一个概率分布&#xff0c;其中每个元素的值表示对应类别的概率。 Softmax函数的公式如下&#xff1a; 给定一…

选择最适合的JavaScript混淆工具:详解JScrambler、JShaman、IpaGuard等五款在线服务

摘要 本篇技术博客将介绍五款常用且好用的在线JavaScript加密混淆工具&#xff0c;包括 jscrambler、JShaman、jsfack、freejsobfuscator 和 jjencode。通过对这些工具的功能及使用方法进行详细解析&#xff0c;帮助开发人员更好地保护和加密其 JavaScript 代码&#xff0c;提…

如何优化嵌入式系统的实时性能

大家好&#xff0c;今天给大家介绍如何优化嵌入式系统的实时性能&#xff0c;文章末尾附有分享大家一个资料包&#xff0c;差不多150多G。里面学习内容、面经、项目都比较新也比较全&#xff01;可进群免费领取。 优化嵌入式系统的实时性能是一个综合性的任务&#xff0c;涉及到…

C++的并发世界(六)——互斥解决数据共享冲突

0.数据共享的问题 在多个线程中共享数据时。需要注意线程安全问题。如果多个线程同时访问同一个变量。并且其中至少有一个线程对该变量进行了写操作。那么就会出现数据竞争问题。数据竞争可能会导致程序崩溃,产生来定义的结果,或者得到错误的热果。为了避免数据竞争问题。需要…

真·面试题总结——JVM虚拟机

JVM虚拟机 JVM虚拟机规范与实现 JVM虚拟机规范 JVM虚拟机实现 JVM的常见实现 JVM虚拟机物理架构 JVM虚拟机的运转流程 JVM类加载过程 JVM类加载器及类加载器类型 JVM类加载器双亲委派机制 JVM运行时数据区的内存模型 JVM运行时数据区的内存模型&#xff1a;程序计数器…

Transformer - Outputs(Shifted Right)

Transformer - Outputs(Shifted Right) flyfish 输入: “je suis etudiant” 预期输出 : “i am a student” 除了普通词汇之外&#xff0c;模型还引入了一些特殊token&#xff0c;常有的&#xff08;start of sequence&#xff09;、&#xff08;end of sequence&#xff09;…

【linux】lsof命令使用

1. 功能 lsof list open files, 列出被进程所使用的文件名称。 2. 基础语法 3. 参数含义 参数含义-a过滤出多个选项要同时满足的文件-U仅列出UNIX-like系统的socket文件类型。-u指定用户&#xff0c;比如-u atiaisi&#xff0c;会把用户atiaisi相关的进程使用的文件列出来。…

线程池小项目【Linux C/C++】(踩坑分享)

目录 前提知识&#xff1a; 一&#xff0c;线程池意义 二&#xff0c;实现流程 阶段一&#xff0c;搭建基本框架 1. 利用linux第三方库&#xff0c;将pthread_creat线程接口封装 2. 实现基本主类ThreadPool基本结构 阶段二&#xff0c;完善多线程安全 1. 日志信息打印…

【JavaScript】函数 ⑥ ( 使用 arguments 获取所有实参 | arguments 内置对象 | 伪数组概念 )

文章目录 一、使用 arguments 获取所有实参1、arguments 内置对象2、伪数组概念3、arguments 实参遍历4、arguments 代码示例 - 基本使用5、arguments 代码示例 - 遍历实参 一、使用 arguments 获取所有实参 1、arguments 内置对象 在 定义 JavaScript 函数 时 , 有时 不确定 形…

工业设备远程控制

随着科技的飞速发展和工业4.0的深入实施&#xff0c;远程控制技术在工业领域的应用变得日益重要。HiWoo Box网关作为连接工业设备与远程控制中心的桥梁&#xff0c;凭借其卓越的性能和稳定性&#xff0c;为工业设备远程控制提供了强大的支持。 一、工业设备远程控制的意义 工…