线性回归、线性回归的损失和优化

「爱情、让人受尽委屈。」 2023-07-08 15:28 19阅读 0赞

# ![20191009191333910.png][][日萌社][Link 1] #

[人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]

--------------------

# 2.1 线性回归简介 #

## 1 线性回归应用场景 ##

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

举例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70][]

## 2 什么是线性回归 ##

### 2.1 定义与公式 ###

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

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

![20200226222418105.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1][]

那么怎么理解呢？我们来看几个例子

*  期末成绩：0.7×考试成绩+0.3×平时成绩
 *  房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率

上面两个例子，**我们看到特征值与目标值之间建立了一个关系，这个关系可以理解为线性模型**。

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

线性回归当中主要有两种模型，**一种是线性关系，另一种是非线性关系。**在这里我们只能画一个平面更好去理解，所以都用单个特征或两个特征举例子。

*  线性关系
    
     *  单变量线性关系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2][]

> 注释：单特征与目标值的关系呈直线关系，或者两个特征与目标值呈现平面的关系
> 
> 更高维度的我们不用自己去想，记住这种关系即可

*  非线性关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 3][]

## 3 小结 ##

*  线性回归的定义【了解】
    
     *  利用**回归方程(函数)**对**一个或多个自变量(特征值)和因变量(目标值)之间**关系进行建模的一种分析方式
 *  线性回归的分类【知道】
    
     *  线性关系
     *  非线性关系

--------------------

# 2.2 线性回归api初步使用 #

## 1 线性回归API ##

*  sklearn.linear\_model.LinearRegression()
    
     *  LinearRegression.coef\_：回归系数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 4][]

### 2.1 步骤分析 ###

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

### 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)
    
    estimator.coef_
    
    estimator.predict([[100, 80]])

## 3 小结 ##

*  sklearn.linear\_model.LinearRegression()
    
     *  LinearRegression.coef\_：回归系数

--------------------

# **linear\_demo.py ** #

# coding:utf-8
    
    from sklearn.linear_model import LinearRegression
    
    # 1.获取数据
    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]
    
    # 2.模型训练
    # 2.1 实例化一个估计器
    estimator = LinearRegression()
    
    # 2.2 使用fit方法进行训练
    estimator.fit(x, y)
    
    
    # 打印对应的系数:
    print("线性回归的系数是:\n", estimator.coef_)
    
    # 打印的预测结果是:
    print("输出预测结果:\n", estimator.predict([[100, 80]]))

--------------------

# 2.3 数学:求导 #

## 1 常见函数的导数 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 5][]

## 2 导数的四则运算 ##

![20200226222800454.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 6][]

## 4 矩阵（向量）求导 \[了解\] ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 7][]

## 3 小结 ##

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

--------------------

# 2.4 线性回归的损失和优化 #

假设刚才的房子例子，真实的数据之间存在这样的关系：

真实关系：真实房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率

那么现在呢，我们随意指定一个关系（猜测）

随机指定关系：预测房子价格 = 0.25×中心区域的距离 + 0.14×城市一氧化氮浓度 + 0.42×自住房平均房价 + 0.34×城镇犯罪率

请问这样的话，会发生什么？真实结果与我们预测的结果之间是不是存在一定的误差呢？类似这样样子

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 8][]

既然存在这个误差，那我们就将这个误差给衡量出来

## 1 损失函数 ##

总损失定义为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 9][]

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

## 2 优化算法 ##

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

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

### 2.1 正规方程 ###

2.1.1 什么是正规方程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 10][]

### 2.1.2 正规方程求解举例 ###

以下表示数据为例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 11][]

2.1.3 正规方程的推导

*  **推导方式一：**

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

![20200226223010136.png][]

其中y是真实值矩阵，X是特征值矩阵，w是权重矩阵

对其求解关于w的最小值，起止y,X 均已知二次函数直接求导，导数为零的位置，即为最小值。

求导：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 12][]

# 正规方程的另一种推导方式 #

## 1.损失表示方式 ##

总损失定义为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 14][]

### 2.2 梯度下降(Gradient Descent) ###

2.2.1 什么是梯度下降

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

