深度学习之优化器

深度学习之优化器

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} otimesfrac{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]

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>