机器学习：随机梯度下降法（线性回归中的应用）

一、指导思想

　# 只针对线性回归中的使用

• 算法的最优模型的功能：预测新的样本对应的值；

• 什么是最优的模型：能最大程度的拟合住数据集中的样本数据；

• 怎么才算最大程度的拟合：让数据集中的所有样本点，在特征空间中距离线性模型的距离的和最小；（以线性模型为例说明）

• 怎么得到最优模型：求出最优模型对应的参数；

• 怎么求解最优模型的参数：通过数学方法，得到目标函数（此函数计算数据集中的所有样本点，在特征空间中到该线性模型的距离，也就是损失函数），通过批量梯度下降法和随机梯度下降法对目标函数进行优化，得到目标函数最小值时对应的参数；

• 梯度下降法的目的：求解最优模型对应的参数；（并不是为了求目标函数的最小值，这一点有助于理解随机梯度下降法）

 

二、批量梯度下降法基础

　1）批量梯度下降法的特点

 

1. 运算量大：批量梯度下降法中的每一项计算：，要计算所有样本（共 m 个）；
2. 批量梯度下降法的梯度是损失函数减小最快的方向，也就是说，对应相同的 theta 变化量，损失函数在梯度方向上的变化量最大；

 

 

　2）批量梯度下降法的思路

• 思路：计算损失函数的梯度，按梯度的方向，逐步减小损失函数的变量 theta，对应的损失函数也不断减小，直到损失函数的的变化量满足精度要求；
• 梯度计算：变形公式如下

 

• 梯度是优化的方向，损失函数的变量 theta 的变化量  =  学习率  X  当前梯度值

 

 

三、随机梯度下降法（Batch Gradient Descent）

　1）基础理解

• 思路：随机抽取 n （一般 n = 总样本数 / 3）个样本，在每个样本的梯度方向上逐步优化（每随机抽取一个样本就对 theta 做一次递减优化）变量 theta；
• 分析：批量梯度下降法的优化，是整体数据集的梯度方向逐步循环递减变量 theta ，随机梯度下降法，是数据集中的一个随机的样本的梯度方向，优化变量 theta；
• 特点一：直接优化变量 theta，而不需要计算 theta 对应的目标函数值；
• 特点二：不是按整体数据集的梯度方向优化，而是按随机抽取的某个样本的梯度方向进行优化；

 

 

　2）优化方向的公式

• 新的搜索方向计算公式（也即是优化的方向）：；

• 此处称为搜索方向，而不是梯度的计算公式，因为此公式已经不是梯度公式，而表示优化损失函数的方向；

• 随机梯度下降法的搜索路径：

• 特点：

1. 每一次搜索的方向，不能保证是损失函数减小的方向；
2. 每一次搜索的方向，不能保证是损失函数减小最快的方向；
3. 其优化方向具有不可预知性；

 

• 意义：

1. 实验结论表明，即使随机梯度下降法的优化方向具有不可预知性，通过此方法依然可以差不多来到损失函数最小值的附近，虽然不像批量梯度下降法那样，一定可以来到损失函数最小值位置，但是，如果样本数量很大时，有时可以用一定的模型精度，换取优化模型所用的时间；

 

• 实现技巧：确定学习率（η：eta）的取值，很重要；

1. 原因：在随机梯度下降法优化损失函数的过程中，如果 η 一直取固定值，可能会出现，已经优化到损失函数最小值位置了，但由于随机的过程不够好，η 又是各固定值，导致优化时慢慢的又跳出最小值位置；
2. 方案：优化过程中让 η 逐渐递减（随着梯度下降法循环次数的增加，η 值越来越小）；

 

 

　3）η 的确定过程

• 一：如果 η = 1 / i_iters；（i_iters：当前循环次数）

1. 问题：随着循环次数（i_iters）的增加，η 的变化率差别太大；

• 二：如果 η = 1 / (i_iters + b)；（b：为常量）

1. 解决了 η 的变化率差异过大

• 再次变形：η = a / (i_iters + b)；（a、b：为常量）

1. 分子改为 a ，增加 η 取值的灵活度；

　　

1. a、b：为随机梯度下降法的超参数；
2. 本次学习不对 a、b 调参，选用经验上比较适合的值：a = 5、b = 50；

 

• 学习率的特点

　　　# 学习率随着循环次数的增加，逐渐递减；

　　　# 这种逐渐递减的思想，是模拟在搜索领域的重要思路：模拟退火思想；

　　　# 模拟退火思想：在退火过程中的冷却函数，温度与冷却时间的关系；

• 一般根据模拟退火思想，学习率还可以表示：η = t₀ / (i_iters + t₁)

 

