02_线性模型(回归线性模型)

描述

线性模型是在实践中广泛使用的一类模型，线性模型利用输入特征的线性函数（linear function）进行预测。

用于回归的线性模型

对于回归问题，线性模型预测的一般公式如下：

$ \widehat y = w[0]*x[0]+w[1]*x[1]+…+w[p]*x[p]+b$

这里 x[0] 到 x[p] 表示单个数据点的特征（本例中特征个数为 p+1），w 和 b 是学习模型的参数， $ \widehat y $ 是模型的预测结果。

对于单一特征的数据集，公式如下：

$ \widehat y = w[0]*x[0]+ b$

这里 w[0] 是斜率，b 是 y 轴偏移。对于有更多特征的数据集，w 包含沿每个特征坐标轴的斜率。或者也可以将预测的响应值看作输入特征的加权求和，权重由 w 的元素给出（可以取负值）。

线性回归（最小二乘法）

线性回归是回归问题最简单也最经典的线性方法。线性回归寻找参数 w 和 b，使得对训练集的预测值与真实的回归目标值 y之间的均方误差最小。均方误差（mean squared error）是预测值与真实值之差的平方和除以样本数。线性回归没有参数，这是一个优点，但也因此无法控制模型的复杂度。

看一个例子:

import pandas as pd
import numpy as np
import mglearn
import warnings
warnings.filterwarnings('ignore')

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

X,Y = mglearn.datasets.make_wave(n_samples=60)
X_train,X_test,Y_train,Y_test = train_test_split(X,Y,random_state=42)

lr = LinearRegression().fit(X_train, Y_train)
# 斜率(w):coef_
# 偏移或截距(b):intercept_
print(lr.coef_,lr.intercept_)
# 训练集，测试集分数
print(lr.score(X_train, Y_train),lr.score(X_test, Y_test))

对于回归问题，score返回的是是 $R^2$ 分数（K近邻回归的例子中，KNeighborsRegressor的score返回的也是 $R^2$ 分数），也叫作决定系数，是回归模型预测的优度度量，位于 0 到 1 之间。

执行过上例会发现结果不是很好，训练集和测试集上的分数非常接近。这说明可能存在欠拟合，而不是过拟合。对于这个一维数据集来说，过拟合的风险很小，因为模型非常简单（或受限）。然而，对于更高维的数据集（即有大量特征的数据集），线性模型将变得更加强大，过拟合的可能性也会变大。

再看一个例子：

X,Y = mglearn.datasets.load_extended_boston()
X_train,X_test,Y_train,Y_test = train_test_split(X,Y,random_state=0)

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

print(lr.score(X_train, Y_train),lr.score(X_test, Y_test))

训练集和测试集之间的性能差异是过拟合的明显标志，因此我们应该试图找到一个可以控制复杂度的模型。标准线性回归最常用的替代方法之一就是岭回归

岭回归

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

from sklearn.linear_model import Ridge

ridge = Ridge().fit(X_train, Y_train)
print(ridge.score(X_train, Y_train),ridge.score(X_test, Y_test))

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

Ridge 模型在模型的简单性（系数都接近于 0）与训练集性能之间做出权衡。简单性和训练集性能二者对于模型的重要程度可以由用户通过设置 alpha 参数来指定（默认参数 alpha=1.0）。alpha的最佳设定值取决于用到的具体数据集。增大 alpha 会使得系数更加趋向于 0，从而降低训练集性能，但可能会提高泛化性能。

# 对比
ridge10 = Ridge(alpha=10).fit(X_train,Y_train)
print(ridge10.score(X_train, Y_train),ridge10.score(X_test, Y_test))

ridge03 = Ridge(alpha=0.3).fit(X_train,Y_train)
print(ridge03.score(X_train, Y_train),ridge03.score(X_test, Y_test))

学习曲线

将模型性能作为数据集大小的函数进行绘图，这样的图像叫作学习曲线。通过学习曲线可以直观的看到模型的大小对训练分数的影响

import pandas as pd
import numpy as np
import seaborn as sns
import mglearn
import warnings
warnings.filterwarnings('ignore')

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

