机器学习--线性回归

「这是我参与11月更文挑战的第15天，活动详情查看：2021最后一次更文挑战」。

1.1应用场景

• 房价预测
• 销售额度预测
• 贷款额度预测

1.2什么是线性回归

1.2.1定义与公式

线性回归是利用回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方式

• 特点：只有一个自变量的情况称为单变量回归，多于一个自变量情况的叫做多元回归

  • 通用公式：

    ​ $h(\theta)=\theta_1x_1+\theta_2x_2+\cdots +\theta_nx_n+b=\sum_{i=1}^n\theta_ix_i+b$

    • 其中$\theta_i$为模型系数，$x_i$为自变量(特征值)，b为模型的偏置
• 线性回归用矩阵表示举例

特征值与目标值之间建立了一个关系，这个关系可以理解为线性模型。

1.2.2线性回归的特征与目标的关系分析

线性回归中主要有两种模型，一种是线性关系，另一种是非线性关系。

• 线性关系

  • 单变量线性关系

• 多变量线性关系

注释：单特征与目标值的关系呈直线关系，或者多个特征与目标值呈平面关系。

• 非线性关系

二.线性回归api初步使用

2.1线性回归API

• sklearn.linear_model.LinearRegression()
  • LinearRegression.coef_:回归系数

2.2举例

2.2.1步骤分析

• 1.获取数据集
• 2.数据基本处理（该案例中省略）
• 3.特征工程（该案例中省略）
• 4.机器学习
• 5.模型评估（该案例中省略）

2.2.2代码

from sklearn.linear_model import LinearRegression

x = [[80, 86],
     [82, 80],
     [85, 78],
     [90, 90],
     [86, 82],
     [82, 90],
     [78, 80],
     [92, 94]]
y = [84.2, 80.6, 80.1, 90, 83.2, 87.6, 79.4, 93.4]

# 实例化API
estimator = LinearRegression()
# 使用fit方法进行训练
estimator.fit(x, y)

print(estimator.coef_)
print(estimator.predict([[100, 80]]))

结果：

[0.3 0.7]
[86.]

三.数学：求导

3.1常见函数的求导

3.2导数的四则运算

3.3矩阵（向量）求导

四.线性回归的损失和优化

4.1损失函数

总损失定义为：$J(\theta)=(h_\theta(x_1)-y_1)^2+(h_\theta(x_2)-y_2)^2+\cdots+(h_\theta(x_m)-y_m)^2=\sum_{i=1}^m(h_\theta(x_i)-y_i)^2$

• $y_i$为第$i$个训练样本的真实值
• $h(x_i)$为第$i$个训练样本特征值组合预测函数
• 又称最小二乘法

如何减少损失？运用数学中的求导功能去优化这个回归的总损失。

4.2优化算法

如何去求模型当中的$\theta$，使得损失最小（目的是找到最小损失对应的$\theta$值）

线性回归经常使用的两种优化算法：

1. 正规方程：根据样本数据直接计算一个最好的模型系数和偏置
2. 梯度下降：从一个任意的模型系数和偏置开始，一步一步进行优化，最终得到一个最好的模型系数和偏置

4.2.1正规方程

1. 什么是正规方程

   $\theta=(X^TX)^{-1}X^TY$

   X为特征值矩阵，Y为目标值矩阵，直接求到最好的结果

   缺点：当特征过多过于复杂时，求解速度太慢并且得不到结果

2. 正规方程求解举例

   以下表示数据为例：

即：

运用正规方程方法求解参数：

