alphas=np.logspace(-2,2,50) test_scores1=[] test_scores2=[] for alpha in alphas: clf=ridge(alpha) scores1=np.sqrt(cross_val_score(clf,train_X,train_y,cv=5)) scores2=np.sqrt(cross_val_score(clf,train_X,train_y,cv=10)) test_scores1.append(1-np.mean(scores1)) test_scores2.append(1-np.mean(scores2)) #从图中找出正则化参数alpha为时，误差最小 plt.plot(alphas,test_scores1,color='red') plt.plot(alphas,test_scores1,color='green')

这段代码看起来是用于进行岭回归的交叉验证，并绘制不同正则化参数 alpha 对应的测试误差。其中，`alphas=np.logspace(-2,2,50)` 生成了 50 个等比数列的正则化参数 alpha，接着使用循环遍历每个 alpha 值，对应地训练并使用交叉验证计算模型在训练数据上的误差，最后将误差结果保存到 `test_scores1` 和 `test_scores2` 列表中。

最后，使用 `plt.plot(alphas,test_scores1,color='red')` 和 `plt.plot(alphas,test_scores1,color='green')` 分别绘制了 alpha 值与测试误差的关系图，其中 `color='red'` 和 `color='green'` 指定了绘制颜色为红色和绿色。需要注意的是，这两个 `plot()` 函数的第二个参数都应该是 `test_scores2`，而不是 `test_scores1`，因为第一个 `plot()` 函数已经使用了 `test_scores1`。

相关问题

写出以下任务代码。实验任务：对boston数据集进行回归任务 使用scikit-learn自带的boston数据集，完成下列任务： 1导入数据后，对其进行预处理(包括缺失值填充、one-hot编码、标准化等) 2.1使用标准的线性回归模型（LinearRegression）对数据进行建模，计算在test上的评价指标。 2.2 对数据的目标变量y进行处理，重复上述模型，得到比2.1更准确的模型，计算在test上的评价指标。 3.1 使用Ridge(岭回归)完成2.1的任务，对比结果，进行说明 3.2对3.1的Ridge回归，选择最优的超参alpha，需要画出必要的图形 3.3 针对3.2的任务，对数据的目标变量y进行处理，重复任务

3.2得到最优的超参alpha，计算在test上的评价指标。

以下是对应的代码实现：

# 导入数据集
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error, r2_score

import numpy as np
import matplotlib.pyplot as plt

# 加载数据集
boston = load_boston()
X, y = boston['data'], boston['target']

# 数据集预处理
num_features = [0, 4, 5, 6, 7, 9, 10, 12]
cat_features = [8]
num_transformer = Pipeline([('scaler', StandardScaler())])
cat_transformer = OneHotEncoder(handle_unknown='ignore')
preprocessor = ColumnTransformer(transformers=[
    ('num', num_transformer, num_features),
    ('cat', cat_transformer, cat_features)])

# 分割训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 线性回归模型
lr_model = Pipeline([('preprocessor', preprocessor), ('lr', LinearRegression())])
lr_model.fit(X_train, y_train)
lr_y_pred = lr_model.predict(X_test)
print("Linear Regression")
print("MSE:", mean_squared_error(y_test, lr_y_pred))
print("R^2:", r2_score(y_test, lr_y_pred))
print()

# 处理y变量再进行线性回归
y_log = np.log1p(y_train)
lr_model2 = Pipeline([('preprocessor', preprocessor), ('lr', LinearRegression())])
lr_model2.fit(X_train, y_log)
lr_y_pred2 = np.expm1(lr_model2.predict(X_test))
print("Linear Regression with processed y")
print("MSE:", mean_squared_error(y_test, lr_y_pred2))
print("R^2:", r2_score(y_test, lr_y_pred2))
print()