假设这样一个场景：

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 15][]

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

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

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

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

2.2.2 梯度的概念

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

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

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

2.2.3 梯度下降举例

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 17][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 18][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 19][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 20][]

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

### ![20200226223149160.png][] ###

**1) α是什么含义？**

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 21][]

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 22][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 23][]

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

*  **优化动态图演示**

![2020022622323883.gif][]

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

### 3.1 两种方法对比 ###

<table> 
 <thead> 
  <tr> 
   <th>梯度下降</th> 
   <th>正规方程</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>需要选择学习率</td> 
   <td>不需要</td> 
  </tr> 
  <tr> 
   <td>需要迭代求解</td> 
   <td>一次运算得出</td> 
  </tr> 
  <tr> 
   <td>特征数量较大可以使用</td> 
   <td>需要计算方程，时间复杂度高O(n3)</td> 
  </tr> 
 </tbody> 
</table>

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 24][]

### 3.2 算法选择依据： ###

*  小规模数据：
    
     *  正规方程：**LinearRegression(不能解决拟合问题)**
     *  岭回归
 *  大规模数据：
    
     *  梯度下降法：**SGDRegressor**

经过前面介绍，我们发现在真正的开发中，我们使用梯度下降法偏多（深度学习中更加明显），下一节中我们会进一步介绍梯度下降法的一些原理。

## 4 小结 ##

*  损失函数【知道】
    
     *  最小二乘法
 *  线性回归优化方法【知道】
    
     *  正规方程
     *  梯度下降法
 *  正规方程 -- 一蹴而就【知道】
    
     *  利用矩阵的逆,转置进行一步求解
     *  只是适合样本和特征比较少的情况
 *  梯度下降法 — 循序渐进【知道】
    
     *  梯度的概念
        
         *  单变量 -- 切线
         *  多变量 -- 向量
     *  梯度下降法中关注的两个参数
        
         *  α -- 就是步长
            
             *  步长太小 -- 下山太慢
             *  步长太大 -- 容易跳过极小值点(**\***)
         *  为什么梯度要加一个负号
            
             *  梯度方向是上升最快方向,负号就是下降最快方向
 *  梯度下降法和正规方程选择依据【知道】
    
     *  小规模数据：
        
         *  正规方程：**LinearRegression(不能解决拟合问题)**
         *  岭回归
     *  大规模数据：
        
         *  梯度下降法：**SGDRegressor**

--------------------

# 2.5 梯度下降方法介绍 #

上一节中给大家介绍了最基本的梯度下降法实现流程，本节我们将进一步介绍**梯度下降法的详细过算法推导过程**和**常见的梯度下降算法**。

## 1 详解梯度下降算法 ##

### 1.1梯度下降的相关概念复习 ###

在详细了解梯度下降的算法之前，我们先复习相关的一些概念。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 25][]

### 1.2 梯度下降法的推导流程 ###

**1) 先决条件： 确认优化模型的假设函数和损失函数。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 26][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 27][]

在下面一节中，咱们会详细讲到梯度下降法的变种，他们主要的区别就是**对样本的采用方法不同。这里我们采用的是用所有样本。**

## 2 梯度下降法大家族 ##

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

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

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

### 2.1 全梯度下降算法(FG) ###

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 28][]

注意：

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

### 2.2 随机梯度下降算法(SG) ###

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

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

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

![2020022622344541.png][]

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

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

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

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

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

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

![20200226223501505.png][]

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

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

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

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

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

其迭代形式为：

![20200226223517248.png][]

*  我们知道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][https_arxiv.org_pdf_1309.2388.pdf]

## 3 小结 ##

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

--------------------

# 梯度下降法算法比较和进一步优化 #

常见的梯度下降算法有：

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

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

我们通过一个数据集案例进行对比，查看他们的区别

## 1 算法比较 ##