　4）循环次数的确定

• 原则

1. 将每个样本都随机抽取到；
2. 将每个样本至少抽取 n 次，也就是总的循环次数一般为：len(X_b) * n；

 

• 具体操作

1. 将变形后的数据集 X_b 的 index 做随机乱序处理，得到新的数据集 X_b_new ；
2. 根据乱序后的 index 逐个抽取 X_b_new 中的样本，循环 n 遍；

 

 

四、实现随机梯度下降法

• 优化方向：，结果是一个列向量；

　　　# array . dot(m) == array . m

• eta 取值：η = a / (i_iters + b)

 

• 优化结束条件

1. 批量梯度下降法：1）达到设定的循环次数；2）找到损失函数的最小值
2.  随机梯度下降法：达到设定的循环次数

• 随机梯度下降法中不能使用精度来结束优化：因为随机梯度下降法的优化方向，不一定全都是损失函数减小的方向；

 

　1）代码实现随机梯度下降法

• 模拟数据

  import numpy as np
  import matplotlib.pyplot as plt
  
  m = 100000
  
  x = np.random.normal(size=m)
  X = x.reshape(-1, 1)
  y = 4. * x + 3. + np.random.normal(0, 3, size=m)

   

• 批量梯度下降法

  def J(theta, X_b, y):
      try:
          return np.sum((y - X_b.dot(theta)) ** 2) / len(y)
      except:
          return float('inf')
      
  def dJ(theta, X_b, y):
      return X_b.T.dot(X_b.dot(theta) - y) * 2. / len(y)
  
  def gradient_descent(X_b, y, initial_theta, eta, n_iters=10**4, epsilon=10**-8):
      
      theta = initial_theta
      cur_iter = 0
      
      while cur_iter < n_iters:
          gradient = dJ(theta, X_b, y)
          last_theta = theta
          theta = theta - eta * gradient
          if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
              break
              
          cur_iter += 1
          
      return theta

  # cur_iter：循环次数
  # initial_theta：theta的初始化值

  %%time
  X_b = np.hstack([np.ones((len(X), 1)), X])
  initial_theta = np.zeros(X_b.shape[1])
  eta = 0.01
  theta = gradient_descent(X_b, y, initial_theta, eta)
  # 输出：Wall time: 898 ms

  theta
  # 输出：array([3.00280663, 3.9936598 ])

   

 

