梯度下降、随机梯度下降和批量梯度下降

转自https://www.cnblogs.com/louyihang-loves-baiyan/p/5136447.html

 

对比梯度下降和随机梯度下降和批量梯度下降

之前看的知识比较零散，没有一个系统的解释说明，看了一些网上的博主的分析，总结了一下自己的理解。

• 梯度下降：梯度下降就是我上面的推导，要留意，在梯度下降中，对于θθ的更新，所有的样本都有贡献，也就是参与调整θθ.其计算得到的是一个标准梯度。因而理论上来说一次更新的幅度是比较大的。如果样本不多的情况下，当然是这样收敛的速度会更快啦~

• 随机梯度下降：可以看到多了随机两个字，随机也就是说我用样本中的一个例子来近似我所有的样本，来调整θθ，因而随机梯度下降是会带来一定的问题，因为计算得到的并不是准确的一个梯度，容易陷入到局部最优解中

• 批量梯度下降：其实批量的梯度下降就是一种折中的方法，他用了一些小样本来近似全部的，其本质就是我1个指不定不太准，那我用个30个50个样本那比随机的要准不少了吧，而且批量的话还是非常可以反映样本的一个分布情况的。

例子这里我参照其他博主的例子做了一些修改，首先是梯度下降

#-*- coding: utf-8 -*-
import random
#This is a sample to simulate a function y = theta1*x1 + theta2*x2
input_x = [[1,4], [2,5], [5,1], [4,2]]  
y = [19,26,19,20]  
theta = [1,1]
loss = 10
step_size = 0.001
eps =0.0001
max_iters = 10000
error =0
iter_count = 0
while( loss > eps and iter_count < max_iters):
    loss = 0
    #这里更新权重的时候所有的样本点都用上了
    for i in range (3):
        pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
        theta[0] = theta[0] - step_size * (pred_y - y[i]) * input_x[i][0]
        theta[1] = theta[1] - step_size * (pred_y - y[i]) * input_x[i][1]
    for i in range (3):
        pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
        error = 0.5*(pred_y - y[i])**2
        loss = loss + error
    iter_count += 1
    print 'iters_count', iter_count

print 'theta: ',theta 
print 'final loss: ', loss
print 'iters: ', iter_count

iters_count 219
iters_count 220
iters_count 221
iters_count 222
iters_count 223
iters_count 224
iters_count 225
theta: [3.0027765778748003, 3.997918297015663]
final loss: 9.68238055213e-05
iters: 225
[Finished in 0.2s]

随机梯度下降

每次选取一个随机值，随机一个点更新θθ

#-*- coding: utf-8 -*-
import random
#This is a sample to simulate a function y = theta1*x1 + theta2*x2
input_x = [[1,4], [2,5], [5,1], [4,2]]  
y = [19,26,19,20]  
theta = [1,1]
loss = 10
step_size = 0.001
eps =0.0001
max_iters = 10000
error =0
iter_count = 0
while( loss > eps and iter_count < max_iters):
    loss = 0
    #每一次选取随机的一个点进行权重的更新
    i = random.randint(0,3)
    pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
    theta[0] = theta[0] - step_size * (pred_y - y[i]) * input_x[i][0]
    theta[1] = theta[1] - step_size * (pred_y - y[i]) * input_x[i][1]
    for i in range (3):
        pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
        error = 0.5*(pred_y - y[i])**2
        loss = loss + error
    iter_count += 1
    print 'iters_count', iter_count

print 'theta: ',theta 
print 'final loss: ', loss
print 'iters: ', iter_count

其结果的输出是

iters_count 1226
iters_count 1227
iters_count 1228
iters_count 1229
iters_count 1230
iters_count 1231
iters_count 1232
theta: [3.002441488688225, 3.9975844154600226]
final loss: 9.989420302e-05
iters: 1232
[Finished in 0.3s]

批量随机梯度下降

这里用了2个样本点

#-*- coding: utf-8 -*-
import random
#This is a sample to simulate a function y = theta1*x1 + theta2*x2
input_x = [[1,4], [2,5], [5,1], [4,2]]  
y = [19,26,19,20]  
theta = [1,1]
loss = 10
step_size = 0.001
eps =0.0001
max_iters = 10000
error =0
iter_count = 0
while( loss > eps and iter_count < max_iters):
    loss = 0
    
    i = random.randint(0,3) #注意这里，我这里批量每次选取的是2个样本点做更新，另一个点是随机点+1的相邻点
    j = (i+1)%4
    pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
    theta[0] = theta[0] - step_size * (pred_y - y[i]) * input_x[i][0]
    theta[1] = theta[1] - step_size * (pred_y - y[i]) * input_x[i][1]

    pred_y = theta[0]*input_x[j][0]+theta[1]*input_x[j][1]
    theta[0] = theta[0] - step_size * (pred_y - y[j]) * input_x[j][0]
    theta[1] = theta[1] - step_size * (pred_y - y[j]) * input_x[j][1]
    for i in range (3):
        pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
        error = 0.5*(pred_y - y[i])**2
        loss = loss + error
    iter_count += 1
    print 'iters_count', iter_count

print 'theta: ',theta 
print 'final loss: ', loss
print 'iters: ', iter_count

其最后的输出结果是

.....
iters_count 543
iters_count 544
iters_count 545
iters_count 546
iters_count 547
iters_count 548
iters_count 549
theta: [3.0023012574840764, 3.997553282857357]
final loss: 9.81717138358e-05
iters: 549

对比一下结果，每个例子我都跑了几次，基本上都维持在哪个迭代次数，可以看到梯度下降迭代的次数最少，因为我这里样本点少，所以这样快。数据多了的话，你想动则几万的样本计算一次的时间就够呛。随机梯度的话因为每次都用一个样本，所以收敛的速度就会慢一些。批量的话这里用了2个样本点，因而速度基本上随机是1200度次迭代，批量大概是550。
其实这些概念一开始没搞明白，在Caffe中，跑网络，里面让你选的这个batch其实就是这么回事。你设一个比较恰当的batch值是可以帮助网络加速收敛的。