ybdx是什么文件2.2 线性回归api初步使用

3 导数的四则运算

4 练习

1. ,求
5. , 求

答案：

• 常见函数的求导方式和导数的四则运算

• 知道线性回归中损失函数
• 知道使用正规方程对损失函数优化的过程
• 知道使用梯度下降法对损失函数优化的过程

如何确定回归方程

• 算法训练出来的回归方程， 是否会满足所有的样本？
  • 允许误差存在
  • 目标，回归方程的结果与实际值的误差最小

• 既然存在误差，如何衡量误差？

总损失定义为：

• 为第个训练样本的真实值
• 为第个训练样本特征值组合预测函数,也称为目标函数
  • 目标函数(objective function)是指所关心的目标(某一变量)与相关的因素(某些变量)的函数关系。简单的说，就是你求解后所得出的那个函数。
• 又称最小二乘法

如何去减少这个损失，使我们预测的更加准确些？既然存在了这个损失，我们一直说机器学习有自动学习的功能，在线性回归这里更是能够体现。这里可以通过一些优化方法去优化（其实是数学当中的求导功能）回归的总损失！！！

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

• 线性回归经常使用的两种优化算法
  • 正规方程
  • 梯度下降法

2.1 正规方程

2.1.1 什么是正规方程

理解：X为特征值矩阵，y为目标值矩阵。直接求到最好的结果

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

2.1.2 正规方程求解举例

以下表示数据为例：

即：

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

2.2 梯度下降(Gradient Descent)

2.2.1 什么是梯度下降

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

假设这样一个场景：

一个人被困在山上，需要从山上下来(i.e. 找到山的最低点，也就是山谷)。但此时山上的浓雾很大，导致可视度很低。

因此，下山的路径就无法确定，他必须利用自己周围的信息去找到下山的路径。这个时候，他就可以利用梯度下降算法来帮助自己下山。

具体来说就是，以他当前的所处的位置为基准，寻找这个位置最陡峭的地方，然后朝着山的高度下降的地方走，（同理，如果我们的目标是上山，也就是爬到山顶，那么此时应该是朝着最陡峭的方向往上走）。然后每走一段距离，都反复采用同一个方法，最后就能成功的抵达山谷。

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

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

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

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

2.2.2 梯度的概念

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

• 在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率；
• 在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向；
  • 在微积分里面，对多元函数的参数求∂偏导数，把求得的各个参数的偏导数以向量的形式写出来，就是梯度。

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

2.2.3 梯度下降举例

• 1. 单变量函数的梯度下降

我们假设有一个单变量的函数 :

函数的微分：

初始化，起点为(已知的起始位置)：

学习率(步长)：

我们开始进行梯度下降的迭代计算过程:

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

• 2.多变量函数的梯度下降

我们假设有一个目标函数 ：

现在要通过梯度下降法计算这个函数的最小值。我们通过观察就能发现最小值其实就是 (0，0)点。但是接下
来，我们会从梯度下降算法开始一步步计算到这个最小值!
我们假设初始的起点为：

初始的学习率(步长)：

函数的梯度为：

进行多次迭代：
$$
begin{eqnarray}
Theta^0 &=& (1, 3)
Theta^1 &=& Theta^0-alphaDelta J(Theta)
&=&(1,3)-0.1(2,6)
&=&(0.8, 2.4)
Theta^2 &=& (0.8, 2.4)-0.1(1.6, 4.8)
&=&(0.64, 1.92)
Theta^3 &=& (0.512, 1.536)
Theta^4 &=& (0.4096, 1.2288)
vdots
Theta^{10} &=& (0.10737418240000003, 0.32212254720000005)
vdots
Theta^{50} &=& (1.1417981541647683e^{-5}, 3.425394462494306e^{-5})
vdots
Theta^{100} &=& (1.6296287810675902e^{-10}, 4.888886343202771e^{-10})

end{eqnarray}
$$

我们发现，已经基本靠近函数的最小值点

2.2.4 梯度下降**（**Gradient Descent）公式

• 1) 是什么含义？

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

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

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

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

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

• 优化动态图演示

3.1 两种方法对比

经过前面的介绍，我们发现最小二乘法适用简洁高效，比梯度下降这样的迭代法似乎方便很多。但是这里我们就聊聊最小二乘法的局限性。

• 首先，最小二乘法需要计算的逆矩阵，有可能它的逆矩阵不存在，这样就没有办法直接用最小二乘法了。
  • 此时就需要使用梯度下降法。当然，我们可以通过对样本数据进行整理，去掉冗余特征。让的行列式不为0，然后继续使用最小二乘法。
• 第二，当样本特征n非常的大的时候，计算的逆矩阵是一个非常耗时的工作（nxn的矩阵求逆），甚至不可行。
  • 此时以梯度下降为代表的迭代法仍然可以使用。
  • 那这个n到底多大就不适合最小二乘法呢？如果你没有很多的分布式大数据计算资源，建议超过10000个特征就用迭代法吧。或者通过主成分分析降低特征的维度后再用最小二乘法。
• 第三，如果拟合函数不是线性的，这时无法使用最小二乘法，需要通过一些技巧转化为线性才能使用，此时梯度下降仍然可以用。
• 第四，以下特殊情况：
  • 当样本量m很少，小于特征数n的时候，这时拟合方程是欠定的，常用的优化方法都无法去拟合数据。
  • 当样本量m等于特征数n的时候，用方程组求解就可以了。
  • 当m大于n时，拟合方程是超定的，也就是我们常用与最小二乘法的场景了。

3.2 算法选择依据：

• 小规模数据：
  • 正规方程：LinearRegression
  • 岭回归: Ridge
• 大规模数据：
  • 梯度下降法：SGDRegressor

• 损失函数【知道】
  • 最小二乘法
• 线性回归优化方法【知道】
  • 正规方程
  • 梯度下降法
• 正规方程 – 一蹴而就【知道】
  • 只是适合样本和特征比较少的情况
• 梯度下降法 – 循序渐进【知道】
  • 梯度的概念
    • 单变量 – 切线
    • 多变量 – 向量
  • 梯度下降法中关注的两个参数
    • α – 就是步长
      • 步长太小 – 下山太慢
      • 步长太大 – 容易跳过极小值点
    • 为什么梯度要加一个负号
      • 梯度方向是上升最快方向,负号就是下降最快方向
• 梯度下降法和正规方程选择依据【知道】
  • 小规模数据：
    • 正规方程：LinearRegression
    • 岭回归: Ridge
  • 大规模数据：
    • 梯度下降法：SGDRegressor

• 了解全梯度下降算法的原理
• 了解随机梯度下降算法的原理
• 了解随机平均梯度下降算法的原理
• 了解小批量梯度下降算法的原理

首先，我们来看一下，常见的梯度下降算法有：

• 全梯度下降算法(Full gradient descent),
• 随机梯度下降算法(Stochastic gradient descent),
• 小批量梯度下降算法(Mini-batch gradient descent),
• 随机平均梯度下降算法(Stochastic average gradient descent)

它们都是为了正确地调节权重向量，通过为每个权重计算一个梯度，从而更新权值，使目标函数尽可能最小化。其差别在于样本的使用方式不同。

1.1 全梯度下降算法(FG)

批量梯度下降法，是梯度下降法最常用的形式，具体做法也就是在更新参数时使用所有的样本来进行更新。

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

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

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

由于我们有m个样本，这里求梯度的时候就用了所有m个样本的梯度数据。

注意：

• 因为在执行每次更新时，我们需要在整个数据集上计算所有的梯度，所以批梯度下降法的速度会很慢，同时，全梯度下降法无法处理超出内存容量限制的数据集。
• 全梯度下降法同样也不能在线更新模型，即在运行的过程中，不能增加新的样本。

1.2 随机梯度下降算法(SG)

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

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

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

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

1.3 小批量梯度下降算法(mini-batch)

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

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

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

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

