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

转载请注明出处，楼燚(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值是可以帮助网络加速收敛的。