3. 正规方程的推导

   把该损失函数转换成矩阵写法：

   $J(\theta)=(h_\theta(x_1)-y_1)^2+(h_\theta(x_2)-y_2)^2+\cdots+(h_\theta(x_m)-y_m)^2=\sum_{i=1}^n(h_\theta(x_i)-y_i)^2=(X\theta-Y)^2$

   其中Y是真实值矩阵，X是特征值矩阵，$\theta$是权重矩阵

   对其求解关于$J(\theta)$的最小值，其实就是代入X，Y对$\theta$求导，倒数为零的位置，即为最小值。

   求导：

   1. $2(X\theta-Y)*X=0$
   2. $2(X\theta-Y)*(XX^T)=0*X^T$
   3. $2(X\theta-Y)*(XX^T)(XX^T)^{-1}=0*X^T(XX^T)^{-1}$
   4. $2(X\theta-Y)=0$
   5. $X\theta-Y=0$
   6. $X\theta=Y$
   7. $X^TX*\theta=Y$
   8. $(X^TX)^{-1}(X^TX)*\theta=(X^TX)^{-1}*X^TY$
   9. $\theta=(X^TX)^{-1}*X^TY$

   注意，1~2的推导过程，X是一个m行n列的矩阵，并不能保证其有逆矩阵，但是右乘$X^T$把其变成一个方阵，保证其有逆矩阵。

4.2.2梯度下降

1. 什么是梯度下降

   ​ 梯度下降法的基本思想可以类比为一个下山的过程。

   ​ 假设这样一个场景：一个人被困在山上，需要从山上下来(i.e. 找到山的最低点，也就是山谷)。但此时山上的浓雾很大，导致可视度很低。因此，下山的路径就无法确定，他必须利用自己周围的信息去找到下山的路径。这个时候，他就可以利用梯度下降算法来帮助自己下山。具体来说就是，以他当前的所处的位置为基准，寻找这个位置最陡峭的地方，然后朝着山的高度下降的地方走，（同理，如果我们的目标是上山，也就是爬到山顶，那么此时应该是朝着最陡峭的方向往上走）。然后每走一段距离，都反复采用同一个方法，最后就能成功的抵达山谷。

   ​ 梯度下降的基本过程就和下山的场景很类似。

   ​ 首先，我们有一个可微分的函数。这个函数就代表着一座山。

   ​ 我们的目标就是找到这个函数的最小值，也就是山底。

   ​ 根据之前的场景假设，最快的下山的方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度 ，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数之变化最快的方向。 所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部的最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。

2. 梯度的概念

   ​ 梯度是微积分中一个很重要的概念

   ​ 在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率

   ​ 在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向

   ​ 这也就说明了为什么我们需要千方百计的求取梯度！我们需要到达山底，就需要在每一步观测到此时最陡峭的地方，梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向，这正是我们所需要的。所以我们只要沿着梯度的反方向一直走，就能走到局部的最低点！

3. 梯度下降举例

   • 单变量函数的梯度下降

     我们假设有一个单变量的函数：$J(\theta)=\theta^2$

     函数的微积分：$J'(\theta)=2\theta$

     初始化，起点为：$\theta^0=1$

     学习率：$\alpha=0.4$

     然后开始进行梯度下降的迭代计算过程：

如图，经过四次的运算，也就是走了四步，基本就抵达了函数的最低点，也就是山底

• 多变量函数的梯度下降

  我们假设有一个目标函数：$J(\theta)=\theta_1^2+\theta_2^2$

  现在要通过梯度下降法计算这个函数的最小值。假设：

  初始的起点为：$\theta^0=(1,3)$

  初始的学习率为：$\alpha=0.1$

  函数的梯度为：$\nabla:J(\theta)=<2\theta_1,2\theta_2>$

  进行多次迭代：

这个时候，已经基本靠近函数的最小值点：

4. 梯度下降公式

   $\theta_i=\theta_i-\alpha\frac{\partial}{\partial\theta_i}J(\theta)$

   • $\alpha$是什么含义

     α在梯度下降算法中被称作为学习率或者步长，意味着我们可以通过α来控制每一步走的距离，以保证不要步子跨的太大扯着蛋，哈哈，其实就是不要走太快，错过了最低点。同时也要保证不要走的太慢，导致太阳下山了，还没有走到山下。所以α的选择在梯度下降法中往往是很重要的！α不能太大也不能太小，太小的话，可能导致迟迟走不到最低点，太大的话，会导致错过最低点！