上式中，也就是我们从m个样本中，选择x个样本进行迭代(1<x<m),

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

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

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

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

其迭代形式为：

• 我们知道sgd是当前权重减去步长乘以梯度，得到新的权重。sag中的a，就是平均的意思，具体说，就是在第k步迭代的时候，我考虑的这一步和前面n-1个梯度的平均值，当前权重减去步长乘以最近n个梯度的平均值。
• n是自己设置的，当n=1的时候，就是普通的sgd。
• 这个想法非常的简单，在随机中又增加了确定性，类似于mini-batch sgd的作用，但不同的是，sag又没有去计算更多的样本，只是利用了之前计算出来的梯度，所以每次迭代的计算成本远小于mini-batch sgd，和sgd相当。效果而言，sag相对于sgd，收敛速度快了很多。这一点下面的论文中有具体的描述和证明。
• SAG论文链接：https://arxiv.org/pdf/1309.2388.pdf

• 全梯度下降算法(FG)【了解】
  • 在进行计算的时候,计算所有样本的误差平均值,作为我的目标函数
• 随机梯度下降算法(SG)【了解】
  • 每次只选择一个样本进行考核
• 小批量梯度下降算法(mini-batch)【了解】
  • 选择一部分样本进行考核
• 随机平均梯度下降算法(SAG)【了解】
  • 会给每个样本都维持一个平均值,后期计算的时候,参考这个平均值

• 了解正规方程的api及常用参数
• 了解梯度下降法api及常用参数
• 知道如何对线性回归模型进行评估

1 线性回归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_：偏置

sklearn提供给我们两种实现的API， 可以根据选择使用

2 案例：波士顿房价预测

2.1 案例背景介绍

• 数据介绍

给定的这些特征，是专家们得出的影响房价的结果属性。我们此阶段不需要自己去探究特征是否有用，只需要使用这些特征。到后面量化很多特征需要我们自己去寻找

2.2 案例分析

回归当中的数据大小不一致，是否会导致结果影响较大。所以需要做标准化处理。

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

2.3 回归性能评估

均方误差(Mean Squared Error, MSE)评价机制：

注：为预测值， 为真实值

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

2.4 代码实现

导包

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

正规方程

# 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.transform(x_test)

# 4.机器学习-线性回归(正规方程)
estimator = LinearRegression()
estimator.fit(x_train, y_train)

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

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

梯度下降法

# 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 = SGDRegressor(max_iter=1000)
estimator.fit(x_train, y_train)

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

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

我们也可以尝试去修改学习率

estimator = SGDRegressor(max_iter=1000,learning_rate="constant",eta0=0.1)

此时我们可以通过调参数，找到学习率效果更好的值。

• 正规方程
  • sklearn.linear_model.LinearRegression()
• 梯度下降法
  • sklearn.linear_model.SGDRegressor(）
• 线性回归性能评估【知道】
  • 均方误差：sklearn.metrics.mean_squared_error

• 掌握过拟合、欠拟合的概念
• 掌握过拟合、欠拟合产生的原因
• 知道什么是正则化，以及正则化的分类

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

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

• 过拟合和欠拟合的区别：

  

  • 欠拟合在训练集和测试集上的误差都较大
  • 过拟合在训练集上误差较小，而测试集上误差较大

• 通过代码认识过拟合和欠拟合

  • 绘制数据

    import numpy as np
    import matplotlib.pyplot as plt
    
    np.random.seed(666)
    # np.random.uniform() 在[-3,3)范围内随机生成100个数
    x = np.random.uniform(-3,3,size = 100)
    
    # 转换成二维数组,变成一列
    X = x.reshape(-1,1)
    # np.random.normal() 生成100个符合正态分布的数,均值为0,标准差为1
    y = 0.5* x**2 + x+2 + np.random.normal(0,1,size = 100)
    
    from sklearn.linear_model import LinearRegression
    estimator = LinearRegression()
    estimator.fit(X,y)
    y_predict = estimator.predict(X)
    
    plt.scatter(x,y)
    plt.plot(x,y_predict,color = 'r')
    plt.show()
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CzcbY6qe-1633775046331)(./pics/1.png)]

    #计算均方误差
    from sklearn.metrics import mean_squared_error
    mean_squared_error(y,y_predict)
    
    #3.0750025765636577
    
    

  • 添加二次项，绘制图像

    # 添加二次项
    X2 = np.hstack([X,X**2])
    estimator2 = LinearRegression()
    estimator2.fit(X2,y)
    y_predict2 = estimator2.predict(X2)
    
    plt.scatter(x,y)
    plt.plot(np.sort(x),y_predict2[np.argsort(x)],color = 'r')
    plt.show()
    
    #计算均方误差和准确率
    
    from sklearn.metrics import mean_squared_error
    mean_squared_error(y,y_predict2)
    
    #1.0987392142417858
    
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UijKgjjr-1633775046333)(./pics/2.png)]

  • 再次加入高次项，绘制图像，观察均方误差结果

    X5 = np.hstack([X2,X**3,X**4,X**5,X**6,X**7,X**8,X**9,X**10])
    
    estimator3 = LinearRegression()
    estimator3.fit(X5,y)
    y_predict5 = estimator3.predict(X5)
    
    plt.scatter(x,y)
    plt.plot(np.sort(x),y_predict5[np.argsort(x)],color = 'r')
    plt.show()
    
    error = mean_squared_error(y, y_predict5)
    error
    
    #1.0508466763764157
    
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IeoldN73-1633775046334)(./pics/3.png)]

  通过上述观察发现，随着加入的高次项越来越多，拟合程度越来越高，均方误差也随着加入越来越小。说明已经不再欠拟合了。

  问题：如何判断出现过拟合呢？

  • 将数据集进行划分：对比X、X2、X5的测试集的均方误差

    • X的测试集均方误差

      X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 5)
      estimator = LinearRegression()
      estimator.fit(X_train,y_train)
      y_predict = estimator.predict(X_test)
      
      mean_squared_error(y_test,y_predict)
      #3.153139806483088
      
      

    • X2的测试集均方误差

      X_train,X_test,y_train,y_test = train_test_split(X2,y,random_state = 5)
      estimator = LinearRegression()
      estimator.fit(X_train,y_train)
      y_predict = estimator.predict(X_test)
      mean_squared_error(y_test,y_predict)
      #1.111873885731967
      
      

    • X5的测试集的均方误差

      X_train,X_test,y_train,y_test = train_test_split(X5,y,random_state = 5)
      estimator = LinearRegression()
      estimator.fit(X_train,y_train)
      y_predict = estimator.predict(X_test)
      mean_squared_error(y_test,y_predict)
      #1.4145580542309835
      
      

• 欠拟合原因以及解决办法
  • 原因：学习到数据的特征过少
  • 解决办法：
    • **1）添加其他特征项，**有时候我们模型出现欠拟合的时候是因为特征项不够导致的，可以添加其他特征项来很好地解决。
    • 2）添加多项式特征，这个在机器学习算法里面用的很普遍，例如将线性模型通过添加二次项或者三次项使模型泛化能力更强。
• 过拟合原因以及解决办法
  • 原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点
  • 解决办法：
    • 1）重新清洗数据，导致过拟合的一个原因也有可能是数据不纯导致的，如果出现了过拟合就需要我们重新清洗数据。
    • 2）增大数据的训练量，还有一个原因就是我们用于训练的数据量太小导致的，训练数据占总数据的比例过小。
    • 3）正则化
    • 4）减少特征维度

3.1 什么是正则化

在解决回归过拟合中，我们选择正则化。但是对于其他机器学习算法如分类算法来说也会出现这样的问题，除了一些算法本身作用之外（决策树、神经网络），我们更多的也是去自己做特征选择，包括之前说的删除、合并一些特征

如何解决？

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

注：调整时候，算法并不知道某个特征影响，而是去调整参数得出优化的结果

3.2 正则化类别

