【机器学习】2. 线性模型 - 岭回归

上一篇：【普通最小二乘法】

岭回归

Ridge 回归通过对系数的大小施加惩罚来解决 普通最小二乘法 的一些问题。
岭系数最小化的是带罚项的残差平方和，
$$\underset{w}{\min }||Xw-y|{|}_{2}2+\alpha ||w|{|}_{2}2$$
其中，$\alpha \ge 0$ 是控制系数收缩量的复杂性参数： $\alpha$ 的值越大，收缩量越大，这样系数对共线性的鲁棒性也更强。
与其他线性模型一样， Ridge 用fit 方法将模型系数 $w$ 存储在其 coef_成员中:

>>> from sklearn import linear_model
>>> reg = linear_model.Ridge (alpha = .5)
>>> reg.fit ([[0, 0], [0, 0], [1, 1]], [0, .1, 1]) 
Ridge(alpha=0.5, copy_X=True, fit_intercept=True, max_iter=None,
normalize=False, random_state=None, solver='auto', tol=0.001)
>>> reg.coef_
array([ 0.34545455,  0.34545455])
>>> reg.intercept_ 
0.13636...

---

岭回归的复杂度： 与普通最小二乘法相同

---

设置正则化参数：广义交叉验证
RidgeCV通过内置的 $Alpha$ 参数的交叉验证来实现岭回归。 该对象与 $GridSearchCV$ 的使用方法相同，只是它默认为 $GeneralizedCross-Validation(广义交叉验证GCV)$，这是一种有效的留一验证方法（LOO-CV）:

>>> from sklearn import linear_model
>>> reg = linear_model.RidgeCV(alphas=[0.1, 1.0, 10.0])
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])       
RidgeCV(alphas=[0.1, 1.0, 10.0], cv=None, fit_intercept=True, scoring=None,
normalize=False)
>>> reg.alpha_                                      
0.1

岭回归也是一种用于回归的线性模型，因此它的预测公式与普通最小二乘法相同。
但在岭回归中，对系数（w）的选择不仅要在训练数据上得到好的预测结果，而且还要拟合附加约束。我们还希望系数尽量小。
换句话说，w的所有元素都应接近于0。直观上来看，这意味着每个特征对输出的影响应尽可能小（即斜率很小），同时仍给出很好的预测结果。
这种约束是所谓正则化（regularization）的一个例子。正则化是指对模型做显式约束，以避免过拟合。
岭回归用到的这种被称为L2正则化。

岭回归在linear model.Ridge中实现。来看一下它对扩展的波士顿房价数据集的效果如何：

from sklearn.linear_model import Ridge
import mglearn as mglearn
from sklearn.model_selection import train_test_split

X, y = mglearn.datasets.load_extended_boston()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

ridge = Ridge().fit(X_train, y_train)

# 训练集和测试集的性能
print("Training set score: {:.2f}".format(ridge.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge.score(X_test, y_test)))


==========================================

Training set score: 0.89
Test set score: 0.75

Ridge在训练集上的分数要低于LinearRegression，但在测试集上的分数更高。这和我们的预期一致。

线性回归对数据存在过拟合。Ridge是一种约束更强的模型，所以更不容易过拟合。
复杂度更小的模型意味着在训练集上的性能更差，但泛化性能更好。
由于我们只对泛化性能感兴趣，所以应该选择Ridge模型而不是LinearRegression模型。

Ridge模型在模型的简单性（系数都接近于0）与训练集性能之间做出权衡。
简单性和训练集性能二者对于模型的重要程度可以由用户通过设置alpha参数来指定。
在前面的例子中，我们用的是默认参数alpha=1.0。但没有理由认为这会给出最佳权衡。alpha的最佳设定值取决于用到的具体数据集。

增大alpha

增大alpha会使得系数更加趋向于0，从而降低训练集性能，但可能会提高泛化性能。
例如：

ridge10 = Ridge(alpha=10).fit(X_train, y_train)

# 训练集和测试集的性能
print("Training set score: {:.2f}".format(ridge10.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge10.score(X_test, y_test)))

===================================

Training set score: 0.79
Test set score: 0.64

减小alpha

减小alpha可以让系数受到的限制更小，即在图中向右移动。

对于非常小的alpha值，系数几乎没有受到限制，我们得到一个与LinearRegression类似的模型：

ridge01 = Ridge(alpha=0.1).fit(X_train, y_train)

# 训练集和测试集的性能
print("Training set score: {:.2f}".format(ridge01.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge01.score(X_test, y_test)))