• 为什么梯度要乘以一个负号

  梯度前加一个负号，就意味着朝着梯度相反的方向前进！我们在前文提到，梯度的方向实际就是函数在此点上升最快的方向！而我们需要朝着下降最快的方向走，自然就是负的梯度的方向，所以此处需要加上负号

  我们通过两个图更好理解梯度下降的过程

所以有了梯度下降这样一个优化算法，回归就有了"自动学习"的能力

• 梯度下降和正规方程的对比

  梯度下降	正规方程
  需要选择学习率	不需要
  需要迭代求解	一次运算得出
  特征数量较大可以使用	需要计算方程，时间复杂度高达$O(n^3)$

• 选择

  • 小规模数据
    • LinearRegression(不能解决拟合问题)
    • 岭回归
  • 大规模数据：SGDRegressor

五.梯度下降法介绍

常见的梯度下降算法有：

• 全梯度下降算法
• 随机梯度下降算法
• 随机平均梯度下降算法
• 小批量梯度下降算法

它们都是为了正确地调节权重向量，通过为每个权重计算一个梯度，从而更新权值，使目标函数尽可能最小化

5.1全梯度下降算法（FG）

​ 计算训练集所有样本误差，对其求和再取平均值作为目标函数。

​ 权重向量沿其梯度相反的方向移动，从而使当前目标函数减少得最多。

​ 因为在执行每次更新时，我们需要在整个数据集上计算所有的梯度，所以批梯度下降法的速度会很慢，同时，批梯度下降法无法处理超出内存容量限制的数据集。

​ 批梯度下降法同样也不能在线更新模型，即在运行的过程中，不能增加新的样本。

​ 其实在整个训练数据集上计算损失函数关于参数θ的梯度：

​ $\theta=\theta=\eta\cdot\nabla_\theta J(\theta)$

5.2随机梯度下降算法（SG）

​ 由于FG每迭代更新一次权重都需要计算所有样本误差，而实际问题中经常有上亿的训练样本，故效率偏低，且容易陷入局部最优解，因此提出了随机梯度下降算法。

​ 其每轮计算的目标函数不再是全体样本误差，而仅是单个样本误差，即每次只代入计算一个样本目标函数的梯度来更新权重，再取下一个样本重复此过程，直到损失函数值停止下降或损失函数值小于某个可以容忍的阈值。

​ 此过程简单，高效，通常可以较好地避免更新迭代收敛到局部最优解。其迭代形式为：

​ $\theta=\theta-\eta\cdot\nabla_\theta J(\theta;x^{(i)};y^{(i)})$

其中，$x^{(i)}$表示一条训练样本的特征值，$y^{(i)}$表示一条训练样本的标签值

但是由于，SG每次只使用一个样本迭代，若遇上噪声则容易陷入局部最优解。

5.3小批量梯度下降算法(mini-bantch)

​ 小批量梯度下降算法是FG和SG的折中方案,在一定程度上兼顾了以上两种方法的优点。

​ 每次从训练样本集上随机抽取一个小样本集，在抽出来的小样本集上采用FG迭代更新权重。

​ 被抽出的小样本集所含样本点的个数称为batch_size，通常设置为2的幂次方，更有利于GPU加速处理。

​ 特别的，若batch_size=1，则变成了SG；若batch_size=n，则变成了FG.其迭代形式为：

​ $\theta=\theta-\eta\cdot\nabla_\theta J(\theta;x^{i:i+n};y^{i:i+n})$

5.4随机平均梯度下降算法(SAG)

​ 在SG方法中，虽然避开了运算成本大的问题，但对于大数据训练而言，SG效果常不尽如人意，因为每一轮梯度更新都完全与上一轮的数据和梯度无关。

​ 随机平均梯度算法克服了这个问题，在内存中为每一个样本都维护一个旧的梯度，随机选择第i个样本来更新此样本的梯度，其他样本的梯度保持不变，然后求得所有梯度的平均值，进而更新了参数。

​ 如此，每一轮更新仅需计算一个样本的梯度，计算成本等同于SG，但收敛速度快得多。