为了比对四种基本梯度下降算法的性能，我们通过一个逻辑二分类实验来说明。本文所用的Adult数据集来自UCI公共数据库（[http://archive.ics.uci.edu/ml/datasets/Adult）。][http_archive.ics.uci.edu_ml_datasets_Adult] 数据集共有15081条记录，包括“性别”“年龄”“受教育情况”“每周工作时常”等14个特征，数据标记列显示“年薪是否大于50000美元”。我们将数据集的80%作为训练集，剩下的20%作为测试集，使用逻辑回归建立预测模型，根据数据点的14个特征预测其数据标记（收入情况）。

以下6幅图反映了模型优化过程中四种梯度算法的性能差异。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 29][]

在图1和图2中，横坐标代表有效迭代次数，纵坐标代表平均损失函数值。图1反映了前25次有效迭代过程中平均损失函数值的变化情况，为了便于观察，图2放大了第10次到25次的迭代情况。

从图1中可以看到，**四种梯度算法下，平均损失函数值随迭代次数的增加而减少**。**FG的迭代效率始终领先**，能在较少的迭代次数下取得较低的平均损失函数值。**FG与SAG的图像较平滑**，这是因为这两种算法在进行梯度更新时都结合了之前的梯度；**SG与mini-batch的图像曲折明显**，这是因为这两种算法在每轮更新梯度时都随机抽取一个或若干样本进行计算，并没有考虑到之前的梯度。

从图2中可以看到**虽然四条折现的纵坐标虽然都趋近于0，但SG和FG较早，mini-batch最晚。**这说明如果想使用mini-batch获得最优参数，必须对其进行较其他三种梯度算法更多频次的迭代。

在图3，4，5，6中，横坐标表示时间，纵坐标表示平均损失函数值。

从图3中可以看出使用四种算法将平均损失函数值从0.7降到0.1最多只需要2.5s，由于本文程序在初始化梯度时将梯度设为了零，故前期的优化效果格外明显。其中SG在前期的表现最好，仅1.75s便将损失函值降到了0.1，虽然SG无法像FG那样达到线性收敛，但在处理大规模机器学习问题时，**为了节约时间成本和存储成本，可在训练的一开始先使用SG，后期考虑到收敛性和精度可改用其他算法。**

从图4，5，6可以看出，随着平均损失函数值的不断减小，SG的性能逐渐反超FG，FG的优化效率最慢，即达到相同平均损失函数值时FG所需要的时间最久。

综合分析六幅图我们得出以下结论：

（1**）FG方法由于它每轮更新都要使用全体数据集，故花费的时间成本最多，内存存储最大。**

**（2）SAG在训练初期表现不佳，优化速度较慢。这是因为我们常将初始梯度设为0，而SAG每轮梯度更新都结合了上一轮梯度值。**

**（3）综合考虑迭代次数和运行时间，SG表现性能都很好，能在训练初期快速摆脱初始梯度值，快速将平均损失函数降到很低。但要注意，在使用SG方法时要慎重选择步长，否则容易错过最优解。**

**（4）mini-batch结合了SG的“胆大”和FG的“心细”，从6幅图像来看，它的表现也正好居于SG和FG二者之间。在目前的机器学习领域，mini-batch是使用最多的梯度下降算法，正是因为它避开了FG运算效率低成本大和SG收敛效果不稳定的缺点。**

## 2 梯度下降优化算法 ##

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

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

--------------------

# 2.6 线性回归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， 可以根据选择使用

## 小结 ##

*  正规方程
    
     *  sklearn.linear\_model.LinearRegression()
 *  梯度下降法
    
     *  sklearn.linear\_model.SGDRegressor(）

--------------------

# 2.7 案例：波士顿房价预测 #

## 1 案例背景介绍 ##

*  数据介绍

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 30][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 31][]

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

## 2 案例分析 ##

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

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

## 3 回归性能评估 ##

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 32][]

## 4 代码实现 ##

### 4.1 正规方程 ###

def linear_model1():
        """
        线性回归:正规方程
        :return:None
        """
        # 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 = LinearRegression()
        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)
    
        return None

### 4.2 梯度下降法 ###

def linear_model2():
        """
        线性回归:梯度下降法
        :return:None
        """
        # 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("预测值为:\n", y_predict)
        print("模型中的系数为:\n", estimator.coef_)
        print("模型中的偏置为:\n", estimator.intercept_)
    
        # 5.2 评价
        # 均方误差
        error = mean_squared_error(y_test, y_predict)
        print("误差为:\n", error)
    
        return None

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

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

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

