梯度优化算法

深度学习caffe:最优化方法

2017年02月14日 18:17:49 generalAI 阅读数:5422

上文提到,到目前为止,caffe总共提供了六种优化方法:

  • Stochastic Gradient Descent (type: "SGD"),
  • AdaDelta (type: "AdaDelta"),
  • Adaptive Gradient (type: "AdaGrad"),
  • Adam (type: "Adam"),
  • Nesterov’s Accelerated Gradient (type: "Nesterov") and
  • RMSprop (type: "RMSProp")

Solver就是用来使loss最小化的优化方法。对于一个数据集D,需要优化的目标函数是整个数据集中所有数据loss的平均值。

其中,fW(x(i))计算的是数据x(i)上的loss, 先将每个单独的样本x的loss求出来,然后求和,最后求均值。 r(W)是正则项(weight_decay),为了减弱过拟合现象。

如果采用这种Loss 函数,迭代一次需要计算整个数据集,在数据集非常大的这情况下,这种方法的效率很低,这个也是我们熟知的梯度下降采用的方法。


在实际中,通过将整个数据集分成几批(batches), 每一批就是一个mini-batch,其数量(batch_size)为N<<|D|,此时的loss 函数为:
 


有了loss函数后,就可以迭代的求解loss和梯度来优化这个问题。在神经网络中,用forward pass来求解loss,用backward pass来求解梯度。

在caffe中,默认采用的Stochastic Gradient Descent(SGD)进行优化求解。后面几种方法也是基于梯度的优化方法(like SGD),因此本文只介绍一下SGD。其它的方法,有兴趣的同学,可以去看文献原文。

 

1、Stochastic gradient descent(SGD)

随机梯度下降(Stochastic gradient descent)是在梯度下降法(gradient descent)的基础上发展起来的,梯度下降法也叫最速下降法,具体原理在网易公开课《机器学习》中,吴恩达教授已经讲解得非常详细。SGD在通过负梯度和上一次的权重更新值Vt的线性组合来更新W,迭代公式如下:

 


 
其中,  是负梯度的学习率(base_lr),是上一次梯度值的权重(momentum),用来加权之前梯度方向对现在梯度下降方向的影响。这两个参数需要通过tuning来得到最好的结果,一般是根据经验设定的。如果你不知道如何设定这些参数,可以参考相关的论文。

在深度学习中使用SGD,比较好的初始化参数的策略是把学习率设为0.01左右(base_lr: 0.01),在训练的过程中,如果loss开始出现稳定水平时,对学习率乘以一个常数因子(gamma),这样的过程重复多次。

对于momentum,一般取值在0.5--0.99之间。通常设为0.9,momentum可以让使用SGD的深度学习方法更加稳定以及快速。

关于更多的momentum,请参看Hinton的《A Practical Guide to Training Restricted Boltzmann Machines》。  

实例: 

base_lr: 0.01 
lr_policy: "step"
gamma: 0.1   
stepsize: 1000  
max_iter: 3500 
momentum: 0.9

lr_policy设置为step,则学习率的变化规则为 base_lr * gamma ^ (floor(iter / stepsize))

即前1000次迭代,学习率为0.01; 第1001-2000次迭代,学习率为0.001; 第2001-3000次迭代,学习率为0.00001,第3001-3500次迭代,学习率为10-5  

上面的设置只能作为一种指导,它们不能保证在任何情况下都能得到最佳的结果,有时候这种方法甚至不work。如果学习的时候出现diverge(比如,你一开始就发现非常大或者NaN或者inf的loss值或者输出),此时你需要降低base_lr的值(比如,0.001),然后重新训练,这样的过程重复几次直到你找到可以work的base_lr。

2、AdaDelta

AdaDelta是一种”鲁棒的学习率方法“,是基于梯度的优化方法(like SGD)。

具体的介绍文献:

M. Zeiler ADADELTA: AN ADAPTIVE LEARNING RATE METHOD. arXiv preprint, 2012.