5.5算法比较

1. FG方法由于它每轮更新都要使用全体数据集，故花费的时间成本最多，内存存储最大。
2. SAG在训练初期表现不佳，优化速度较慢。这是因为我们常将初始梯度设为0，而SAG每轮梯度更新都结合了上一轮梯度值。
3. 综合考虑迭代次数和运行时间，SG表现性能都很好，能在训练初期快速摆脱初始梯度值，快速将平均损失函数降到很低。但要注意，在使用SG方法时要慎重选择步长，否则容易错过最优解。
4. mini-batch结合了SG的“胆大”和FG的“心细”，从6幅图像来看，它的表现也正好居于SG和FG二者之间。在目前的机器学习领域，mini-batch是使用最多的梯度下降算法，正是因为它避开了FG运算效率低成本大和SG收敛效果不稳定的缺点。

5.6梯度下降优化算法

以下这些算法主要用于深度学习优化：

• 动量法
  • 其实动量法(SGD with monentum)就是SAG的姐妹版
  • SAG是对过去K次的梯度求平均值
  • SGD with monentum 是对过去所有的梯度求加权平均
• Nesterov加速梯度下降法
  • 类似于一个智能球，在重新遇到斜率上升时候，能够知道减速
• Adagrad
  • 让学习率使用参数
  • 对于出现次数较少的特征，我们对其采用更大的学习率，对于出现次数较多的特征，我们对其采用较小的学习率。
• Adadelta
  • Adadelta是Adagrad的一种扩展算法，以处理Adagrad学习速率单调递减的问题。
• RMSProp
  • 其结合了梯度平方的指数移动平均数来调节学习率的变化。
  • 能够在不稳定（Non-Stationary）的目标函数情况下进行很好地收敛。
• Adam
  • 结合AdaGrad和RMSProp两种优化算法的优点。
  • 是一种自适应的学习率算法

六.线性回归API再介绍

• sklearn.linear_model.LinearRegression(fit_intercept=True)

  • 通过正规方程优化
  • fit_intercept：是否计算偏置
  • LinearRegression.coef_：回归系数_
  • LinearRegression.intercept：偏置

• sklearn.linear_model.SGDRegressor(loss="squared_loss", fit_intercept=True, learning_rate ='invscaling', eta0=0.01)

  • SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型。
  • loss:损失类型
    • loss=”squared_loss”: 普通最小二乘法
  • fit_intercept：是否计算偏置
  • learning_rate : string, optional
    • 学习率填充
    • 'constant': eta = eta0
    • 'optimal': eta = 1.0 / (alpha * (t + t0)) [default]
    • 'invscaling': eta = eta0 / pow(t, power_t)
      • power_t=0.25:存在父类当中
    • 对于一个常数值的学习率来说，可以使用learning_rate=’constant’ ，并使用eta0来指定学习率。
  • SGDRegressor.coef_：回归系数
  • SGDRegressor.intercept_：偏置

七.案例：波士顿房价预测

• 数据介绍

7.1分析

回归当中的数据大小不一致，所以需要做标准化处理

• 数据分割与标准化处理
• 回归预测
• 线性回归的算法效果评估

7.2回归性能分析

均方误差评价机制：

​ $MSE=\frac{1}{m}\sum_{i=1}^m(y_i-\overline{y})^2$

注：$y_i$为预测值，$\overline{y}$为真实值

• sklearn.metrics.mean_squared_error(y_true, y_pred)
  • 均方误差回归损失
  • y_true:真实值
  • y_pred:预测值
  • return:浮点数结果

7.3代码

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor

# mean_squared_error(均方误差): (预测值-真实值)平方求和/样本数量
# mean_absolute_error(平均绝对误差)(预测值-真实值)绝对值求和/样本数量
from sklearn.metrics import mean_squared_error, mean_absolute_error


