批量梯度下降， 随机梯度下降，小批量梯度下降

批量梯度下降， 随机梯度下降，小批量梯度下降

• 批量梯度下降

  计算梯度时，使用全部的样本，换句话说就是，每一次参数更新，使用所有的样本

  缺点：当样本很多时，训练过程非常慢

• 随机梯度下降

  计算梯度的时，仅仅使用一个样本，换句话说就是，每一次参数更新，使用一个样本。

  换句话说，可以是个增量更新的过程。

  缺点：每一次更新，计算出来的‘‘梯度’’并不是真正的梯度，也就是说每一次更新，

  并不是朝着整体最优的方向进行的。

• 小批量梯度下降

  计算梯度时，使用一部分样本。换句话说就是，每一次参数更新，使用样本中的一小部分

  优点：是上面两种算法的一个平衡

• python代码

  批量梯度下降算法

  from numpy import *
  
  #input x input y
  X = [[1, 1, 1], [2, 2, 2], [1, 1, 0], [5, 1, 0], [3, 2 , 1], \
      [1, 0, 1], [7, 0, 2], [8, 1, 0], [5, 6, 5], [0, 0, 0]] 
  Y = [6, 11, 4, 12, 11, 5, 19, 18, 27, 1]
  
  X, Y = mat(X), mat(Y)
  X = insert(X, 0, ones(shape(X)[0]), axis=1)
  m, n = shape(X)
  
  #阈值 步长(步长较大，疯狂震荡), 最大迭代次数
  threshold, step, iterator =  0.00001, 0.001, 10000
   
  #初始化参数  计算初始误差
  theta = ones((n, 1))
  preError = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
  
  times = 0
  while times < iterator:
      times += 1
      theta = theta - step * X.transpose() * (X * theta - Y.transpose())
      #计算新参数的误差
      error = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
      if abs(preError - error) < threshold:
          break
      else:
          preError = error
  print ('ParValue: ', theta)
  

  随机梯度下降算法

  from numpy import *
  
  #input x input y
  X = [[1, 1, 1], [2, 2, 2], [1, 1, 0], [5, 1, 0], [3, 2 , 1], \
      [1, 0, 1], [7, 0, 2], [8, 1, 0], [5, 6, 5], [0, 0, 0]] 
  Y = [6, 11, 4, 12, 11, 5, 19, 18, 27, 1]
  
  X, Y = mat(X), mat(Y)
  X = insert(X, 0, ones(shape(X)[0]), axis=1)
  m, n = shape(X)
  
  #阈值 步长(步长较大，疯狂震荡), 最大迭代次数
  threshold, step, iterator =  0.00001, 0.001, 10000
   
  #初始化参数  计算初始误差
  theta = ones((n, 1))
  preError = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
  
  times = 0
  while times < iterator:
      times += 1
      for index in range(m):
          #修改这一行
          theta = theta - step * X[index].transpose() * (X[index] * theta - Y.transpose()[index])
          #计算新参数的误差
          error = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
          if abs(preError - error) < threshold:
              times = iterator
              break
          else:
              preError = error
  print ('ParValue: ', theta)
  

  小批量梯度下降

  from numpy import *
  
  #input x input y
  X = [[1, 1, 1], [2, 2, 2], [1, 1, 0], [5, 1, 0], [3, 2 , 1], \
      [1, 0, 1], [7, 0, 2], [8, 1, 0], [5, 6, 5], [0, 0, 0]] 
  Y = [6, 11, 4, 12, 11, 5, 19, 18, 27, 1]
  
  X, Y = mat(X), mat(Y)
  X = insert(X, 0, ones(shape(X)[0]), axis=1)
  m, n = shape(X)
  
  #阈值 步长(步长较大，疯狂震荡), 最大迭代次数
  threshold, step, iterator =  0.00001, 0.001, 10000
   
  #初始化参数  计算初始误差
  theta = ones((n, 1))
  preError = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
  
  #一次选三个小样本
  b = 3; times = 0
  
  while times < iterator:
      times += 1; start = 0
      while start < m:
          tempX = X[start:start+b]
          tempY = Y.transpose()[start:start+b];
          #修改这一行
          theta = theta - step * tempX.transpose() * (tempX * theta - tempY)
          #计算新参数的误差
          error = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
          if abs(preError - error) < threshold:
              time = iterator
              break
          else:
              preError = error
          start += b
  
  print ('ParValue: ', theta)