• L2正则化
  • 作用：可以使得其中W的变小，其中很小的w值会趋近于0，削弱某些特征的影响
  • 优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
  • Ridge回归: from sklearn.linear_model import Ridge
• L1正则化
  • 作用：可以使得其中一些特征W的值直接为0，删除这些特征的影响
  • LASSO回归: from sklearn.linear_model import Lasso
• 正则化案例

X10 = np.hstack([X2,X**3,X**4,X**5,X**6,X**7,X**8,X**9,X**10]) 
estimator3 = LinearRegression() 
estimator3.fit(X10,y) 
y_predict3 = estimator3.predict(X10) 

plt.scatter(x,y) 
plt.plot(np.sort(x),y_predict3[np.argsort(x)],color = 'r') 
plt.show()

# 打印回归系数
estimator3.coef_

## 展示结果
array([ 1.32292089e+00,  2.03952017e+00, -2.88731664e-01, -1.24760429e+00,
        8.06147066e-02,  3.72878513e-01, -7.75395040e-03, -4.64121137e-02,
        1.84873446e-04,  2.03845917e-03])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Otgvd6Pb-1633775046335)(data:image/png;base64,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)]

from sklearn.linear_model import Lasso  # L1正则
from sklearn.linear_model import Ridge  # 岭回归 L2正则

X10 = np.hstack([X2,X**3,X**4,X**5,X**6,X**7,X**8,X**9,X**10]) 
estimator_l1 = Lasso(alpha=0.005,normalize=True) # 调整alpha 正则化强度 查看正则化效果 normalize=True 数据标准化
estimator_l1.fit(X10,y) 
y_predict_l1 = estimator_l1.predict(X10) 

plt.scatter(x,y) 
plt.plot(np.sort(x),y_predict_l1[np.argsort(x)],color = 'r') 
plt.show()

estimator_l1.coef_  # Lasso 回归  L1正则 会将高次方项系数变为0