def linear_regression():
    # 1.加载数据集
    data = load_boston()

    # 2.数据的基本处理
    x_train, x_test, y_train, y_test = \
        train_test_split(data.data, data.target, test_size=0.25, random_state=8)

    # 3.特征工程，标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4.机器学习，模型训练：LinearRegression
    estimator = LinearRegression()
    estimator.fit(x_train, y_train)

    # 5.模型评估
    print('模型系数', estimator.coef_)
    print('模型偏置', estimator.intercept_)

    # 6.预测
    y_pre = estimator.predict(x_test)
    print('预测值 - 真实值', y_pre - y_test)

    # 7.模型评估
    # 均方误差
    mse = mean_squared_error(y_test, y_pre)
    print('均方误差', mse)
    # 平均绝对误差
    mae = mean_absolute_error(y_test, y_pre)
    print('平均绝对误差', mae)


def linear_SGDRegressor():
    # 1.加载数据集
    data = load_boston()

    # 2.数据的基本处理（分割数据集）
    x_train, x_test, y_train, y_test = \
        train_test_split(data.data, data.target, test_size=0.25, random_state=8)

    # 3.特征工程（特征预处理，标准化）
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4.机器学习：模型训练 SGDRegressor
    estimator = SGDRegressor()
    estimator.fit(x_train, y_train)

    # 5.模型评估
    print('模型系数', estimator.coef_)
    print('模型偏置', estimator.intercept_)
    # 预测
    y_pre = estimator.predict(x_test)
    print('预测值 - 真实值', y_pre - y_test)

    # 模型评估
    # 均方误差
    mse = mean_squared_error(y_test, y_pre)
    print('均方误差', mse)
    # 平均绝对误差
    mae = mean_absolute_error(y_test, y_pre)
    print('平均绝对误差', mae)


if __name__ == '__main__':
    # linear_regression()
    linear_SGDRegressor()

然后就可以通过调整参数，找到学习率效果更好的值。

八.欠拟合和过拟合

8.1定义

• 过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
• 欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)

8.2原因及解决办法

• 欠拟合原因以及解决办法
  • 原因：学习到数据的特征过少
  • 解决办法：
    • 1）添加其他特征项，有时候我们模型出现欠拟合的时候是因为特征项不够导致的，可以添加其他特征项来很好地解决。例如，“组合”、“泛化”、“相关性”三类特征是特征添加的重要手段，无论在什么场景，都可以照葫芦画瓢，总会得到意想不到的效果。除上面的特征之外，“上下文特征”、“平台特征”等等，都可以作为特征添加的首选项。
    • 2）添加多项式特征，这个在机器学习算法里面用的很普遍，例如将线性模型通过添加二次项或者三次项使模型泛化能力更强。
• 过拟合原因以及解决办法
  • 原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点
  • 解决办法：
    • 1）重新清洗数据，导致过拟合的一个原因也有可能是数据不纯导致的，如果出现了过拟合就需要我们重新清洗数据。
    • 2）增大数据的训练量，还有一个原因就是我们用于训练的数据量太小导致的，训练数据占总数据的比例过小。
    • 3）正则化
    • 4）减少特征维度，防止维灾难

8.3正则化

8.3.1什么是正则化

​ 在学习的时候，数据提供的特征有些影响模型复杂度或者这个特征的数据点异常较多，所以算法在学习的时候尽量减少这个特征的影响（甚至删除某个特征的影响），这就是正则化。

8.3.2正则化类别

• L2正则化
  • 作用：可以使得其中一些θ的都很小，都接近于0，削弱某个特征的影响
  • 优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
  • Ridge回归
• L1正则化
  • 作用：可以使得其中一些θ的值直接为0，删除这个特征的影响
  • LASSO回归

8.4维灾难

8.4.1什么是维灾难

随着维度的增加，分类器性能逐步上升，到达某点后，其性能便逐渐下降

8.4.2维数灾难与过拟合

​ 过多的特征导致的过拟合现象：训练集上表现良好，但是对新数据缺乏泛化能力

