线性回归之多项式回归、过拟合（正则化）

目录

1.多项式回归

2.模型复杂度

3.样本数量对结果（过拟合）的影响：

4.正则化避免过拟合

1.多项式回归

构建符合曲线的数据点

m = 100    #随便构造二次函数
X = 6*np.random.rand(m,1) - 3
y = 0.5*X**2+X+np.random.randn(m,1)

plt.plot(X,y,'b.')
plt.xlabel('X_1')
plt.ylabel('y')
plt.axis([-3,3,-5,10])
plt.show()

回归方程应该是位于这些点中的一条曲线

现在我们只有X_1和y不足以做出一条曲线去拟合它。因此我们需要它们的平方、乘积等，次方越高，曲线越复杂，越能够满足当前的数据点的要求。我们引入sklearn里的polynomial函数（API文档如下）。举例：有a、b两个特征，当指定degree=2时，就获得方括号内的数据（1，a、...、a的平方、ab等）

from sklearn.preprocessing import PolynomialFeatures
poly_features = PolynomialFeatures(degree = 2,include_bias = False)
X_poly = poly_features.fit_transform(X)    #fit是具体执行平方等操作
X[0]                                #transform是将具体执行获得的数据打包传回

这样我们就有了X和X的平方，让数据变得丰富了一些。

用sklearn计算回归方程得到三个数据，表示回归方程为y=1.1x+0.53x**2-0.037，这就与我们开头随便定义的二次函数（y = 0.5*X**2+X+np.random.randn(m,1)）相近。我们拿着数据点通过多项式变换之后确实能够得到一个多项式回归方程。

X_new = np.linspace(-3,3,100).reshape(100,1)    #数据点
X_new_poly = poly_features.transform(X_new)    #多项式转换
y_new = lin_reg.predict(X_new_poly)            #进行预测
plt.plot(X,y,'b.')
plt.plot(X_new,y_new,'r--',label='prediction')
plt.axis([-3,3,-5,10])
plt.legend()
plt.show()

2.模型复杂度

当degree为1、2、100时的拟合情况

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
plt.figure(figsize=(12,6))
for style,width,degree in (('g-',1,100),('b--',1,2),('r-+',1,1)):
    poly_features = PolynomialFeatures(degree = degree,include_bias = False)
    std = StandardScaler()
    lin_reg = LinearRegression()
    polynomial_reg = Pipeline([('poly_features',poly_features),
             ('StandardScaler',std),
             ('lin_reg',lin_reg)])
    polynomial_reg.fit(X,y)
    y_new_2 = polynomial_reg.predict(X_new)
    plt.plot(X_new,y_new_2,style,label = 'degree   '+str(degree),linewidth = width)
plt.plot(X,y,'b.')
plt.axis([-3,3,-5,10])
plt.legend()
plt.show()

degree为1就是线性回归，2就能够比较好地去拟合数据点的趋势，而100想要拟合全部数据点，这就会导致过拟合严重，在训练集上做的好，但是在测试集上就做的差。因此模型并不是越复杂越好，适合才是最好的。

3.样本数量对结果（过拟合）的影响：

从sklearn中导入计算均方误差的函数和切分数据集（训练集和验证集）的函数

from sklearn.metrics import mean_squared_error    #均方误差函数
from sklearn.model_selection import train_test_split    #切分数据集函数

def plot_learning_curves(model,X,y):    #切分比例为2：8（0.2）
    X_train, X_val, y_train, y_val = train_test_split(X,y,test_size = 0.2,random_state=100)
    train_errors,val_errors = [],[]
    for m in range(1,len(X_train)):    #每次样本增加一个看看损失函数值的变化情况
        model.fit(X_train[:m],y_train[:m])
        y_train_predict = model.predict(X_train[:m])
        y_val_predict = model.predict(X_val)
        train_errors.append(mean_squared_error(y_train[:m],y_train_predict[:m]))
        val_errors.append(mean_squared_error(y_val,y_val_predict))

    plt.plot(np.sqrt(train_errors),'r-+',linewidth = 2,label = 'train_error')
    plt.plot(np.sqrt(val_errors),'b-',linewidth = 3,label = 'val_error')
    plt.xlabel('Trainsing set size')
    plt.ylabel('RMSE')
    plt.legend()