array([ 0.97284077,  0.4850203 ,  0.        ,  0.        , -0.        ,
        0.        , -0.        ,  0.        , -0.        ,  0.        ])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BKq2eSH9-1633775046336)(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXAAAAD5CAYAAAA+0W6bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAoOklEQVR4nO3deXxU1f3/8deHECCgAgqKBBC0ihsqmLqh1qrgrtFa3OvWUnfcqFhr3WpFcbetlVatFr64YlRQUYuCKFhBVBRQLNVCQEQx/NiEhJzfHyfBLDOZ7c5yZ97PxyOPkMnNvWfC5HPPfM7nnGPOOUREJHxaZbsBIiKSHAVwEZGQUgAXEQkpBXARkZBSABcRCSkFcBGRkGod6wAzewQ4FvjaObd73WNbAk8CvYEvgCHOue9inatLly6ud+/eKTRXRKTwzJo16xvnXNemj1usOnAzOxhYDTzeIIDfAaxwzo00sxFAZ+fcNbEaUVZW5mbOnJnUExARKVRmNss5V9b08ZgpFOfcVGBFk4dPAB6r+/djQHmqDRQRkcQkmwPfxjm3tO7fXwHbRDvQzIaa2Uwzm7l8+fIkLyciIk2lPIjpfA4mah7GOTfaOVfmnCvr2rVZCkdERJKUbABfZmbbAtR9/jq4JomISDySDeAvAGfX/fts4PlgmiMiIvGKp4xwHHAI0MXMFgM3ACOBp8zsfOBLYEg6GykiEkYVsysZNelTllSto3unEoYf0Zfy/qWBnT9mAHfOnRblW4cF1goRkRCLFKgBrh0/h3XVGwGorFrHtePnAAQWxGMGcBERia5idmXEQN2uuNWmx+qtq97IqEmfKoCLiOSCUZM+jRiomz5Wb0nVusCurbVQRERSkGhA7t6pJLBrK4CLiKQgWkDuVFJMSXFRo8dKios25ceDoAAuIpKC4Uf0jRiobzx+N247qR+lnUowoLRTCbed1C+zVSgiIhJdfUCOVi4YZMBuSgFcRCRF5f1LowfqefPgkkvg4Ych4OW0FcBFRNKluhrOOgu++ALatQv89ArgIiLpcsstMGsWPPssdOsW+Ok1iCkikg4zZsCtt8LZZ8NJJ6XlEuqBi4i0IKn1TFatgjPOgJ494b770tY2BXARkSiiTZOHGNUlw4b5vPebb0LHjmlrn1IoIiJRRJsmP2rSp9F/6Nln4dFHYcQIOOigtLZPAVxEJIpo0+SjTp+vrIShQ6GsDG68MX0Nq6MALiISRbRp8hEfr62Fc86B77+HsWOhuDi9jUMBXEQkqmjT5COuZ3LfffD663D33bDTThlpnwYxRUSiiDVNfpMPPvA57+OP9ymUDDG/qXxmlJWVuZkzZ2bseiIiabd2Ley9N6xcCR99BF26BH4JM5vlnCtr+rh64CIiqbjqKpg/H157LS3BuyUK4CKSt9K5qXDF7Epm3P0wI8f8lbEHD6HDVrtQHsiZ46cALiJ5KelJOHGe+75HJ/PcM6P4qNuPuHGf02gd8IbF8VAViojkpaQm4cTprpfnMrLiDlrXbuSy44ZTXVQc2LkToQAuInkp4Uk4CTjx5cfYd9HHXD/oQr7Y8oced5AbFsdDAVxE8lJCk3AS8dZbDHt7HON3+ynP7X5osOdOkAK4iOSlhCbhxOubb1h38hAqO3fj+kEXBnvuJGgQU0TyUtyTcOLlHF+ddBpbfvsNF551F2vatt/0rU4lxdx4/G4ZHcAEBXARyWMt7lWZqHvvpdtbr3PD4b/mk212aPStDm1bZzx4g1IoIiKx/fvfcM01TNpxPx4bcGyzb2d68LKeeuAiUlASntzz3Xdwyims7bINvzn6cjBrdkimBy/rpRTAzewK4JeAA+YA5zrnvg+iYSIiQaqYXclNL37Cd2urNz0Wc3JPba3fVb6ykmG/vIeV7TZrdohBxgcv6yWdQjGzUuAyoMw5tztQBJwaVMNERIJSPyuzYfCu1+IEnNtug4kT4Z57eH2L3hEPcWR29mVDqebAWwMlZtYaaA8sSb1JIiLBijQrs6GIOezXXoPrr4fTT4eLLoqaJinNUvoEUgjgzrlK4E7gf8BSYKVz7tWmx5nZUDObaWYzly9fnnxLRUSSFGuQsVlwXrTIB+5dd4XRo8EsPXXlKUolhdIZOAHoA3QHOpjZmU2Pc86Nds6VOefKunbtmnxLRUSS1NIgY7MgvGEDDBnit0Z79lno0AHwaZLbTupHaacSDN/zvu2kfllLn0Bqg5iHA/91zi0HMLPxwAHAmCAaJiLSUCpLww4/om+jlQnrRZyAc/XVMGMGPP009G3cuw60rjwAqQTw/wH7mVl7YB1wGKDtdkQkcKkuDRv3rMxx4+CBB+DKK+Hkk4N9EmmQ0pZqZnYTcApQA8wGfumcWx/teG2pJiLJGDhyMpUR8tilnUp4e8ShEX4iCZ98AvvsAwMGwOTJKe0qH/RGEmnZUs05dwNwQyrnEBGJJZ1LwwKwahX87Gew+ebw5JMpB+90bSTRlKbSi0jOS9vSsADOwfnnw+ef++DdvXtKp0vnRhJNKYCLSM5Lawnffff5AcvbboOf/CTl06X93UIDWgtFRHJe4EvD1ps2DYYPh/JyX30SRSI57e6dSiLm69OxXooCuIgA6d3BPQiBl/AtW+brvXv3hn/8I+IiVZB4TjtSyWK6JvwogItIRgfeMinqTammBk49Faqq4JVXoGPHqOdoKacd6XeTtncLESiAi0jCQSoMWrwpPXE/vPkmPP447LFHi+dJJqedqQk/GsQUkYwOvGVKtJvSrFEPwR13wAUX+KViY0hrBUyKFMBFJKeDVLIi3Xx2+Xoh1z5zBwwc6KtP4pCLi1jVUwAXkZwOUslqevPpvHYlo8ffyuqSzeGZZ6BNm7jOk4uLWNVTDlxEMjrwlikNq0Fab6zhL8+PZOvVK5j+6Hi27tYtoXPl2iJW9RTARQTI3SCVrIY3paFP38P+/5vDrJvv5ZCzmm9KHFYK4CKSt8r7l1I+62V4fwJcdRV7Xz8s200KlAK4iIRWzMlH06bBRRfB4MEwcmT2GpomCuAiEkoxJx998QWcdBL06eMXqWqdf+FOVSgiEkotrvq3ahUcfzxUV8OLL0KnTtlpZJrl3y1JRApCtElGX61Y7TcknjsXXn4Zdtopwy3LHPXARSSUok0y+uM7j8OECXD//TBoUIZblVkK4CISSpEmH5370cuc8vazMGwYFfufwMCRk+kzYiIDR06mYnZlllqaPkqhiEgoNZ18VP71x1z/6l/hmGOoOPPKvFxdsamUNjVOlDY1FpG0+OQTOOAA6N2bCX9+imET/8PGCLEt0E2QMyjapsZKoYhIuC1bBsccA+3bM2nk3xk+6b8RgzeEe3XFSJRCEZHwWrfOb4f29dcwZQo3/2tVs9LChsK8umIk6oGLSDht3AhnnAHvvgtjxsCPf9xiDzvsqytGogAuIuF09dXw3HNw991+xiXRe9hFZjmzBGyQFMBFJHzuvdd/DBsGl1++6eFo65rfNWTPvAveoBy4iITN+PFw5ZVw4olw112NvpWP65q3RAFcRMJj+nSf9953X5/3Lipqdki+rWveEqVQRCQc5s+HY4+F0lJ44QVo3z7bLco6BXARyX1LlsCRR/olYSdNgq5ds92inJBSADezTmb2jJnNN7N5ZrZ/UA0TEQGYOHUuC8oOZs2SZZz/8xup+H/tst2knJFqDvw+4BXn3Mlm1gbQexoRCcwL0z+n+5mnsN2yLzn/5N/z1ma9eCcP1zRJVtI9cDPrCBwMPAzgnNvgnKsKqF0iUuhqauh8/tkMWPQJVx57JW/1GQA02LRBUkqh9AGWA4+a2Wwz+7uZdWh6kJkNNbOZZjZz+fLlKVxORAqGczB0KAfNe4cbDx/KhF0ObvTtfFvTJFmpBPDWwADgQedcf2ANMKLpQc650c65MudcWVcNPIhIPK69Fh59lEcOPYvH9z6u2bfzbU2TZKUSwBcDi51z79Z9/Qw+oIuIJO/OO+H22+GCC9hy1B8jzqzMtzVNkpX0IKZz7iszW2RmfZ1znwKHAXODa5qIFJy//Q2GD4chQ+BPf6K8qAjMCmZmZaJSrUK5FBhbV4GyEDg39SaJSEF68kn49a/hqKPgn//cNMuykGZWJiqlAO6c+wBotkuEiEhCJk6EM8+EAw+EZ56BNm2y3aJQ0ExMEcmuSZP8crB77gkvvqgp8gnI+cWsKmZXKv8lkq/+9S+/o86uu8Krr0LHjtluUajkdACvmF1ZEDtLi+SDhDtbb74Jxx0HO+4Ir78OW26Zsbbmi5zelX7gyMlURijYD+vO0iL5qmlnq1774lasq65tHtCnTfOLU223HbzxBmy9dRZaHR7RdqXP6R54tNlWmoUlkltGTfo04mbCa6trgSbvnr//n6806dHDp1AUvJOW04OY0WZbaRaWSG6Jp1O1rnojE/7+vO95d+sGkyf7z5K0nA7g0fa30ywskdwST6dqt68+566HfwNbbeWDd/fuGWhZfsvpAF7ev5TbTupHaacSDJ/7zsedpUXCbvgRfbEWvr/L1wsZ++TvWFuymc959+yZsbbls5zOgYNmYYmEQXn/UmZ+uYKxM/5H07KInZZ/wZgnfse64nbMeXw82263XdTzqGw4MTkfwEUkHP5Q3o+y7bbcFIA7lhSzw/IveeiJ31FbXMzHjz/H4OMOaPZz9UG7smodBptuACobji2nywhFJMQ++ggOP9yvafLmm9C3+dhVtPLDhlQ2HNIyQhHJjpRTGe+/D4MGQUmJH7DcaaeIh0UrP2xIZcPRKYCLSCMpz4D+97/hiCP8tPjJk2H77aMeGk9wVtlwdDldhSIimRepVxz3PpRvveXTJltuCVOmtBi8IXZwVtlwyxTARaSRpGdAv/QSNYMH80W7zux35O8ZOO4/VMyubPFHIs31qC9HVNlwbEqhiEgjHUuKqVpX3ezxFnvLY8dSe845zO/ah1+cfCMr2neEOFIv9Y+rdDA5CuAiBa7hgGXHkmJWra9pdkxxK4ueynjgAbjsMmZvvxdnH/9bVrf9YT3v+tRLSwFZcz2SpwAuUmCaBuw1G2qo3ujLiSP1vAE2a9e6eZB1Dm66yX+Ul3P6Dr9gfevmO+moiiR9FMBFkhDWGYNNK0yiBeymqtY2Oa62Fi67DP78Zzj3XBg9mi53To24/LOqSNJHg5giCaoPgpVV63D8UGYXa8AuF8RTdx1J904lVMyuZODIyew0vIJXBwzywfvqq+Hhh6F1ay0+lwUK4CIJSqnMLsuSSWeUFBfx0527cu34OXy7/DseGv8HBn84mTsPPY+K0y8H83UjWnwu85RCEUlQmDca6d6pJGKao6HiVsZm7VpTtbZ6U3roxhc+oXjVSh555ib6L/mUa468lCf3PILSJgOUGpDMLAVwkQRFC4KZyvXGk3+PdszwI/o2W3skUsBueL6K2ZV0+KqSfzx9A72qlnLxCdfwSt+BQPObVljHBsJKAVwkQZGCYKZyvfFMc4/nmESC7POPvMj4MddRUr2es4fczIxee2z6XsObljYhzzwFcJEEZXPySUv594btaumYhNIcL73Enx66gqp2m3PyGbfzWdfejb7d8KYVT9skWArgIknIVq43nvx7YDn6v/4VLr6YRd124KwTr2f5Zls2+nbn9sWNfgdhHhsIK1WhiIRIPBt9p7wZ+MaNMHw4XHghHHUUC56awOrOXRsdUlJcxA3H7ZZw2yRYeRPA62tU+4yYyMCRk0NRkyuSqHhqrVOqx16zBn72M7jzTrj4Yqio4LiBO8VVHqg68MzLixSKBk8k30Sr5ogn/550jn7RIjjhBPjwQ7j/frj00kbnjPXzWpgq81LeUs3MioCZQKVz7tiWjk3XlmoDR06OWNalrZgkjCJtM1ZSXJTeSTHvvgvl5b4H/sQTcPTR6bmOJCXalmpBpFCGAfMCOE/SNHgi+STjMz0fewwOPhjat4fp0xW8QySlAG5mPYBjgL8H05zkaPBE8knGOiQ1NXDFFXDOOXDQQX4rtN12i/ljkjtS7YHfC/wGqE29KcnT4Inkk44lxQk9npQVK3xP+957YdgweOUV2Gqr4M4vGZH0IKaZHQt87ZybZWaHtHDcUGAoQK9evZK9XIs0eCL5xCyxxxM2axacfDIsWeJXEjzvvIBOLJmWShXKQOB4MzsaaAdsYWZjnHNnNjzIOTcaGA1+EDOF67Uo1xfR0RoREq9ma2/HeDxuzsHf/w6XXALbbANTp8K++8b8Mb12c1fSKRTn3LXOuR7Oud7AqcDkpsE7CPlQ3x3m9aMl89IyprN2re9pDx3KsgH7c/TZ99HnuW9i/k3ptZvbcnoiT768eMK8frRkXuBjOp9/DgccAI89xvxfXc6hhw5nbnWbuP6m9NrNbYEEcOfcm7FqwJORLy8elTlKIgLdGOH556GszE/SmTiR87c/jjVNNuRp6W9Kr93cltMzMdP94omV2wsq9xfv+tHKNUq9lMd0qqvh+uvh9tth773hmWegd2+WTJkY8fAlVesivv6yvfa5tCynUyip5AJj5c5jpWeCTN/E85Y4X9JFkgO+/BIOOcQH76FDYdo06N0biP6307GkOOLr76c7d1WJbg7L6QCebC4wnmAYKz0TZPomnrfEQaeLwj74G/b2Z83//R/ssQfMmQPjxsFDD0G7dpu+He1vyoyIr7835i/XPpc5LKdTKJt2GHl0ApVra1n7o75xpRXiWVg+Vnom6PRNrLfE0c5bWbWOgSMnJ5RWCfviXmFvf1asXOlXDxw71g9YjhkDffo0OyzanIkrnvwg4mnr0ydaUyg35XQAByjfqzvlsx6H99+HUaNgr5/G/Jlom7Y2fDxWbi/dub+m+caOJcVUrWte52sN2h1vIAv7zihhb3/GTZsGZ54JixfDTTfBb38LraP/aUfqTIya9GnUvxvdPHNXTqdQAD/9bPx4OPRQuPRSpu+8L/tc8s8W31YXRZmy1vDxWOmZdE7Pj5TiWbOhhuJWjdttQNOZT/GkVcJeORD29mdM/UDlT34CRUU+kP/+9y0G72givd7rhbHyq1DkfgAH2GYbKm55iJuPvJj+Cz/klUcuYY8Zr0Ud5NsYZYncho/HyksHWsrVRKQeZvVGx2btWje6XrRpq7ECWdgX9wp7+zPi88/9AlR/+AP84hfwwQew335Jn67+9R6Nbp65KedTKPVGvfoZlXsexZQeu3P3hLt58PmRPP/ZdB60y5sF1dIo6Y/SJgEgVl46XdPzo/0xVK2tZvbvB2/6Oto659ECWX1aprJqXbPee5gqB7K563vOq62FP/0Jrr0W2rSBJ5+EIUMCOXV5/9KoqRTdPHNTOHrg/BD0/rNVT3525ijuOvAMjv50Go/ffR4jzrq5UU8811cnjLeHmcjzaJiWAR+86xMyYascSOe7n1BbsMCnS4YN85/nzAkseNfL9b8daSzlHXkSkcqOPJF6o7suW8iol+5lt68X8tKuB8MDD3D0oXsAuT0pJpEdV+J9HtqVKHg58xrauNEv+/q73/mSwHvv9WmTwJYnbCxnnrdsEm1HntAE8EhBD6D1xhp+/e6zDHt7HGtKOtD5bw/Cqaem7cUdlKD/SPqMmBgxZ27Af0cek/R5C1VWtjWLZP58OPdcmDEDjj8eHnwQunfP3PUlJ0QL4KHJgTesX23Y06wpas2fDziFV3fcjztfvpfOp58O//wn/OUvm2af5aKg8+ua8hysrJcyrl/vy2b/8Afo0MHXd592Ws53TCSzQpMDBx/03h5xaLPBSIAFXbfjkkv+7N9eTp3qt4a6806/bVQBUO4yWFktZZwwwb9+r78ejjsO5s6F009X8JZmQhXA60ULVlcdtasf4Jk7Fw47DIYP9wv5TJ2apZZmjgb+gpWVUsYFC+CYY3zQLi6GSZPg6af95gsiEYQmB95UzByyc/Dcc3D55X4pzdNOgzvugB49Arm+5LeM5sBXr4Zbb4W774a2beGGG+DSS32ZoAh5MIiZtLVr/apst9/uZ6tddx1ceSUV877VSHuOy3Y1RNqv75xfcGr4cL8/5dlnw8iR0K1bcNeQvFC4Abzef/8LV18N48ezusd2DD/gHF7uXbYpr5iVCgOJKmeqQNLlww99L/utt3ya74EHYP/9s90qyVHRAngoc+BJ6dMHnn0WXnuN5RscDz51E/94+kZ2+HYRoPUecm351nzZjamZFSvgootgwACYNw/+9jd4992MB+9c+/+W5ISmjDAwhx/O4F/cz1nvT+TyaWOZ9PDFjNvrSO4/4FSWsGW2W5cVyS7fms4UQ94taFVT43eEv+66H5Z+vekm6Nw5403Rcr35o3B64A1svdXmPPLjEzjk13/j//Y6ilM/nMTUh37FzTPGwnffZbt5GZdMbzfdOwjlzYJWtbV+vZLdd4cLL4R+/WD2bLj//qwEb8jjdzcFqCADeH0Z4or2Hfn94As5/JcP8nrf/TlryjjYfns/kLR2bbabmTHJ9HbTHQRCX9funK/nHjDAzwxu3dovi/zGGz6IZ1HevbspYAUZwJvWTNf02YGN/xzjl+QcONCv9LbDDn425/r12W5u2iXT2013EAh1XfvkyX5XnOOO8yWCY8b4QcsTT0z7ZJx4ctt58+5GCjAHXifyVPZS32uaNs0H8Ysv9uWHI0bAeef5Gt08lMzyrZmYup+u5XzTZupUn9eePBlKS/1+lOee6yflZEC8uW0t15s/CrIHHtOBB/o/xlde8X+IF13ke+T33Qdr1mS7dYFLprcb+hRHUJzzr5ODDvJLvH78Mdxzj99wYejQjAVviD+tFep3N9JI4dSBJ8s536O65RaYMgW6dPE98wsuKPgJF9meaJOqlNpfU+Nz2nfcAbNm+Rm+v/kNnH8+tG+f3oZHoRUp85cm8gThnXfgttt8mqW42C+mf+mlsO++2W6ZJCjpiUKrVsEjj/hF0774An70I7jmGr8+d5anvmtN+PyVNxN5sjoB4YAD4MUX4bPPfFrlhRf8PoT77uuX+9ywIXNtkZQkXEXz5Zc+UPfs6dfXKS31PfD58+GXv8x68AaltQpRqAJ4umuP47bjjr4HVlnpp0CvXAlnngm9esGNN8LSpZltjyQsriqa2lp47TVfPbL99n554kGD/OYK06b5x4t8wMyFmY3KbReeUKVQcvYtYv0f+gMPwEsv+Zrfn/8cLrtM6ZUsiCe33eJr6dzd4NFH/TT3hQthq638gOQFF/ibdITr5fW6LZJ1gadQzKynmb1hZnPN7BMzG5ZaE2PL2QkIrVrBEUf43Phnn8HFF1P9wouw3358ss0O3HP8pUx84+PstjEPxNPLjfddWtN0Q1HtRo78YhZPvX6XH5C89lqfLhk7FhYvhj/+MWLwBs1slOxJpQ68BrjKOfe+mW0OzDKz15xzcwNqWzOh2DbsRz+i4hdXc0vxQRz1weuc8tGrXPHin9gw8a8s+cnhdL/kV3D00X5zWokoUg8aiKvGOd6t0Mr7l4JzvPDoBA54dxLl86fSZdUKX2V06aW+x73zznG1N2c7FpL3kg7gzrmlwNK6f68ys3lAKZC2AB6WCQijJn3Kt63aMmbAMYwZcAy7fL2Qk+f8ixPfmwI/ewU239znT089FQ4/PKO1wrku2mSUdsWt4grMcQXTefPgiScoHzeO8gUL/O//6KPhnHP85wQHJEPRsZC8FMggppn1BvoD7wZxvmjCMkjTNIjM23p7bjnsV+xz4WPw6qs+P/788z5YdOvmZ+u9+CJ8/32WWpw7ovWgv1tbHfH4pr/rSEGzVe1GBq9c6Ou0+/aFXXf1df09esDo0fDVV1BRAeXlSVWTqPpDsiXlQUwz2wyYAtzqnBsf4ftDgaEAvXr12vvLL79M6XphEG2ArMiMu4bs6W8469f7YP7kkz53vnKl33188GA49lg46ijYdtsstD5zIqVKrnjyg4iTUaIpMqPWuWapltp16xj4xQcMWjCDQf/5N13WVPnB5Z/+FE44wb8D6t49rc8l1zoWEl5pmchjZsXABGCSc+7uWMcHMZEnG38oiV4zUlVCvYjVCRs2+FXqKip8MF+82D++xx4+oA8e7Kf3l4TvLXm03120yo22rVtRta55b7tTSTHra2oj/k4BcI49v1vErZstpev0qXSaOZ22NRtY3bYDVT85jB7nnuZvih07puupRqXgLqkKPICbmQGPASucc5fH8zOpBvBslGsle82K2ZVc9dSHbIzw+22x7NE5+Ogjv77GpEm+3ri62r+1339/v97GwIF+AtEWW6T8/NKppd/dqEmfRnyX0rl9Md9X10b8GWBTICx2tey4bCFllfP48eK57Pu/OXRdW+V/YNddfb32UUf5HncWJ9moxFCCkI4AfiDwFjAHqK17+LfOuZei/UwY68BTuWYga1OsWQNTprDgiRfY+K/J7Lj0PxS5WpwZ1q+fD+b77OP3VdxlF58myBEt/e6W1JX5NWXAPafs1bzHuo35NUfeew/efps1b71Dh2o/ZrBk8y7M6NWP6b36Ma33AKb/5ez0PrEE5OzcBQmVaAE8lSqUafi/t4zJRrlWKtcMpDqhQwcqtt2Ta7drxbqzjqPD+rXstfQz9ls6nyEbFrHNmDHw4IP+2HbtYM89/Ue/fv5j551h663Tvg51JC397qL9bvq2raF8/SLKt10EVfNg6kdw32w/0Ai+5n7PPXm57EimdNmRWT12YckWW2/6+dIcq/xQiaGkU+501+KQqXKthjnLVmYR0yCtzKiYXRlzydUgyh4bVmasaduet3vvxdu99+KJTiW8/fYhfvLQrFk/fDz9tK+uqLfFFrDTTn4JgO228xNUevTwn3v29DMN0xDgm/1/OcfmG9ayB6u5qGMJE96ZyZZVy+mxchnbr6hkh+8q/WDjzXXHFxf7G9CgQVBW5t9l7LUXdOhA69mVvJ7BktJk89gqMZR0ClUAz0QdeNOcZaTgXf94rI1g6x9PdQArWm+tsmodA+94s+7c2zL8rKsov9tPUGHpUr829bx5sGCBD/LTp/vgXlPT+ETt2vmKjK5dfTDfbDP/0aHDD5/r/92+ve8F13PO5+jXr/dlkN9/73ehqapi3MIlLPhsMZutW02XNVV0W/XNprQHwMC6z9+WbMHibXqxetCRdDlggA/afftCnz5Ra+SD+t3GI5VNgMMyd0HCKVRroUD6R/Sj5SyjyUQuM1qbDBrlkeMaHKuthWXLYNEiX+1S/7myEr75Br791ufdV6/+4XPTgB+Pjh2hUydWtu3AwurWLG2zOau32oZdf7wLu++7m1/Nr7TU3zhyoLqmpddVqnlsVaFIqrQeeJyiDTxGk4nF8iNVMjQN3vXSckPZsOGHYL52re91N1Rc7HvxDT+KiiKfKwfFqhTRRgmSbYEPYuaraDnLoii58EzkMiOlC6K9S0jL4FibNv6jc+fgzx2ndPZiY62fojy25KpQrQeeCZGmRRe3Mtq2bj7Il8lcZnn/Ut4ecSj/HXkMb484NGq1RT4GlXSvAx+rUkRT5SVXKYA30XS9lU4lxWCwtrq20XGd2xenZTJGvBsDFFJQSfdyrdFuevWPh2UNHik8SqFEUN6/tNEAVqSp3e3btE5L8I632iGTVRjZlu5a6ngqRRq+JkRyhQJ4DJmciBHvWtb1CiWopDsHXUg3Q8kvCuAxZHIAS7P2IstELXWh3AwlvygHHkMmc82xcrGFSjlokcjUA48hk2+vNWsvOvWQRZpTAI9DpoJHUDcLzfwTKQwK4Dkm1ZtFKut2FDrd+CRsFMBzSBABJNFKFgUtTzc+CSMNYuaIoGYbJlLJku4ZjmGS7slCIumgHniOSLTnHE0iZY+JXDOX9yINom0q4ZQwUg88RwQVQBIpe4z3mtnoqcd7zaDaphJOCSMF8BwRVABJpGY63mvGm16Idx2XeMR7zaBSH4W0tozkD6VQckSQNeDxVrLEe814eupBDwLG++4gqHcumk4vYaQAniOyEUDivWY8efWgcviJXDOR4+KhyUISNgrgOSQbASSea8bTUw96EDDedweavSqFTAFcYoqnpx70ol/xvjtQ6kMKmfbElEDE2ldSRJKnPTElrdQTFsk8BfAckC/T2TUIKJJZCuBZpjU4RCRZmsiTZVqDQ0SSpQCeZVqDQ0SSpQCeZVqDQ0SSlVIAN7MjzexTM/vczEYE1ahCkgtrcAS5homIZE7Sg5hmVgT8GRgELAbeM7MXnHNzg2pcIagfqLzpxU/4bm01AG1bZ+6NUaENouZLxY8IpNYD3wf43Dm30Dm3AXgCOCGYZhWe76trN/27al11xjZWKKRBVG1gIfkmlQBeCixq8PXiuscaMbOhZjbTzGYuX748hcvlr2wG0UIaRC2km5UUhrTXgTvnRgOjwU+lT/f1wigTQTRa6iDoNUxyWSHdrKQwpNIDrwR6Nvi6R91jkqB0V6K0lDrIhUHUTFHFj+SbVAL4e8COZtbHzNoApwIvBNOswpLuIBprre54d/AJu0K6WUlhSDqF4pyrMbNLgElAEfCIc+6TwFpWQNK9EFSs1EGhrGGiBbck36SUA3fOvQS8FFBbClo6g2gh5bljKZSblRQGzcQsAEodiOQnrUZYAJQ6EMlPCuAFQqkDkfyjFIqISEgpgIuIhJRSKFLQtLiVhJkCuBSsQluJUfKPUihSsLS4lYSdArgULC1uJWGnAC4FS4tbSdgpgEvB0gxVCTsNYkrB0gxVCTsFcClomqEqYaYUiohISCmAi4iElAK4iEhIKYCLiISUAriISEiZcy5zFzNbDnyZxI92Ab4JuDnZoueSm/RccpOei7edc65r0wczGsCTZWYznXNl2W5HEPRccpOeS27Sc2mZUigiIiGlAC4iElJhCeCjs92AAOm55CY9l9yk59KCUOTARUSkubD0wEVEpAkFcBGRkApNADezW8zsIzP7wMxeNbPu2W5TssxslJnNr3s+z5lZp2y3KVlm9nMz+8TMas0sdOVeZnakmX1qZp+b2YhstycVZvaImX1tZh9nuy2pMLOeZvaGmc2te20Ny3abkmVm7czs32b2Yd1zuSnQ84clB25mWzjn/l/dvy8DdnXOXZDlZiXFzAYDk51zNWZ2O4Bz7posNyspZrYLUAs8BFztnJuZ5SbFzcyKgM+AQcBi4D3gNOfc3Kw2LElmdjCwGnjcObd7ttuTLDPbFtjWOfe+mW0OzALKw/j/YmYGdHDOrTazYmAaMMw5NyOI84emB14fvOt0AMJx54nAOfeqc66m7ssZQI9sticVzrl5zrmw7gK8D/C5c26hc24D8ARwQpbblDTn3FRgRbbbkSrn3FLn3Pt1/14FzANCuWi781bXfVlc9xFY7ApNAAcws1vNbBFwBvD7bLcnIOcBL2e7EQWqFFjU4OvFhDRQ5Csz6w30B97NclOSZmZFZvYB8DXwmnMusOeSUwHczF43s48jfJwA4Jy7zjnXExgLXJLd1rYs1nOpO+Y6oAb/fHJWPM9FJGhmthnwLHB5k3fgoeKc2+ic2wv/TnsfMwssvZVTW6o55w6P89CxwEvADWlsTkpiPRczOwc4FjjM5fhARAL/L2FTCfRs8HWPuscky+ryxc8CY51z47PdniA456rM7A3gSCCQgeac6oG3xMx2bPDlCcD8bLUlVWZ2JPAb4Hjn3Npst6eAvQfsaGZ9zKwNcCrwQpbbVPDqBv4eBuY55+7OdntSYWZd66vMzKwEP2AeWOwKUxXKs0BffMXDl8AFzrlQ9pbM7HOgLfBt3UMzQlxRcyLwANAVqAI+cM4dkdVGJcDMjgbuBYqAR5xzt2a3Rckzs3HAIfhlS5cBNzjnHs5qo5JgZgcCbwFz8H/vAL91zr2UvVYlx8z2AB7Dv75aAU85524O7PxhCeAiItJYaFIoIiLSmAK4iEhIKYCLiISUAriISEgpgIuIhJQCuIhISCmAi4iE1P8Ha33lFOQwPfIAAAAASUVORK5CYII=)]

X10 = np.hstack([X2,X**3,X**4,X**5,X**6,X**7,X**8,X**9,X**10]) 
estimator_l2 = Ridge(alpha=0.005,normalize=True) # 调整alpha 正则化强度 查看正则化效果
estimator_l2.fit(X10,y) 
y_predict_l2 = estimator_l2.predict(X10) 

plt.scatter(x,y) 
plt.plot(np.sort(x),y_predict_l2[np.argsort(x)],color = 'r') 
plt.show()

estimator_l2.coef_   # l2 正则不会将系数变为0 但是对高次方项系数影响较大

array([ 9.91283840e-01,  5.24820573e-01,  1.57614237e-02,  2.34128982e-03,
        7.26947948e-04, -2.99893698e-04, -8.28333499e-05, -4.51949529e-05,
       -4.21312015e-05, -8.22992826e-07])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ssAesU2h-1633775046338)(./pics/26img.png)]