# 加载数据
df_bst = pd.read_csv(r'..\..\seaborn-data\boston.csv')

# 固定 alpha 值，但改变训练数据量 / 或者 固定训练数据量，调整alpha
list_ret=[]
for i in range(10):
    df_sub = df_bst.sample(50 +i*50)
    s_medv = df_sub['MEDV']
    df_data = df_sub.drop("MEDV",axis=1)
    X_train,X_test,Y_train,Y_test = train_test_split(df_data,s_medv,random_state=42)
    lr = LinearRegression().fit(X_train, Y_train)
    ridge = Ridge().fit(X_train, Y_train)
    list_ret.append({
        'count':50 +i*50,
        'sorce':lr.score(X_train, Y_train),
        'type':'Linear_train'
        })
    list_ret.append({
        'count':50 +i*50,
        'sorce':lr.score(X_test, Y_test),
        'type':'Linear_test'
        })
    list_ret.append({
        'count':50 +i*50,
        'sorce':ridge.score(X_train, Y_train),
        'type':'Ridge_train'
        })
    list_ret.append({
        'count':50 +i*50,
        'sorce':ridge.score(X_test, Y_test),
        'type':'Ridge_test'
        })
    
    df_ret = pd.DataFrame(list_ret)
    sns.lineplot(df_ret,x='count',y='sorce',hue='type')

执行上例，从图中可以明显的看出无论是岭回归还是线性回归，所有数据集大小对应的训练分数都要高于测试分数。由于岭回归是正则化的，因此它的训练分数要整体低于线性回归的训练分数。随着模型可用的数据越来越多，两个模型的性能都在提升，最终线性回归的性能追上了岭回归。如果有足够多的训练数据，正则化变得不那么重要，并且岭回归和线性回归将具有相同的性能。

通过模型预测数据

# 根据模型，预测数据
s_medv = df_bst['MEDV']
df_data = df_bst.drop("MEDV",axis=1)
X_train,X_test,Y_train,Y_test = train_test_split(df_data,s_medv,random_state=42)
lr = LinearRegression().fit(X_train, Y_train)
ridge = Ridge().fit(X_train, Y_train)

array_lr = lr.predict(df_data)
array_ridge = ridge.predict(df_data)

df_pre = pd.DataFrame(index=df_data.index,data={'linear':array_lr,'ridge':array_ridge})
df_pre['medv']=s_medv

df_pre.plot(kind='line') # 图形化展示数据

# sns.lineplot(df_pre,x=df_pre.index,y='medv',color='r')
# sns.lineplot(df_pre,x=df_pre.index,y='ridge',color='r')
# sns.lineplot(df_pre,x=df_pre.index,y='linear',color='g')

lasso

还有一种正则化的线性回归是 Lasso，与岭回归相同，使用 lasso 也是约束系数使其接近于 0，但用到的方法不同，叫作 L1 正则化。 L1 正则化的结果是，使用 lasso 时某些系数刚好为 0。这说明某些特征被模型完全忽略。这可以看作是一种自动化的特征选择。某些系数刚好为 0，这样模型更容易解释，也可以呈现模型最重要的特征。

from sklearn.linear_model import Lasso

lasso = Ridge().fit(X_train, Y_train)
print(lasso.score(X_train, Y_train),lasso.score(X_test, Y_test))

执行上例，可以看到Lasso 在训练集与测试集上的表现都很差（欠拟合），与 Ridge 类似，Lasso 也有一个正则化参数 alpha（默认值 alpha=1.0），可以控制系数趋向于 0 的强度。为了降低欠拟合，可以尝试减小 alpha，同时还需要增加 max_iter 的值（运行迭代的最
大次数）

lasso001 = Ridge(alpha=0.01,max_iter=100000).fit(X_train, Y_train)
print(lasso.score(X_train, Y_train),lasso.score(X_test, Y_test))

alpha 值变小，可以拟合一个更复杂的模型，在训练集和测试集上的表现也更好。但如果把alpha设得太小，那么就会消除正则化的效果，并出现过拟合现象。