深度学习之优化器

深度学习之优化器

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


1. SGD – 随机梯度下降法(Stochastic Gradient Descent)

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

对于多层的神将网络,我们往往使用字典这种数据结构来保存各层的权重参数。在实现SGD的时,我们还需要传入与权重 W W W所对应的梯度 g r a d grad 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 ← α v − η ∂ l o s s ∂ W v \leftarrow \alpha v - \eta \frac{\partial loss}{\partial W} vαvηWloss W ← W + v W \leftarrow W +v WW+v
其中 α \alpha α表示动量因子,也可以理解为衰减因子,类似于在地面上滚动小球时,摩擦力和空气阻力所带来的的影响。 v v 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 ← h + ∂ l o s s ∂ W ⊗ ∂ l o s s ∂ W h \leftarrow h + \frac{\partial loss}{\partial W} \otimes \frac{\partial loss}{\partial W} hh+WlossWloss W ← W − η 1 h ∂ l o s s ∂ W W \leftarrow W - \eta \frac{1}{\sqrt{h}} \frac{\partial loss}{\partial W} WWηh 1Wloss
新参数 h h h保存了梯度的累计平方和(其中 ⊗ \otimes 表示逐元素乘法)。 1 h \frac{1}{\sqrt{h}} h 1用于调整学习尺度, η 1 h \eta \frac{1}{\sqrt{h}} ηh 1整体代表新的学习率。这是一种自适应的学习率策略,而且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 ← t + 1 t \leftarrow t + 1 tt+1 η ← α ⋅ 1 − β 2 t / ( 1 − β 1 t ) \eta \leftarrow \alpha \cdot \sqrt{1- \beta_2^t} / (1 - \beta_1^t) ηα1β2t /(1β1t) m ← ( 1 − β 1 ) ∂ l o s s ∂ W + β 1 m m \leftarrow (1-\beta_1)\frac{\partial loss}{\partial W} + \beta_1 m m(1β1)Wloss+β1m v ← ( 1 − β 2 ) ∂ l o s s ∂ W ⊗ ∂ l o s s ∂ W + β 2 v v \leftarrow (1-\beta_2)\frac{\partial loss}{\partial W} \otimes \frac{\partial loss}{\partial W}+\beta_2v v(1β2)WlossWloss+β2v W ← W − η m v + ϵ W \leftarrow W - \eta \frac{m}{\sqrt{v} + \epsilon} WWηv +ϵm
其中 t t t为时间,代表迭代了多少次。 α \alpha α代表初始学习率, η \eta η表示t时刻的学习率。 m m m v v v代表累计梯度和累计平方梯度。 β 1 \beta_1 β1 β 2 \beta_2 β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 ← μ v − η ∂ l o s s ∂ W v \leftarrow \mu v-\eta \frac{\partial loss}{\partial W} vμvηWloss W ← W − ( 1 + μ ) η ∂ l o s s ∂ W + μ 2 v W \leftarrow W - (1+ \mu)\eta \frac{\partial loss}{\partial W} + \mu^2v WW(1+μ)ηWloss+μ2v
这里的 μ \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 ← ρ h + ( 1 − ρ ) ∂ l o s s ∂ W ⊗ ∂ l o s s ∂ W h \leftarrow \rho h +(1-\rho) \frac{\partial loss}{\partial W} \otimes\frac{\partial loss}{\partial W} hρh+(1ρ)WlossWloss W ← W − η 1 h ∂ l o s s ∂ W W \leftarrow W - \eta \frac{1}{\sqrt h} \frac{\partial loss}{\partial W} WWηh 1Wloss
代码实现如下:

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)

联系邮箱:[email protected]

你可能感兴趣的:(Deep,Learning,机器学习,python,深度学习,神经网络)