梯度优化算法

深度学习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.