示例:

复制代码

net: "examples/mnist/lenet_train_test.prototxt"
test_iter: 100
test_interval: 500
base_lr: 1.0
lr_policy: "fixed"
momentum: 0.95
weight_decay: 0.0005
display: 100
max_iter: 10000
snapshot: 5000
snapshot_prefix: "examples/mnist/lenet_adadelta"
solver_mode: GPU
type: "AdaDelta"
delta: 1e-6

复制代码

从最后两行可看出,设置solver type为Adadelta时,需要设置delta的值。

3、AdaGrad

自适应梯度(adaptive gradient)是基于梯度的优化方法(like SGD)

具体的介绍文献:

Duchi, E. Hazan, and Y. Singer. Adaptive Subgradient Methods for Online Learning and Stochastic Optimization. The Journal of Machine Learning Research, 2011.

示例:

复制代码

net: "examples/mnist/mnist_autoencoder.prototxt"
test_state: { stage: 'test-on-train' }
test_iter: 500
test_state: { stage: 'test-on-test' }
test_iter: 100
test_interval: 500
test_compute_loss: true
base_lr: 0.01
lr_policy: "fixed"
display: 100
max_iter: 65000
weight_decay: 0.0005
snapshot: 10000
snapshot_prefix: "examples/mnist/mnist_autoencoder_adagrad_train"
# solver mode: CPU or GPU
solver_mode: GPU
type: "AdaGrad"

复制代码

4、Adam

是一种基于梯度的优化方法(like SGD)。

 具体的介绍文献:

D. Kingma, J. Ba. Adam: A Method for Stochastic Optimization. International Conference for Learning Representations, 2015.

5、NAG

Nesterov 的加速梯度法(Nesterov’s accelerated gradient)作为凸优化中最理想的方法,其收敛速度非常快。

 具体的介绍文献:

 I. Sutskever, J. Martens, G. Dahl, and G. Hinton. On the Importance of Initialization and Momentum in Deep Learning. Proceedings of the 30th International Conference on Machine Learning, 2013.

示例:

复制代码

net: "examples/mnist/mnist_autoencoder.prototxt"
test_state: { stage: 'test-on-train' }
test_iter: 500
test_state: { stage: 'test-on-test' }
test_iter: 100
test_interval: 500
test_compute_loss: true
base_lr: 0.01
lr_policy: "step"
gamma: 0.1
stepsize: 10000
display: 100
max_iter: 65000
weight_decay: 0.0005
snapshot: 10000
snapshot_prefix: "examples/mnist/mnist_autoencoder_nesterov_train"
momentum: 0.95
# solver mode: CPU or GPU
solver_mode: GPU
type: "Nesterov"

复制代码

6、RMSprop

RMSprop是Tieleman在一次 Coursera课程演讲中提出来的,也是一种基于梯度的优化方法(like SGD)

具体的介绍文献:

T. Tieleman, and G. Hinton. RMSProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning.Technical report, 2012.

 示例:

复制代码

net: "examples/mnist/lenet_train_test.prototxt"
test_iter: 100
test_interval: 500
base_lr: 1.0
lr_policy: "fixed"
momentum: 0.95
weight_decay: 0.0005
display: 100
max_iter: 10000
snapshot: 5000
snapshot_prefix: "examples/mnist/lenet_adadelta"
solver_mode: GPU
type: "RMSProp"
rms_decay: 0.98

复制代码

最后两行,需要设置rms_decay值。

 

SGD

x+= -learning_rate*dx

Momentum

 

Momentum可以使SGD不至于陷入局部鞍点震荡,同时起到一定加速作用。
Momentum最开始有可能会偏离较远(overshooting the target),但是通常会慢慢矫正回来。

 
  1. v = mu*v - learning_rate*dx

  2. x+= v

Nesterov momentum