4.1 岭回归的API

• sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True,solver=“auto”, normalize=False)
  • 具有l2正则化的线性回归
  • alpha:正则化力度，也叫 λ
    • λ取值：0~1 1~10
  • 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):

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

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

4.3 岭回归实现波士顿房价预测

# 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.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("预测值为:
", y_predict)
print("模型中的系数为:
", estimator.coef_)
print("模型中的偏置为:
", estimator.intercept_)

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

• 欠拟合【掌握】
  • 在训练集上表现不好，在测试集上表现不好
  • 解决方法：
    • 继续学习
      • 1.添加其他特征项
      • 2.添加多项式特征
• 过拟合【掌握】
  • 在训练集上表现好，在测试集上表现不好
  • 解决方法：
    • 1.重新清洗数据集
    • 2.增大数据的训练量
    • 3.正则化
    • 4.减少特征维度
• 正则化【掌握】
  • 通过限制高次项的系数进行防止过拟合
  • L1正则化
    • 理解：直接把高次项前面的系数变为0
    • Lasso回归
    • from sklearn.linear_model import Lasso
  • L2正则化
    • 理解：把高次项前面的系数变成特别小的值
    • 岭回归

• 知道sklearn中模型的保存和加载

• from sklearn.externals import joblib
  • 保存：joblib.dump(estimator, ‘test.pkl’)
  • 加载：estimator = joblib.load(‘test.pkl’)
  • 注意：0.21版本以下可以使用sklearn.externals.joblib，新版本需要安装joblibpip install joblib，import joblib

# 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.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("预测值为:
", y_predict)
print("模型中的系数为:
", estimator.coef_)
print("模型中的偏置为:
", estimator.intercept_)

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

• sklearn.externals import joblib【知道】
  • 保存：joblib.dump(estimator, ‘test.pkl’)
  • 加载：estimator = joblib.load(‘test.pkl’)
  • 注意：
    • 1.保存文件，后缀名是**.pkl
    • 2.加载模型是需要通过一个变量进行承接

• 知道线性回归的常见落地场景

• 回归是研究自变量x对因变量y影响的一种数据分析方法
  • 最简单的回归模型是一元线性回归，可以表示为Y=β0+β1x+ε，其中Y为因变量，x为自变量，β1为影响系数，β0为截距，ε为随机误差。
  • 回归分析是广泛应用的统计分析方法，可用于分析自变量和因变量的影响关系（通过自变量求因变量），也可以分析自变量对因变量的影响方向（正向影响还是负向影响）。
  • 回归分析的主要应用场景是进行预测和控制，例如计划制定、KPI制定、目标制定等；也可以基于预测的数据与实际数据进行比对和分析，确定事件发展程度并给未来行动提供方向性指导。
  • 常用的回归算法包括线性回归、多项式回归等
  • 回归分析的优点是数据模式和结果便于理解，如线性回归用y=ax+b的形式表达，在解释和理解自变量与因变量关系式相对容易；在基于函数公式的业务应用中，可以直接使用代入法求解，因此应用起来比较容易。
  • 回归分析的缺点是只能分析少量变量之间的相互关系，无法处理海量变量间的相互作用关系，尤其是变量共同因素对因变量的影响程度。

• 在各种媒体上投放的广告对最终销售所产生的效果研究
  • 公司可以投入的营销渠道
    • 传统大众媒体：电视 广播 户外广告
    • 直销媒体：电子邮件，短信，电话
    • 数字媒体：app 微信 社交应用
  • 通过回归分析可以回答
    • 不同营销渠道是如何促进销售的
    • 如何调整营销组合使每一份支出获取最大收益
    • 同时在不同渠道进行广告营销，哪个效果更明显
  • 销售量 = 营销变量 + 误差因素
    • 营销变量 ： 可控的渠道投入
      • 线上产品：微信 微博 头条
      • 传统产品：电商 微信 户外 电视
    • 误差因素：不可控的所有因素
      • 经济大环境，季节，假期，对手
  • 营销变量和销售量之间是线性关系
    • 营销投入越大，销售量也会对应的逐步提高
  • 回归分析模型：销售额 =93765+0.3* 百度+0.15 * 社交媒体+0.05 *电话直销+0.02 * 短信
    • 线性回归模型，假设解释变量和因变量之间是线性关系，但实际情况，销售收入不会随着广告的投入而一直上升
    • 使用回归模型的结果，最主要的还是观察各个因素的大小做横向对比
• 回归分析的结果，着重于不同X对于Y影响的对比，直接预测Y的场景较少

• 销售额预测分析

  • 快消企业，分析目的
    • 对商超门店的销售额进行预测
    • 量化自身所能控制的各种促销因素所能产生的效果
    • 对营销资源做出合理规划
  • 传统快消企业，数据特点
    • 聚合类的数据
    • 渠道众多，无法精准了解用户
  • 本例中，通过回归分析实现对各类因素投入产出比做出评估
    • 分析数据
      • 电视广告，线上，线下，门店内，微信渠道等促销投入和销售额之间的关系
    • 数据说明 （以月为观测窗口）
      • Revenue 门店销售额
      • Reach 微信广告次数
      • Local_tv 本地电视广告投入
      • Online 线上广告投入
      • Instore 门店内海报等投入
      • Person 门店促销人员
      • Event 促销事件
        • cobranding 品牌联合促销
        • holiday 节假日
        • special 门店特别促销
        • non-event 无促销活动
    • 分析流程：数据概况分析->单变量分析->相关性分析与可视化->回归模型
      • 数据概况分析
        • 数据行/列数量
        • 缺失值分布
      • 单变量分析
        • 数字型变量的描述指标（平均值，最大最小值，标准差）
        • 类别型变量（多少个分类，各自占比）
      • 相关性分析与可视化
        • 按类别交叉对比
        • 变量之间的相关性分析
        • 散点图/热力图
      • 回归分析
        • 模型建立
        • 模型评估与优化
  • 代码

  import pandas as pd
  #数据读取#
  #index_col=0 ，数据的第一列是索引，指定索引列
  store=pd.read_csv('data/store_rev.csv',index_col=0)
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xOfo6c0p-1633775046339)(pics/p&g_regression1.png)]

  #数据的基本信息
  #发现local_tv有50多个空值
  #发现event是object,即类别型变量
  store.info()
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-seuDGaYx-1633775046340)(pics/p&g_regression2.png)]

  #统计各个列哪些是空值
  #发现local_tv有56个空值
  store.isnull().sum()
  
  '''
  revenue      0
  reach        0
  local_tv    56
  online       0
  instore      0
  person       0
  event        0
  dtype: int64
  '''
  
  #了解数据的分布
  #判断数据是否符合业务场景
  store.describe()
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kP9Q3Aan-1633775046341)(pics/p&g_regression3.png)]

  #了解event的具体值
  store.event.unique()
  #array(['non_event', 'special', 'cobranding', 'holiday'], dtype=object)
  #这些类别对应的revenue(销售额)是怎样的
  store.groupby(['event'])['revenue'].describe()
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mzPd874V-1633775046341)(pics/p&g_regression4.png)]

  #这几个类别对应的local_tv（本地电视广告投入）是怎样的
  store.groupby(['event'])['local_tv'].describe()
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fj0zL3iF-1633775046342)(pics/p&g_regression5.png)]

  • 相关性分析

  #所有变量，任意两个变量相关分析
  #local_tv,person,instore是比较好的指标，与revenue相关度高
  store.corr()
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oxxBNFyH-1633775046343)(pics/p&g_regression7.png)]

  #其他变量与revenue的相关分析
  #sort_values 将revenue排序，ascending默认升序，False为降序排列
  #看到前3个相关变量为local_tv,person,instore
  store.corr()[['revenue']].sort_values('revenue',ascending=False)
  '''
  	               revenue
  revenue	           1.000000
  local_tv	       0.602114
  person	           0.559208
  instore	           0.311739
  online	            0.171227
  event_special	    0.033752
  event_cobranding	-0.005623
  event_holiday	    -0.016559
  event_non_event	    -0.019155
  reach	            -0.155314
  '''
  
  

  • 可视化分析

  #可视化分析
  import seaborn as sns
  import matplotlib.pyplot as plt
  #线性关系可视化
  #斜率与相关系数有关
  sns.regplot(x='local_tv',y='revenue',data=store)
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hgl8e8Yo-1633775046343)(pics/p&g_regression8.png)]

  #线性关系可视化
  sns.regplot(x='person',y='revenue',data=store)
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l4W8Q5L4-1633775046344)(pics/p&g_regression9.png)]

  sns.regplot(x='instore',y='revenue',data=store)
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cbarEDxb-1633775046345)(pics/p&g_regression10.png)]

  • 线性回归分析

  #删除缺失值，数据有缺失，不处理会报错，需要处理缺失值
  store.dropna(inplace=True)
  
  #或者填充缺失值
  #缺失值处理,填充0
  store=store.fillna(0)
  #缺失值处理,均值填充
  store=store.fillna(store.local_tv.mean())
  store.info()
  '''
  <class 'pandas.core.frame.DataFrame'>
  Int64Index: 985 entries, 845 to 26
  Data columns (total 10 columns):
  revenue             985 non-null float64
  reach               985 non-null int64
  local_tv            985 non-null float64
  online              985 non-null int64
  instore             985 non-null int64
  person              985 non-null int64
  event_cobranding    985 non-null uint8
  event_holiday       985 non-null uint8
  event_non_event     985 non-null uint8
  event_special       985 non-null uint8
  dtypes: float64(2), int64(4), uint8(4)
  memory usage: 57.7 KB
  '''
  
  #设定自变量和因变量
  y=store['revenue']
  #第一次三个 
  x=store[['local_tv','person','instore']]
  #第二次四个 
  #x=store[['local_tv','person','instore','online']]
  
  #数据标准化处理
  from sklearn.preprocessing import MinMaxScaler
  scaler = MinMaxScaler()
  x1 = scaler.fit_transform(x)
  
  from sklearn.linear_model import LinearRegression
  # 实例化api
  model=LinearRegression()
  # 训练模型
  model.fit(x1,y)
  # LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)
  
  # 自变量系数
  model.coef_
  # array([41478.6429907 , 48907.03909284, 26453.89791677])
  
  # 模型的截距
  model.intercept_
  # -17641.46438435701
  # 最后得到x和y的关系为:y=41478*local_tv + 48907*person + 26453*instore - 17641
  
  # 模型的评估,x为'local_tv','person','instore'
  y_predict=model.predict(x)#计算y预测值
  from sklearn.metrics import mean_squared_error
  mean_squared_error(y,y_predict)
  # 1.9567577917634842e+18
  
  