## 5 小结 ##

*  正规方程和梯度下降法api在真实案例中的使用【知道】
 *  线性回归性能评估【知道】
    
     *  均方误差

--------------------

# 2.8 欠拟合和过拟合 #

## 1 定义 ##

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 33][]

那么是什么原因导致模型复杂？线性回归进行训练学习的时候变成模型会变得复杂，这里就对应前面再说的线性回归的两种关系，非线性关系的数据，也就是存在很多无用的特征或者现实中的事物特征跟目标值的关系并不是简单的线性关系。

## 2 原因以及解决办法 ##

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

## 3 正则化 ##

### 3.1 什么是正则化 ###

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 34][]

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

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

### 3.2 正则化类别 ###

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

## 4 小结 ##

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

--------------------

# 向量与矩阵的范数 #

## 1.向量的范数 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 35][]

## 2.矩阵的范数 ##

设：向量，矩阵，例如矩阵A为：

A=[2, 3, -5, -7;
    
       4, 6,  8, -4;
    
       6, -11, -3, 16];

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 36][]

--------------------

# 2.9 正则化线性模型 #

*  Ridge Regression 岭回归
 *  Lasso 回归
 *  Elastic Net 弹性网络
 *  Early stopping

## 1 Ridge Regression (岭回归，又名 Tikhonov regularization) ##

岭回归是线性回归的正则化版本，即在原来的线性回归的 cost function 中添加正则项（regularization term）:

![20200226224508804.png][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 37][]

## 2 Lasso Regression(Lasso 回归) ##

Lasso 回归是线性回归的另一种正则化版本，正则项为权值向量的ℓ1范数。

Lasso回归的代价函数 ：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 38][]

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

例如：当α 取值相对较大时，高阶多项式退化为二次甚至是线性：高阶多项式特征的权重被置为0。

也就是说，Lasso Regression 能够自动进行特征选择，并输出一个稀疏模型（只有少数特征的权重是非零的）。

## 3 Elastic Net (弹性网络) ##

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

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

弹性网络的代价函数 ：

![20200226224550505.png][]

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

**小结：**

*  常用：岭回归
 *  假设只有少部分特征是有用的：
    
     *  弹性网络
     *  Lasso
     *  一般来说，弹性网络的使用更为广泛。因为在特征维度高于训练样本数，或者特征是强相关的情况下，Lasso回归的表现不太稳定。
 *  api:
    
     *      from sklearn.linear_model import Ridge, ElasticNet, Lasso

## 4 Early Stopping \[了解\] ##

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

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

## 5 小结 ##

*  Ridge Regression 岭回归
    
     *  就是把系数添加平方项
     *  然后限制系数值的大小
     *  α值越小，系数值越大，α越大，系数值越小
 *  Lasso 回归
    
     *  对系数值进行绝对值处理
     *  由于绝对值在顶点处不可导，所以进行计算的过程中产生很多0，最后得到结果为：稀疏矩阵
 *  Elastic Net 弹性网络
    
     *  是前两个内容的综合
     *  设置了一个r,如果r=0--岭回归；r=1--Lasso回归
 *  Early stopping
    
     *  通过限制错误率的阈值，进行停止

--------------------

# 2.10 线性回归的改进-岭回归 #

## 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):

## 2 观察正则化程度的变化，对结果的影响？ ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 39][]

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

## 3 波士顿房价预测 ##