​ 高维空间训练形成的线性分类器，相当于在低维空间的一个复杂的非线性分类器，这种分类器过多的强调了训练集的准确率甚至于对一些错误/异常的数据也进行了学习，而正确地数据却无法覆盖整个特征空间。为此，这样得到的分类器在对新数据进行预测时将会出现错误。这种现象称之为过拟合，同时也是维灾难的直接体现。

​ 简单的线性分类器在训练数据上的表现不如非线性分类器，但由于线性分类器的学习过程中对噪声没有对非线性分类器敏感，因此对新数据具备更优的泛化能力。换句话说，通过使用更少的特征，避免了维数灾难的发生(也即避免了高维情况下的过拟合)。

​ 当两个点位于相同的单位超立方体内时，两点如何分离？这个事实意味着高维数据集有可能非常稀疏：大多数训练实例可能彼此远离。当然，这也意味着一个新实例可能离任何训练实例都很远，这使得预测的可信度表现得比在低维度数据中要来的差。训练集的维度越多，过度拟合的风险就越大。

​ 理论上讲，维度灾难的一个解决方案可能是增加训练集的大小以达到足够密度的训练实例。 不幸的是，在实践中，达到给定密度所需的训练实例的数量随着维度的数量呈指数增长。 如果只有100个特征（比MNIST问题少得多），那- 么为了使训练实例的平均值在0.1以内，需要比可观察宇宙中的原子更多的训练实例，假设它们在所有维度上均匀分布。

​ 如果理论无限数量的训练样本可用，则维度的诅咒不适用，我们可以简单地使用无数个特征来获得完美的分类。训练数据的大小越小，应使用的功能就越少。如果N个训练样本足以覆盖单位区间大小的1D特征空间，则需要N ^ 2个样本来覆盖具有相同密度的2D特征空间，并且在3D特征空间中需要N ^ 3个样本。换句话说，所需的训练实例数量随着使用的维度数量呈指数增长。

九.正则化线性模型

9.1Ridge Regression(岭回归)

岭回归是线性回归的正则化版本，即在原来的线性回归的cost function中添加L2正则项：$\alpha\sum_{i=1}^n\theta_i^2$

以达到在拟合数据的同时，使模型权重尽可能小的目的，岭回归代价函数：

• $\alpha=0$：岭回归退化为线性回归
• 为什么说L2正则化：可以使得其中一些$\theta$的值很小，都接近于0，削弱某个特征的影响

  • L2正则化项，假设正则化力度$\eta=\frac{1}{2}L_2=\frac{1}{2}(\theta_1^2+\theta_2^2+\cdots+\theta_n^2)$，其导数$\frac{dL_2}{d\theta_i}=\theta_i$

  • 我们假定：$\theta_i$等于不为0的某个正的浮点数，学习速率$\alpha=0.5$

    • L2梯度下降，权值更新公式为：$\theta_i=\theta_i-\alpha*\theta_i=\theta_i-0.5*\theta_i$

9.2Lasso Regression(Lasso回归)

Lasso回归是线性回归的另一个正则化版本，正则项为权值向量的$l_1$范数

Lasso回归的代价函数：

【注意】

• Lasso Regression的代价函数在$\theta_i=0$处是不可导的

• 解决办法：在$\theta_i=0$处用一个次梯度向量代替梯度，如下式

• Lasso Regression的次梯度向量

Lasso Regression有一个很重要的性质是：倾向于完全消除不重要的权重

为什么说L1正则化：可以使得其中一些$\theta$的值直接为0，删除这个特征的影响

• L1正则化项，假设正则化力度$\eta=1:L_1=\theta_1+\theta_2+\cdots\theta_n$，其导数$\frac{dL_i}{d\theta_i}=sign(\theta_i)$
• 我们假定：$\theta_i$等于不为0的某个正的浮点数，学习速率$\alpha$为0.5
  • $L_1$梯度下降，权值更新公式：$\theta_i=\theta_i-\alpha*1=\theta_i-0.5$

9.3Elastic Net(弹性网络)

弹性网络在岭回归和Lasso回归中进行了折中，通过 混合比(mix ratio) r 进行控制：

