波士顿房价预测案例（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模块作为一种前沿的数据采集和故障提醒系统，已经成为该行业内不可或缺的一部分。本文将深入探讨GRM560模块的功能及其在医药行业中的应用。 正文： 在当今…
阅读更多...
29.使线程以固定顺序输出结果

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语言：文件操作（一）

C语言：文件操作（一）

目录 前言 1、为什么使用文件 2、什么是文件 2.1 程序文件 2.2 数据文件 2.3 文件名 3、文件的打开和关闭 3.1 文件指针 3.2 文件的打开和关闭 结（一） 前言 本篇文章将介绍C语言的文件操作，在后面的内容讲到：为什么使用文…
阅读更多...
C++的并发世界（五）——线程状态切换

C++的并发世界（五）——线程状态切换

0.线程状态 初始化：该线程正在被创建； 就绪：该线程在列表中就绪，等待CPU调度； 运行：该线程正在运行； 阻塞：该线程被阻塞挂机，Blocked状态包括：pend&#xff…
阅读更多...
Apache DolphinScheduler 【安装部署】

Apache DolphinScheduler 【安装部署】

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

Golang 开发实战day07 - Functions

Golang 教程07 - Functions 1. Functions 1.1 什么是函数？ 在 Golang 中，函数就像是代码的超级组合体，可以将一段代码封装成一个独立的单元，以便重复使用。 1.2 函数声明 func funcName(parameter1 type1, parameter2 type2)…
阅读更多...
Leetcode刷题-数组（二分法、双指针法、窗口滑动）

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

数组 1、二分法 704. 二分查找 - 力扣&#xff08;LeetCode&#xff09; 需要注意区间的问题。首先在最外面的循环判断条件是left<right。那就说明我们区间规定的范围就是【left,right】 属于是左闭右闭&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&…
阅读更多...
一文让你彻底理解 AdaBoost 自适应提升算法 | AdaBoost 的关键要点、基本原理、优缺点和实际应用

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

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

【面试HOT200】链表篇

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

softmax函数的功能及用法

Softmax函数是一种常用的激活函数&#xff0c;通常用于多分类问题的输出层。其功能是将一个具有任意实数值的向量&#xff08;通常称为“logits”&#xff09;转换为一个概率分布&#xff0c;其中每个元素的值表示对应类别的概率。 Softmax函数的公式如下&#xff1a; 给定一…
阅读更多...
选择最适合的JavaScript混淆工具：详解JScrambler、JShaman、IpaGuard等五款在线服务

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

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

Copyright @ 2022~2023