def linear_model3():
        """
        线性回归:岭回归
        :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.机器学习-线性回归(岭回归)
        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)

## 4 小结 ##

*  sklearn.linear\_model.Ridge(alpha=1.0, fit\_intercept=True,solver="auto", normalize=False)【知道】
    
     *  具有l2正则化的线性回归
     *  alpha -- 正则化
        
         *  正则化力度越大，权重系数会越小
         *  正则化力度越小，权重系数会越大
     *  normalize
        
         *  默认封装了，对数据进行标准化处理

--------------------

# **price\_predict.py ** #

# coding:utf-8
    
    """
    # 1.获取数据
    # 2.数据基本处理
    # 2.1 分割数据
    # 3.特征工程-标准化
    # 4.机器学习-线性回归
    # 5.模型评估
    """
    
    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, RidgeCV, Ridge
    from sklearn.metrics import mean_squared_error
    
    
    def linear_model1():
        """
        线性回归:正规方程
        :return:
        """
        # 1.获取数据
        boston = load_boston()
        # print(boston)
    
        # 2.数据基本处理
        # 2.1 分割数据
        x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)
    
        # 3.特征工程-标准化
        transfer = StandardScaler()
        x_train = transfer.fit_transform(x_train)
        x_test = transfer.fit_transform(x_test)
    
        # 4.机器学习-线性回归
        estimator = LinearRegression()
        estimator.fit(x_train, y_train)
    
        print("这个模型的偏置是:\n", estimator.intercept_)
        print("这个模型的系数是:\n", estimator.coef_)
    
        # 5.模型评估
        # 5.1 预测值
        y_pre = estimator.predict(x_test)
        # print("预测值是:\n", y_pre)
    
        # 5.2 均方误差
        ret = mean_squared_error(y_test, y_pre)
        print("均方误差:\n", ret)
    
    
    def linear_model2():
        """
        线性回归:梯度下降法
        :return:
        """
        # 1.获取数据
        boston = load_boston()
        # print(boston)
    
        # 2.数据基本处理
        # 2.1 分割数据
        x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)
    
        # 3.特征工程-标准化
        transfer = StandardScaler()
        x_train = transfer.fit_transform(x_train)
        x_test = transfer.fit_transform(x_test)
    
        # 4.机器学习-线性回归
        # estimator = SGDRegressor(max_iter=1000, learning_rate="constant", eta0=0.001)
        estimator = SGDRegressor(max_iter=1000)
        estimator.fit(x_train, y_train)
    
        print("这个模型的偏置是:\n", estimator.intercept_)
        print("这个模型的系数是:\n", estimator.coef_)
    
        # 5.模型评估
        # 5.1 预测值
        y_pre = estimator.predict(x_test)
        # print("预测值是:\n", y_pre)
    
        # 5.2 均方误差
        ret = mean_squared_error(y_test, y_pre)
        print("均方误差:\n", ret)
    
    
    def linear_model3():
        """
        线性回归:岭回归
        :return:None
        """
        # 1.获取数据
        boston = load_boston()
        # print(boston)
    
        # 2.数据基本处理
        # 2.1 分割数据
        x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)
    
        # 3.特征工程-标准化
        transfer = StandardScaler()
        x_train = transfer.fit_transform(x_train)
        x_test = transfer.fit_transform(x_test)
    
        # 4.机器学习-线性回归
        # estimator = Ridge(alpha=1.0)
        estimator = RidgeCV(alphas=(0.001, 0.01, 0.1, 1, 10, 100))
        estimator.fit(x_train, y_train)
    
        print("这个模型的偏置是:\n", estimator.intercept_)
        print("这个模型的系数是:\n", estimator.coef_)
    
        # 5.模型评估
        # 5.1 预测值
        y_pre = estimator.predict(x_test)
        # print("预测值是:\n", y_pre)
    
        # 5.2 均方误差
        ret = mean_squared_error(y_test, y_pre)
        print("均方误差:\n", ret)
    
    
    if __name__ == '__main__':
        linear_model1()
        linear_model2()
        linear_model3()

--------------------

# 2.11 模型的保存和加载 #

## 1 sklearn模型的保存和加载API ##

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

## 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)

## 3 小结 ##

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

--------------------

# **model\_dump\_load.py ** #

# coding:utf-8
    
    # coding:utf-8
    
    
    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, RidgeCV, Ridge
    from sklearn.metrics import mean_squared_error
    from sklearn.externals import joblib
    
    
    def dump_load():
        """
        模型保存和加载
        :return:None
        """
        # 1.获取数据
        boston = load_boston()
        # print(boston)
    
        # 2.数据基本处理
        # 2.1 分割数据
        x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22, test_size=0.2)
    
        # 3.特征工程-标准化
        transfer = StandardScaler()
        x_train = transfer.fit_transform(x_train)
        x_test = transfer.fit_transform(x_test)
    
        # # 4.机器学习-线性回归
        # # 4.1 模型训练
        # # estimator = Ridge(alpha=1.0)
        # estimator = RidgeCV(alphas=(0.001, 0.01, 0.1, 1, 10, 100))
        # estimator.fit(x_train, y_train)
        #
        # # 4.2 模型保存
        # joblib.dump(estimator, "./data/test.pkl")
    
        # 4.3 模型加载
        estimator = joblib.load("./data/test.pkl")
    
        print("这个模型的偏置是:\n", estimator.intercept_)
        print("这个模型的系数是:\n", estimator.coef_)
    
        # 5.模型评估
        # 5.1 预测值
        y_pre = estimator.predict(x_test)
        # print("预测值是:\n", y_pre)
    
        # 5.2 均方误差
        ret = mean_squared_error(y_test, y_pre)
        print("均方误差:\n", ret)
    
    
    if __name__ == '__main__':
        dump_load()

[20191009191333910.png]: https://img-blog.csdnimg.cn/20191009191333910.png
[Link 1]: http://www.rimengshe.com/
[AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]: https://blog.csdn.net/zimiao552147572/article/details/88867161
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200226222406523.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200226222418105.png]: https://img-blog.csdnimg.cn/20200226222418105.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200226222426749.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200226222518271.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200226222529768.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200226222559668.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200226222752694.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200226222800454.png]: https://img-blog.csdnimg.cn/20200226222800454.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200226222808541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200226222820649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200226222852713.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200226222933448.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/2020022622294261.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200226223000131.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200226223010136.png]: https://img-blog.csdnimg.cn/20200226223010136.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200226223026134.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/202002262237343.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/2020022622374820.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200226223037253.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200226223103258.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200226223103253.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20200226223115378.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20200226223123353.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20200226223131169.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200226223149160.png]: https://img-blog.csdnimg.cn/20200226223149160.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20200226223200126.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20200226223209539.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 23]: https://img-blog.csdnimg.cn/2020022622321791.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[2020022622323883.gif]: https://img-blog.csdnimg.cn/2020022622323883.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 24]: https://img-blog.csdnimg.cn/20200226223255829.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 25]: https://img-blog.csdnimg.cn/20200226223338952.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 26]: https://img-blog.csdnimg.cn/20200226223356866.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 27]: https://img-blog.csdnimg.cn/20200226223409526.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 28]: https://img-blog.csdnimg.cn/20200226223431952.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[2020022622344541.png]: https://img-blog.csdnimg.cn/2020022622344541.png
[20200226223501505.png]: https://img-blog.csdnimg.cn/20200226223501505.png
[20200226223517248.png]: https://img-blog.csdnimg.cn/20200226223517248.png
[https_arxiv.org_pdf_1309.2388.pdf]: https://arxiv.org/pdf/1309.2388.pdf
[http_archive.ics.uci.edu_ml_datasets_Adult]: http://archive.ics.uci.edu/ml/datasets/Adult%EF%BC%89%E3%80%82
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 29]: https://img-blog.csdnimg.cn/20200226223838474.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 30]: https://img-blog.csdnimg.cn/20200226224238593.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 31]: https://img-blog.csdnimg.cn/2020022622424574.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 32]: https://img-blog.csdnimg.cn/20200226224256277.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 33]: https://img-blog.csdnimg.cn/20200226224323294.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 34]: https://img-blog.csdnimg.cn/20200226224349598.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 35]: https://img-blog.csdnimg.cn/20200226224422624.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 36]: https://img-blog.csdnimg.cn/202002262244359.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200226224508804.png]: https://img-blog.csdnimg.cn/20200226224508804.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 37]: https://img-blog.csdnimg.cn/20200226224518211.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 38]: https://img-blog.csdnimg.cn/20200226224535342.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200226224550505.png]: https://img-blog.csdnimg.cn/20200226224550505.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 39]: https://img-blog.csdnimg.cn/20200226224632989.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70