基本思路是每次不在x位置求dx,而是在x+mu*v处更新dx,然后在用动量公式进行计算
相当于每次先到动量的位置,然后求梯度更新
vt=μvt?1?ε▽f(θt?1+μvt?1)
θt=θt?1+vt
计算▽f(θt?1+μvt?1)不太方便,做如下变量替换:?t?1=θt?1+μvt?1 ,并带回上述公式可以得到
vt=μvt?1+ε▽f(?t?1)
?t?1=?t?1?μvt?1+(1+μ)vt

 
  1. v_prev = v

  2. v = mu*v-learning_rate*dx

  3. x += -mu*v_prev+(1+mu)*v

AdaGrad

使用每个变量的历史梯度值累加作为更新的分母,起到平衡不同变量梯度数值差异过大的问题

 
  1. cache += dx**2

  2. x += -learning_rate*dx/(np.sqrt(cache)+1e-7)

RMSProp

在AdaGrad基础上加入了decay factor,防止历史梯度求和过大

 
  1. cache = decay_rate*cache + (1-decay_rate)*dx**2

  2. x += -learning_rate*dx/(np.sqrt(cache)+1e-7)

ADAM

初始版本:类似于加入动量的RMSProp

 
  1. m = beta1*m + (1-beta1)*dx

  2. v = beta2*v + (1-beta2)*(dx**2)

  3. x += -learning_rate*m / (np.sqrt(v)+1e-7)

真实的更新算法如下:

 
  1. m = beta1*m + (1-beta1)*dx

  2. v = beta2*v + (1-beta2)*(dx**2)

  3. mb = m/(1-beta1**t) # t is step number

  4. vb = v/(1-beta2**t)

  5. x += -learning_rate*mb / (np.sqrt(vb)+1e-7)

mb和vb起到最开始的时候warm up作用,t很大之后(1-beta1**t) =1

Second Order optimization methods

second-order taylor expansion:
J(θ)≈J(θ0)+(θ?theta0)T+12(θ?θ0)TH(θ?θ0)
θ?=θ0?H?1▽θJ(θ0)

Quasi_newton methods (BFGS) with approximate inverse Hessian matrix L-BFGS (limited memory BFGS)
Does not form/store the full inverse Hessian.
Usually works very well in full batch, deterministic mode

实际经验

ADAM通常会取得比较好的结果,同时收敛非常快相比SGD L-BFGS适用于全batch做优化的情况 有时候可以多种优化方法同时使用,比如使用SGD进行warm up,然后ADAM 对于比较奇怪的需求,deepbit两个loss的收敛需要进行控制的情况,比较慢的SGD比较适用


tensorflow 不同优化算法对应的参数

SGD

optimizer = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate)

Momentum

optimizer = tf.train.MomentumOptimizer(lr, 0.9)

AdaGrad

optimizer = tf.train.AdagradientOptimizer(learning_rate=self.learning_rate)

RMSProp

optimizer = tf.train.RMSPropOptimizer(0.001, 0.9)

ADAM

optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, epsilon=1e-08)

部分局部参数需要查找tensorflow官方文档

直接进行优化
train_op = optimizer.minimize(loss)
获得提取进行截断等处理
gradients, v = zip(*optimizer.compute_gradients(loss))
gradients, _ = tf.clip_by_global_norm(gradients, self.max_gradient_norm)
train_op = optimizer.apply_gradients(zip(gradients, v), global_step=self.global_step)


Caffe 不同优化算法参数

caffe的优化需要在solver.prototxt中指定相应的参数

type代表的是优化算法

比较坑的是不同的版本之间type会有变化(ADAM or Adam),需要看具体代码
* Stochastic Gradient Descent (type: “SGD”),
* AdaDelta (type: “AdaDelta”),
* Adaptive Gradient (type: “AdaGrad”),
* Adam (type: “Adam”),
* Nesterov’s Accelerated Gradient (type: “Nesterov”) and
* RMSprop (type: “RMSProp”)