• r=0：弹性网络变为岭回归
• r=1：弹性网络便为Lasso回归

弹性网络的代价函数：

一般来说，我们应避免使用朴素线性回归的，而应对模型进行一定的正则化处理，那如何选择正则化方法呢？

小结：

• 常用：岭回归

• 假设只有少部分特征是有用的：

  • 弹性网络
  • Lasso
  • 一般来说，弹性网络的使用更为广泛。因为在特征维度高于训练样本数，或者特征是强相关的情况下，Lasso回归的表现不太稳定。

• api:

  from sklearn.linear_model import Ridge, ElasticNet, Lasso
  

9.4Early Stopping

Early Stopping 也是正则化迭代学习的方法之一。

其做法为：在验证错误率达到最小值的时候停止训练。

十.线性回归的改进-岭回归

10.1 API

• sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, solver="auto", normalize=False)
  • 具有l2正则化的线性回归
  • alpha:正则化力度，也叫 λ
    • λ取值：01 110
  • solver:会根据数据自动选择优化方法
    • sag:如果数据集、特征都比较大，选择该随机梯度下降优化
  • normalize:数据是否进行标准化
    • normalize=False:可以在fit之前调用preprocessing.StandardScaler标准化数据
  • Ridge.coef_:回归权重
  • Ridge.intercept_:回归偏置

Ridge方法相当于SGDRegressor(penalty='l2', loss="squared_loss"),只不过SGDRegressor实现了一个普通的随机梯度下降学习，推荐使用Ridge(实现了SAG)

• sklearn.linear_model.RidgeCV(_BaseRidgeCV, RegressorMixin)
  • 具有l2正则化的线性回归，可以进行交叉验证
  • coef_:回归系数

class _BaseRidgeCV(LinearModel):
    def __init__(self, alphas=(0.1, 1.0, 10.0),
                 fit_intercept=True, normalize=False,scoring=None,
                 cv=None, gcv_mode=None,
                 store_cv_values=False):

10.2正则化程度的变化对结果的影响

• 正则化力度越大，权重系数会越小
• 正则化力度越小，权重系数会越大

10.3波士顿房价预测

def linear_model3():
    # 1.获取数据
    data = load_boston()

    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, random_state=22)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-线性回归(岭回归)
    estimator = Ridge(alpha=1)
    # estimator = RidgeCV(alphas=(0.1, 1, 10))
    estimator.fit(x_train, y_train)

    # 5.模型评估
    # 5.1 获取系数等值
    y_predict = estimator.predict(x_test)
    print("预测值为:\n", y_predict)
    print("模型中的系数为:\n", estimator.coef_)
    print("模型中的偏置为:\n", estimator.intercept_)

    # 5.2 评价
    # 均方误差
    error = mean_squared_error(y_test, y_predict)
    print("误差为:\n", error)

十一.模型的保存和加载

11.1 sklearn模型的保存和加载API

• from sklearn.externals import joblib
  • 保存：joblib.dump(estimator, 'test.pkl')
  • 加载：estimator = joblib.load('test.pkl')

11.2线性回归的模型保存和加载案例

def load_dump_demo():
    """
    线性回归:岭回归
    :return:
    """
    # 1.获取数据
    data = load_boston()

    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, random_state=22)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-线性回归(岭回归)
    # # 4.1 模型训练
    # estimator = Ridge(alpha=1)
    # estimator.fit(x_train, y_train)
    #
    # # 4.2 模型保存
    # joblib.dump(estimator, "./data/test.pkl")

    # 4.3 模型加载
    estimator = joblib.load("./data/test.pkl")

    # 5.模型评估
    # 5.1 获取系数等值
    y_predict = estimator.predict(x_test)
    print("预测值为:\n", y_predict)
    print("模型中的系数为:\n", estimator.coef_)
    print("模型中的偏置为:\n", estimator.intercept_)

    # 5.2 评价
    # 均方误差
    error = mean_squared_error(y_test, y_predict)
    print("误差为:\n", error)