========================================

Training set score: 0.93
Test set score: 0.77

这里alpha=0.1似乎效果不错。我们可以尝试进一步减小alpha以提高泛化性能.

alpha与模型复杂度的对应关系

我们还可以查看alpha取不同值时模型的coef属性，从而更加定性地理解alpha参数是如何改变模型的。
更大的alpha表示约束更强的模型，所以我们预计大alpha对应的coef元素比小alpha对应的coef元素要小。

##############################
# 制图
plt.plot(ridge.coef_, 's', label="Ridge_alpha = 1")
plt.plot(ridge10.coef_, '^', label="Ridge_alpha = 10")
plt.plot(ridge01.coef_, 'v', label="Ridge_alpha = 0.1")
plt.plot(lr.coef_, 'o', label="LinearRegression")

plt.xlabel("Coefficient_index")
plt.ylabel("Coefficient_magnitude")
plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25, 25)
plt.legend()
plt.show()

这里x轴对应coef的元素：

• x=0对应第一个特征的系数
• x=1对应第二个特征的系数
• 以此类推，一直到x=100。
  y轴表示该系数的具体数值。

这里需要记住的是

• 对于alpha=10，系数大多在-3和3之间
• 对于alpha=1的Ridge模型，系数要稍大一点
• 对于alpha=0.1，点的范围更大。
  对于没有做正则化的线性回归（即alpha=0），点的范围很大，许多点都超出了图像的范围。

还有一种方法可以用来理解正则化的影响，就是固定alpha值，但改变训练数据量。
我们对波士顿房价数据集做二次抽样，并在数据量逐渐增加的子数据集上分别对LinearRegression和Ridge(alpha=1)两个模型进行评估（将模型性能作为数据集大小的函数进行绘图，这样的图像叫作学习曲线）：

mglearn.plots.plot_ridge_n_samples()

正如所预计的那样，无论是岭回归还是线性回归，所有数据集大小对应的训练分数都要高于测试分数。
由于岭回归是正则化的，因此它的训练分数要整体低于线性回归的训练分数。但岭回归的测试分数要更高，特别是对较小的子数据集。
如果少于400个数据点，线性回归学不到任何内容。随着模型可用的数据越来越多，两个模型的性能都在提升，最终线性回归的性能追上了岭回归。
这里要记住的是，如果有足够多的训练数据，正则化变得不那么重要，并且岭回归和线性回归将具有相同的性能（在这个例子中，二者相同恰好发生在整个数据集的情况下，这只是一个巧合）。
图中还有一个有趣之处，就是线性回归的训练性能在下降。如果添加更多数据，模型将更加难以过拟合或记住所有的数据。

完整代码

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge

import mglearn as mglearn
import matplotlib.pyplot as plt

X, y = mglearn.datasets.load_extended_boston()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

##################### LinearRegression

lr = LinearRegression().fit(X_train, y_train)

# 训练集和测试集的性能
print("\n[LinearRegression]")
print("Training set score: {:.2f}".format(lr.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lr.score(X_test, y_test)))

##################### Ridge

########### Ridge_alpha = 1

ridge = Ridge().fit(X_train, y_train)

# 训练集和测试集的性能
print("\n[Ridge_alpha = 1]")
print("Training set score: {:.2f}".format(ridge.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge.score(X_test, y_test)))

########## Ridge_alpha = 10

ridge10 = Ridge(alpha=10).fit(X_train, y_train)

# 训练集和测试集的性能
print("\n[Ridge_alpha = 10]")
print("Training set score: {:.2f}".format(ridge10.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge10.score(X_test, y_test)))

########## Ridge_alpha = 0.1

ridge01 = Ridge(alpha=0.1).fit(X_train, y_train)

# 训练集和测试集的性能
print("\n[Ridge_alpha = 0.1]")
print("Training set score: {:.2f}".format(ridge01.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge01.score(X_test, y_test)))


#################### 制图
plt.plot(ridge.coef_, 's', label="Ridge_alpha = 1")
plt.plot(ridge10.coef_, '^', label="Ridge_alpha = 10")
plt.plot(ridge01.coef_, 'v', label="Ridge_alpha = 0.1")
plt.plot(lr.coef_, 'o', label="LinearRegression")

plt.xlabel("Coefficient_index")
plt.ylabel("Coefficient_magnitude")
plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25, 25)
plt.legend()

mglearn.plots.plot_ridge_n_samples()
plt.show()