SGD

 
  1. base_lr: 0.01

  2. lr_policy: "step" # 也可以使用指数,多项式等等

  3. gamma: 0.1

  4. stepsize: 1000

  5. max_iter: 3500

  6. momentum: 0.9

AdaDelta

 
  1. net: "examples/mnist/lenet_train_test.prototxt"

  2. test_iter: 100

  3. test_interval: 500

  4. base_lr: 1.0

  5. lr_policy: "fixed"

  6. momentum: 0.95

  7. weight_decay: 0.0005

  8. display: 100

  9. max_iter: 10000

  10. snapshot: 5000

  11. snapshot_prefix: "examples/mnist/lenet_adadelta"

  12. solver_mode: GPU

  13. type: "AdaDelta"

  14. delta: 1e-6

AdaGrad

 
  1. net: "examples/mnist/mnist_autoencoder.prototxt"

  2. test_state: { stage: 'test-on-train' }

  3. test_iter: 500

  4. test_state: { stage: 'test-on-test' }

  5. test_iter: 100

  6. test_interval: 500

  7. test_compute_loss: true

  8. base_lr: 0.01

  9. lr_policy: "fixed"

  10. display: 100

  11. max_iter: 65000

  12. weight_decay: 0.0005

  13. snapshot: 10000

  14. snapshot_prefix: "examples/mnist/mnist_autoencoder_adagrad_train"

  15. # solver mode: CPU or GPU

  16. solver_mode: GPU

  17. type: "AdaGrad"

Nesterov

 
  1. base_lr: 0.01

  2. lr_policy: "step"

  3. gamma: 0.1

  4. weight_decay: 0.0005

  5. momentum: 0.95

  6. type: "Nesterov"

ADAM

 
  1. train_net: "nin_train_val.prototxt"

  2. base_lr: 0.001

  3. ###############

  4. ##### step:base_lr * gamma ^ (floor(iter / stepsize))

  5. #lr_policy: "step"

  6. #gamma: 0.1

  7. #stepsize: 25000

  8. ##### multi-step:

  9. #lr_policy: "multistep"

  10. #gamma: 0.5

  11. #stepvalue: 1000

  12. #stepvalue: 2000

  13. #stepvalue: 3000

  14. #stepvalue: 4000

  15. #stepvalue: 5000

  16. #stepvalue: 10000

  17. #stepvalue: 20000

  18. ###### inv:base_lr * (1 + gamma * iter) ^ (- power)

  19. # lr_policy: "inv"

  20. # gamma: 0.0001

  21. # power: 2

  22. ##### exp:base_lr * gamma ^ iter

  23. # lr_policy: "exp"

  24. # gamma: 0.9

  25. ##### poly:base_lr (1 - iter/max_iter) ^ (power)

  26. # lr_policy: "poly"

  27. # power: 0.9

  28. ##### sigmoid:base_lr ( 1/(1 + exp(-gamma * (iter - stepsize))))

  29. # lr_policy: "sigmoid"

  30. # gamma: 0.9

  31. #momentum: 0.9

  32. solver_type: ADAM

  33. momentum: 0.9

  34. momentum2: 0.999

  35. delta: 1e-8

  36. lr_policy: "fixed"

  37.  
  38. display: 100

  39. max_iter: 50000

  40. weight_decay: 0.0005

  41. snapshot: 5000

  42. snapshot_prefix: "./stage1/sgd_DeepBit1024_alex_stage1"

  43. solver_mode: GPU

RMSProp

 
  1. net: "examples/mnist/lenet_train_test.prototxt"

  2. test_iter: 100

  3. test_interval: 500

  4. base_lr: 1.0

  5. lr_policy: "fixed"

  6. momentum: 0.95

  7. weight_decay: 0.0005

  8. display: 100

  9. max_iter: 10000

  10. snapshot: 5000

  11. snapshot_prefix: "examples/mnist/lenet_adadelta"

  12. solver_mode: GPU

  13. type: "RMSProp"

  14.  

你可能感兴趣的:(梯度优化算法)