[人工智能]深度学习之优化器

深度学习之优化器

Optimizers是在网络训练时，对网络权重进行更新，使得模型最优化loss，现阶段主流的深度学习优化器是基于梯度的优化方法，代表有：SGD，Momentum，AdaGrad，Adam，Nesterov，RMSprop等。

1. SGD – 随机梯度下降法（Stochastic Gradient Descent）

从数学知识可知，函数朝着梯度方向上升最快，梯度反方向下降最快。而在深度学习的目标中，是最小化loss。直觉上可以想到能使用梯度下降方法，来最优化loss。形式上，我们可以将SGD表示如下：
$$W\leftarrow W?\eta \frac{?loss}{?W}$$
其中，$W$是网络权重，$\eta$是学习率,代表每次更新参数$W$的步长，$loss$是衡量模型输出与标签之前的距离的标量。

对于多层的神将网络，我们往往使用字典这种数据结构来保存各层的权重参数。在实现SGD的时，我们还需要传入与权重$W$所对应的梯度$grad$,具体python实现，可参考如下代码：

from typing import Dict

class SGD:
    def __init__(self,lr=0.01):
        self.lr  = lr

    def update(self,params:Dict,grads:Dict):
        for key in params.keys():
            params[key] -= self.lr * grads[key]

note:梯度的反方向下降最快，但不一定指向最小值。

2. Momentum

Momentum原本来源物理，表示动量。在深度学习优化中的具体形式如下：
$$v\leftarrow \alpha v?\eta \frac{?loss}{?W}$$$$W\leftarrow W+v$$
其中$\alpha$表示动量因子，也可以理解为衰减因子，类似于在地面上滚动小球时，摩擦力和空气阻力所带来的的影响。$v$表示速度，表示物体在梯度作用力下的速度。其它参数与上文相同，下文中在未说明参数含义时，请参考上文相同参数的说明。其实现可参考如下代码：

import tensorflow as tf
from typing import Dict


class Momentum:
    def __init__(self,lr=0.01,alpha=0.9) -> None:
        self.lr=lr
        self.alpha= alpha
        self.v = None

    def update(self,params:Dict,grads:Dict):
        if self.v is None:
            self.v = {}
            for key,val in params.items():
                self.v[key] = tf.zeros_like(val)
            
            for key in params.keys():
                self.v[key] = self.alpha* self.v[key] - self.lr * grads[key]
                params[key] += self.v[key]

3. AdaGrad

在优化器中，学习率$\eta$是一个非常重要的参数。学习率过大过小都不便于学习。一般地，深度学习一般在开始是“多学习”，然后“逐渐少学习”。AdaGrad是一种可以为每个参数适当调整学习率的方法。其具体表达形式如下：
$$h\leftarrow h+\frac{?loss}{?W}?\frac{?loss}{?W}$$$$W\leftarrow W?\eta \frac{1}{\sqrt{h}}\frac{?loss}{?W}$$
新参数$h$保存了梯度的累计平方和（其中$?$表示逐元素乘法）。$\frac{1}{\sqrt{h}}$用于调整学习尺度，$\eta \frac{1}{\sqrt{h}}$整体代表新的学习率。这是一种自适应的学习率策略，而且AdaGrad中的Ada表示“adaptive”。AdaGrad代码实现如下：

import tensorflow as tf
from typing import Dict


class AdaGrad:
    def __init__(self, lr=0.01):
        self.lr = lr
        self.h = None
        
    def update(self, params:Dict, grads:Dict):
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = tf.zeros_like(val)
    
        for key in params.keys():
            self.h[key] += grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (tf.sqrt(self.h[key]) + 1e-7)

note: 在coding时，未避免分母为0，可以加上一个很小的数，如：1e-7，1e-10等。

4.Adam

Adam将Momentum和AdaGrad结合在一起。具体形式如下：
$$t\leftarrow t+1$$$$\eta \leftarrow \alpha ?\sqrt{1?{\beta }_2^t}/(1?{\beta }_1^t)$$$$m\leftarrow (1?{\beta }_1)\frac{?loss}{?W}+{\beta }_{1}m$$$$v\leftarrow (1?{\beta }_2)\frac{?loss}{?W}?\frac{?loss}{?W}+{\beta }_{2}v$$$$W\leftarrow W?\eta \frac{m}{\sqrt{v}+?}$$
其中$t$为时间，代表迭代了多少次。$\alpha$代表初始学习率，$\eta$表示t时刻的学习率。$m$和$v$代表累计梯度和累计平方梯度。${\beta }_1$和${\beta }_2$是对应的累计因子。其代码实现如下：

import tensorflow as tf
from typing import Dict

class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None
        self.v = None
        
    def update(self, params:Dict, grads:Dict):
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = tf.zeros_like(val)
                self.v[key] = tf.zeros_like(val)
        
        self.iter += 1
        lr_t  = self.lr * tf.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)         
        
        for key in params.keys():
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])
            
            params[key] -= lr_t * self.m[key] / (tf.sqrt(self.v[key]) + 1e-7)

论文原文：http://arxiv.org/abs/1412.6980v8

5.Nesterov

Nesterov 是对Momentum的改进和优化，其形式与Momentum极其相似。具体形式如下所示：
$$v\leftarrow \mu v?\eta \frac{?loss}{?W}$$$$W\leftarrow W?(1+\mu )\eta \frac{?loss}{?W}+{\mu }^{2}v$$
这里的$\mu$与Momentum中的$\alpha$相同。代码实现如下

import tensorflow as tf
from typing import Dict

class Nesterov:
    def __init__(self, lr=0.01, mu=0.9):
        self.lr = lr
        self.mu = mu
        self.v = None
        
    def update(self, params:Dict, grads:Dict):
        if self.v is None:
            self.v = {}
            for key, val in params.items():
                self.v[key] = tf.zeros_like(val)
            
        for key in params.keys():
            self.v[key] *= self.mu
            self.v[key] -= self.lr * grads[key]
            params[key] += self.mu * self.mu * self.v[key]
            params[key] -= (1 + self.mu) * self.lr * grads[key]

论文原文：http://arxiv.org/abs/1212.0901

6.RMSprop

RMSprop通过在AdaGrad的基础上，增加一个衰减系数$\rho$来控制历史信息的获取量。下面是形式化表达：
$$h\leftarrow \rho h+(1?\rho )\frac{?loss}{?W}?\frac{?loss}{?W}$$$$W\leftarrow W?\eta \frac{1}{\sqrt{h}}\frac{?loss}{?W}$$
代码实现如下：

import tensorflow as tf
from typing import Dict

class RMSprop:
    def __init__(self, lr=0.01, decay_rate = 0.99):
        self.lr = lr
        self.decay_rate = decay_rate
        self.h = None
        
    def update(self, params:Dict, grads:Dict):
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = tf.zeros_like(val)
            
        for key in params.keys():
            self.h[key] *= self.decay_rate
            self.h[key] += (1 - self.decay_rate) * grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (tf.sqrt(self.h[key]) + 1e-7)

联系邮箱：antarm@outlook.com