• 随机梯度下降法

  1） 通过每一次随机抽取的样本，计算 theta 的优化方向def dJ_sgd(theta, X_b_i, y_i):
      return X_b_i.T.dot(X_b_i.dot(theta) - y_i) * 2

  # X_b_i：是 X_b 中的一行数据，也就是一个随机样本，不在是全部的数据集
  # y_i：对应的随机抽取的样本的真值

  2） 随机优化过程
  def sgd(X_b, y, initial_theta, n_iters):
      
      # 计算学习率 eta
      t0 = 5
      t1 = 50
      
      # 定义求解学习率的函数
      def learning_rate(t):
          return t0 / (t + t1)
      
      theta = initial_theta
      for cur_iter in range(n_iters):
          rand_i = np.random.randint(len(X_b))
          gradient = dJ_sgd(theta, X_b[rand_i], y[rand_i])
          theta = theta - learning_rate(cur_iter) * gradient
          
      return theta

  # 此处的形参中不需要设置 eta 值了，eta 值随着循环的进行，在函数内部求取
  # cur_iter：当前循环次数
  # rand_i：从 [0, len(X_b)) 中随机抽取的一个数
  # gradient：一次循环中，随机样本的优化方向
  # learning_rate(cur_iter) * gradient：一次循环的 theta 的变化量

  3）给初始化数值，预测数据
  %%time
  X_b = np.hstack([np.ones((len(X), 1)), X])
  initial_theta = np.zeros(X_b.shape[1])
  theta = sgd(X_b, y, initial_theta, n_iters=len(X_b)//3)
  # 输出：Wall time: 287 ms

  4）查看最终优化结果
  theta
  # 输出：array([2.9648937 , 3.94467405])

 

 

　2）封装与调用自己的代码

• 封装：已规范循环次数（代码中的红色字样）

   1     def fit_sgd(self, X_train, y_train, n_iters=5, t0=5, t1=50):
   2         """根据训练数据集X_train, y_train, 使用梯度下降法训练Linear Regression模型"""
   3         assert X_train.shape[0] == y_train.shape[0], \
   4             "the size of X_train must be equal to the size of y_train"
   5         assert n_iters >= 1
   6 
   7         def dJ_sgd(theta, X_b_i, y_i):
   8             return X_b_i * (X_b_i.dot(theta) - y_i) * 2.
   9 
  10         def sgd(X_b, y, initial_theta, n_iters, t0=5, t1=50):
  11 
  12             def learning_rate(t):
  13                 return t0 / (t + t1)
  14 
  15             theta = initial_theta
  16             m = len(X_b)
  17 
  18             for cur_iter in range(n_iters):
  19                 indexes = np.random.permutation(m)
  20                 X_b_new = X_b[indexes]
  21                 y_new = y[indexes]
  22                 for i in range(m):
  23                     gradient = dJ_sgd(theta, X_b_new[i], y_new[i])
  24                     theta = theta - learning_rate(cur_iter * m + i) * gradient
  25 
  26             return theta
  27 
  28         X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
  29         initial_theta = np.random.randn(X_b.shape[1])
  30         self._theta = sgd(X_b, y_train, initial_theta, n_iters, t0, t1)
  31 
  32         self.intercept_ = self._theta[0]
  33         self.coef_ = self._theta[1:]
  34 
  35         return self

   # n_iters：对所有数据集循环的遍数；

 

• 调用自己封装的代码

1. 获取原始数据

   import numpy as np
   import matplotlib.pyplot as plt
   
   from sklearn import datasets
   
   boston = datasets.load_boston()
   X = boston.data
   y = boston.target
   
   X = X[y < 50.0]
   y = y[y < 50.0]

    

2. 数据分割

   from ALG.data_split import train_test_split
   
   X_train, X_test, y_train, y_test = train_test_split(X, y, seed=666)

    

3. 数据归一化

   from sklearn.preprocessing import StandardScaler
   
   standardScaler = StandardScaler()
   standardScaler.fit(X_train)
   X_train_standard = standardScaler.transform(X_train)
   X_test_standard = standardScaler.transform(X_test)

   # 数据归一化，主要是将训练数据集（X_train）和测试数据集（X_test）归一化；

4. 使用线性回归算法：LinearRegression

   from LR.LinearRegression import LinearRegression
   
   lin_reg = LinearRegression()
   %time lin_reg.fit_sgd(X_train_standard, y_train, n_iters=2)
   lin_reg.score(X_test_standard, y_test)
   # 输出：Wall time: 10 ms
          0.7865171620468298

   # 问题：通过score()函数得到的 R^2 值，也就是准确度过小
   # 原因：对所有的 X_train_standard 循环优化的遍数太少：n_iters=2

5. 循环遍数改为 50：n_iters=50

   %time lin_reg.fit_sgd(X_train_standard, y_train, n_iters=50)
   lin_reg.score(X_test_standard, y_test)
   # 输出：Wall time: 143 ms
          0.8085728716573835

    

6. 循环遍数改为 100：n_iters = 100

   %time lin_reg.fit_sgd(X_train_standard, y_train, n_iters=100)
   lin_reg.score(X_test_standard, y_test)
   # 输出：Wall time: 502 ms
          0.8125954368325295

    

7. 总结：随着循环遍数的增加，模型的准确度也随着增加；

 

　3）调用 scikit-learn 中的算法模型

• SGDRegressor：该算法虽是名为随机梯度下降法的回归器，但其只能解决线性模型，因为，其被封装在了 linear_model 线性回归模块中；

• 学习scikit-learn中的算法的过程：掉包 - 构建实例对象 - 拟合 - 验证训练模型的效果（查看准确度）

 

• 实现过程：前期的数据处理与步骤（2）相同

  from sklearn.linear_model import SGDRegressor
  
  sgd_reg = SGDRegressor()
  %time sgd_reg.fit(X_train_standard, y_train)
  sgd_reg.score(X_test_standard, y_test)
  # 输出：Wall time: 16 ms
          0.8065416815240762

  # 准确度为0.8065 左右，此时循环遍数使用默认的 5 遍：max_iter = 5

• 修改循环遍数：max_iter = 100

  sgd_reg = SGDRegressor(max_iter=100)
  %time sgd_reg.fit(X_train_standard, y_train)
  sgd_reg.score(X_test_standard, y_test)
  # 输出：Wall time: 8 ms
          0.813372455938393

   

 

　4）总结

• 与自己写的算法相比，scikit-learn中的算法的实现过程更加复杂，性能更优：

1. 通过计算时间就可以看出：n_iters=100时，自己的算法需要 502ms，scikit-learn中的算法需要 8ms；

2. 自己所学的封装好的算法，只是为了帮助理解算法的原来，而scikit-learn中使用了很多优化的方案

 

转载于:https://www.cnblogs.com/volcao/p/9144362.html