• 注意应用回归模型时研究自变量是否产生变化
  • 在应用回归模型做预测时，必须研究对因变量产生影响的自变量是否产生变化，主要考察两个方面：
    • 是否产生了新的对因变量影响更大的自变量
      • 在建立回归模型时，需要综合考虑自变量的选择问题。如果遗漏了重要的变量，那么模型很可能无法正确反映实际情况，而且参数估计是有偏的，此时的回归模型极其不稳定且方差较大。
      • 同样在应用回归模型时，仍然需要重新评估该问题是否发生。例如，在做用户订单金额预测时是基于正常销售状态下的变量实现的；但当发生大型促销活动且促销活动因素没有被纳入回归模型中时，原来的回归模型则无法有效预测。
    • 原有自变量是否仍然控制在训练模型时的范围之内。
      如果有自变量的变化超过训练模型的范围，那么原来的经验公式可能无法在新的值域范围下适用，这种情况下通常需要重新做研究和建模。
      • 假设我们建立了一个回归模型，可以广告投放费用预测广告点击率，在训练回归模型时的广告费用在[0，1000]区间内，但在广告费用超过1000（例如2000）时，则无法保证最终预测效果的有效性。
• 回归算法按照自变量的个数分为一元回归和多元回归，按照影响是否是线性分为线性回归和非线性回归。在面对不同回归方法的选择时，注意参考以下因素：
  • 入门的开始——简单线性回归。如果是学习为主，那么不需要选择多么强大的模型，基于最小二乘法的普通线性回归最合适；同时，它适合数据集本身结构简单、分布规律有明显线性关系的场景。
  • 如果自变量数量少或经过降维后得到了可以使用的二维变量（包括预测变量），那么可以直接通过散点图发现自变量和因变量的相互关系，然后选择最佳回归方法。
  • 如果经过基本判断发现自变量间有较强的共线性关系，可以考虑岭回归。
  • 如果在高维度变量下，使用正则化回归方法效果更好，例如Lasso、Ridge
  • 如果注重模型的可解释性，那么容易理解的线性回归、多项式回归比较适合。