# 岭回归模型
ridge_model = Pipeline([('preprocessor', preprocessor), ('ridge', Ridge())])
param_grid = [{'ridge__alpha': np.logspace(-3, 3, 13)}]
ridge_grid = GridSearchCV(ridge_model, param_grid=param_grid, cv=10, scoring='r2')
ridge_grid.fit(X_train, y_train)
ridge_y_pred = ridge_grid.predict(X_test)
print("Ridge Regression")
print("MSE:", mean_squared_error(y_test, ridge_y_pred))
print("R^2:", r2_score(y_test, ridge_y_pred))
print()

# 处理y变量再进行岭回归
y_log2 = np.log1p(y_train)
ridge_model2 = Pipeline([('preprocessor', preprocessor), ('ridge', Ridge())])
ridge_grid2 = GridSearchCV(ridge_model2, param_grid=param_grid, cv=10, scoring='r2')
ridge_grid2.fit(X_train, y_log2)
ridge_y_pred2 = np.expm1(ridge_grid2.predict(X_test))
print("Ridge Regression with processed y")
print("MSE:", mean_squared_error(y_test, ridge_y_pred2))
print("R^2:", r2_score(y_test, ridge_y_pred2))
print()

# 画出alpha与R^2的关系图
alphas = ridge_grid2.cv_results_['param_ridge__alpha'].data
r2_scores = ridge_grid2.cv_results_['mean_test_score']
plt.semilogx(alphas, r2_scores)
plt.xlabel('Alpha')
plt.ylabel('R^2')
plt.title('Ridge Regression with Processed y')
plt.show()

建议保存代码并在本地运行。

使用岭回归、套索回归、和最小二乘法的线性回归预测波士顿房价,并画出不同alpha值下面的准确度的图像

岭回归、套索回归（Lasso Regression）和最小二乘法都是用于线性回归的统计模型，它们的区别在于对模型复杂性和变量选择的方式：

1. **最小二乘法**是最基础的线性回归方法，它通过最小化残差平方和来确定系数，适用于数据中存在完全线性的关系。这种方法对于多重共线性敏感，即当自变量之间高度相关时，可能会导致不稳定的结果。

2. **岭回归**是一种正则化的形式，引入了一个惩罚项（通常是一个L2 norm，相当于每个系数的平方），随着惩罚因子α的增大，模型会倾向于减少特征的数量，防止过拟合。α=0就等同于普通最小二乘法。

3. **套索回归**（也称为L1 Regularization）与岭回归类似，但它的惩罚项是L1 norm，也就是绝对值之和。这使得一些系数变为0，实现了特征选择的作用，因此常用于高维数据集中的变量筛选。

要在Python中，比如使用sklearn库，可以这样做：

from sklearn.datasets import load_boston
from sklearn.linear_model import Ridge, Lasso, LinearRegression
import matplotlib.pyplot as plt

# 加载波士顿房价数据
boston = load_boston()
X, y = boston.data, boston.target

# 初始化不同α值
alphas = np.logspace(-4, 4, 100)

# 对三种方法分别计算准确度并保存结果
ridge_scores = []
lasso_scores = []
ols_scores = []

for alpha in alphas:
    ridge = Ridge(alpha=alpha)
    lasso = Lasso(alpha=alpha)
    ols = LinearRegression()

    ridge.fit(X, y)
    lasso.fit(X, y)
    ols.fit(X, y)

    ridge_scores.append(ridge.score(X, y))
    lasso_scores.append(lasso.score(X, y))
    ols_scores.append(ols.score(X, y))

# 绘制三条曲线
plt.plot(alphas, ridge_scores, label='Ridge')
plt.plot(alphas, lasso_scores, label='Lasso')
plt.plot(alphas, ols_scores, label='OLS', linestyle='dashed')  # 线性回归用虚线表示
plt.xlabel('Alpha')
plt.ylabel('Accuracy')
plt.xscale('log')
plt.legend()
plt.show()

图中会显示不同α值下的岭回归、套索回归和最小二乘法的预测准确度变化情况。一般来说，随着α增加，Lasso的准确度可能会先上升然后下降，因为它会在某些点上设为0；Ridge的准确度变化较为平滑，因为其不会将系数全部置零。