可以看出，当样本少的时候，在训练集上的误差比较小，但是验证集的误差比较大，表示在图上就是两条线之间的缝隙大，这就是过拟合了。当样本数量逐渐增多时，缝隙也逐渐减小，表示模型比较稳定了，不管在测试集还是验证集上发挥的效果都差不多。因此数据样本越多越好，发生过拟合的风险就越低

多项式的过拟合同样如此，而且多项式越多，也就是次方越大，模型越复杂，过拟合的风险就越高，下图可以看出，样本少的时候过拟合已经非常严重。

polynomial_reg = Pipeline([('poly_features',PolynomialFeatures(degree = 25,include_bias = False)),
             ('lin_reg',LinearRegression())])
plot_learning_curves(polynomial_reg,X,y)
plt.axis([0,80,0,5])
plt.show()

4.正则化避免过拟合

假设θ1为[4，0，0，0]，θ2为[1，1，1，1] ，X为[1，1，1，1]，那么θ1X和θ2X的乘积完全一样，对于机器而言他们的损失值也完全一样，但θ1的第一个特征权重过大，其余特征完全没用，而θ2更能全面考察数据的特征，为了让机器选择θ2，我们就要额外进行操作，这个操作就是正则化。

正则化公式如下：MSE是原来的损失值，根据上面所说，两个θ的损失值相同，后面这一项就是正则损失。对于θ1：正则损失为1的平方+0的平方+..0的平方为1。对于θ2：正则损失为4个1/4的平方也就是1/4。因此θ2总损失值更小，选择θ2。

sklearn中提供的一种正则化方法（岭回归，也称为L2正则化回归）：前面这一项就是MSE，后面这一项就是正则损失，alpha为惩罚力度，越大就代表越不希望过拟合现象发生。

from sklearn.linear_model import Ridge
np.random.seed(42)
m = 20
X = 3*np.random.rand(m,1)
y = 0.5 * X +np.random.randn(m,1)/1.5 +1 #任意定义的函数
X_new = np.linspace(0,3,100).reshape(100,1)

def plot_model(model_calss,polynomial,alphas,**model_kargs): #引入岭回归
    for alpha,style in zip(alphas,('b-','g--','r:')): #不同alpha值对应不同的线条
        model = model_calss(alpha,**model_kargs)
        if polynomial: #polynomial是否为true，是就多项式转换，没有就跳过此步骤
            model = Pipeline([('poly_features',PolynomialFeatures(degree =10,include_bias = False)),
             ('StandardScaler',StandardScaler()),
             ('lin_reg',model)])

        model.fit(X,y)
        y_new_regul = model.predict(X_new) #预测值
        lw = 2 if alpha > 0 else 1 #不同正则化的线条宽度
        plt.plot(X_new,y_new_regul,style,linewidth = lw,label = 'alpha = {}'.format(alpha))
    plt.plot(X,y,'b.',linewidth =3)
    plt.legend() #展示图例
#打印图片
plt.figure(figsize=(14,6))
plt.subplot(122)
plot_model(Ridge,polynomial=True,alphas = (0,10**-5,1))
plt.show()

下图是多项式转换后的不同正则化惩罚力度的曲线（plot_model(Ridge,polynomial=True,alphas = (0,10**-5,1))），蓝色曲线时惩罚力度alpha为0，也就是没有进行正则化，它的浮动范围大，这个模型就不稳定。绿色曲线的alpha为10**-5，就能够让曲线比较平稳。继续增大alpha为1，红色曲线就几乎没有波动了，此时就是一个比较稳定的模型。

另外一种正则化方法（lasso），公式如下，就是将正则损失替换为了绝对值，用法跟岭回归差不多。需要注意的是，惩罚力度并不是越大越好，以下就是反例，红色曲线几乎变成了直线，过大的惩罚力度会使模型过于简单，无法捕捉数据中的基本结构和模式，导致模型在训练集和测试集上都表现不佳，也就是导致了欠拟合。

from sklearn.linear_model import Lasso

plt.figure(figsize=(14,6))
plt.subplot(122)
plot_model(Lasso,polynomial=True,alphas = (0,10**-1,1))
plt.show()

正则化的目的是控制模型的复杂度，防止过拟合，提高模型的泛化能力。