转载

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

转载请注明出处，楼燚(yì)航的blog， http://www.cnblogs.com/louyihang-loves-baiyan/

这几种方法呢都是在求最优解中经常出现的方法，主要是应用迭代的思想来逼近。在梯度下降算法中，都是围绕以下这个式子展开：

/[/frac {/partial}{/partial /theta}{J(/theta)} = /frac{/partial}{/partial /theta} /frac{1}{2} /sum_{i=1}^{m}(h_/theta(x)-y)^2/]

其中在上面的式子中 /(h_/theta(x)/) 代表，输入为x的时候的其当时 /(/theta/) 参数下的输出值，与y相减则是一个相对误差，之后再平方乘以1/2，并且其中

/[h(x)=h_/theta(x)=/theta_0+/theta_1x_1+/theta_2x_2/]

这里我列举了一个简单的例子，当然实际的x可以有n多个维度。我们知道曲面上方向导数的最大值的方向就代表了梯度的方向，因此我们在做梯度下降的时候，应该是沿着梯度的反方向进行权重的更新，可以有效的找到全局的最优解。这个 /(/theta/) 的更新过程可以描述为

/[/theta_i=/theta_i-/alpha/frac{/partial}{/partial /theta} J(/theta) = /theta_i-/alpha(h_/theta(x)-y)x_i/]

我一开始看这个式子也没怎么看明白，后来想了一下，运来就是根据每一个x的分量以及当时的偏差值进行 /(/theta/)

的更新，其中

/(/alpha/)

为步长，一开始没搞清楚步长和学习速率的关系。这里提一下其实这两个是一个概念，叫法不一样，最优化问题中叫步长，但一般在神经网络中也叫学习速率，比较好理解。

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

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

梯度下降：梯度下降就是我上面的推导，要留意，在梯度下降中，对于 /(/theta/) 的更新，所有的样本都有贡献，也就是参与调整 /(/theta/) .其计算得到的是一个标准梯度。因而理论上来说一次更新的幅度是比较大的。如果样本不多的情况下，当然是这样收敛的速度会更快啦~
随机梯度下降：可以看到多了随机两个字，随机也就是说我用样本中的一个例子来近似我所有的样本，来调整 /(/theta/) ，因而随机梯度下降是会带来一定的问题，因为计算得到的并不是准确的一个梯度，容易陷入到局部最优解中
批量梯度下降：其实批量的梯度下降就是一种折中的方法，他用了一些小样本来近似全部的，其本质就是我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]

随机梯度下降

每次选取一个随机值，随机一个点更新 /(/theta/)

#-*- 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值是可以帮助网络加速收敛的。

原文 http://www.cnblogs.com/louyihang-loves-baiyan/p/5136447.html

正文到此结束