深度学习-*-梯度优化算法及代码实例

深度学习 同时被 2 个专栏收录
8 篇文章 0 订阅
14 篇文章 0 订阅

1 梯度下降简单说明

想必大家对梯度下降或多或少有所了解,这里对他的原理就不再多说(其他教程说的比我好多了),只给出下列公式(按照吴恩达的深度学习课程中的公式): W : = W − α ∗ d W W:=W-\alpha*dW W:=WαdW b : = b − α ∗ d b b:=b-\alpha*db b:=bαdb
上述公式中dW与db为权重W与偏置b的梯度方向, α \alpha α为步长/学习速率,即一个超参。我们的任务就是通过大量数据的学习,来逼近真实的W和b。

1.1 随机梯度下降

该方法简写做SGD。通常,在数据集较少的情况下,我们一般使用批梯度下降,也就是用所有的数据集来进行求解。当数据量较多时,批梯度下降就不再适合,因为速度超级慢。所以我们在每次迭代时随机选取一个样本点来进行权重W、偏置b的更新。这样能保证权重随着迭代不断地逼近真实值。但要警惕,每次只是依靠当前一个数据集,容易陷入局部极小。

1.2 Mini-Batch梯度下降

此种方法可以看做批梯度下降与SGD的折中方法:在SGD中每次迭代时,不是选取1个样本点,而是选取M个样本点来进行梯度下降。此种方法的好处在于:若数据集中有一些噪音数据,可以有效的平均噪音数据的影响,一定程度上避免陷入局部极小值。据吴恩达深度学习课程介绍,M的选取也是有经验借鉴的。若数据集数量N<=2000,则M=1即可。若N很大,那么M的取值可以取2的K次方,即M={32,64,128,256,512}。

1.3 Momentum梯度下降

在说明此种方法之前,首先需要了解什么是指数加权平均。
假设有数据 d 1 , d 2 , . . . , d 100 d_{1},d_{2},...,d_{100} d1,d2,...,d100,他们的平均数为:
a 100 = d 1 + d 2 + . . . + d 100 100   ( 1.1 ) a_{100}=\frac{d_{1}+d_{2}+...+d_{100}}{100} \ (1.1) a100=100d1+d2+...+d100 (1.1)
若我们按照公式:
v 100 = β ∗ v 99 + ( 1 − β ) ∗ d 100 v_{100}=\beta*v_{99}+(1-\beta)*d_{100} v100=βv99+(1β)d100
v 99 = β ∗ v 98 + ( 1 − β ) ∗ d 99 v_{99}=\beta*v_{98}+(1-\beta)*d_{99} v99=βv98+(1β)d99
. . . ... ...
v 1 = β ∗ v 0 + ( 1 − β ) ∗ d 1 v_{1}=\beta*v_{0}+(1-\beta)*d_{1} v1=βv0+(1β)d1
对第一式化简可得 v 100 = ( 1 − β ) ∗ d 100 + ( 1 − β ) ∗ β ∗ d 99 + ( 1 − β ) ∗ β 2 ∗ d 98 + . . . + ( 1 − β ) ∗ β 99 ∗ d 1   ( 1.2 ) v_{100}=(1-\beta)*d_{100}+(1-\beta)*\beta*d_{99}+(1-\beta)*\beta^2*d_{98}+...+(1-\beta)*\beta^{99}*d_{1} \ (1.2) v100=(1β)d100+(1β)βd99+(1β)β2d98+...+(1β)β99d1 (1.2)
通过(1.1)(1.2)之间的比较可以看到,(1.1)中每一项的权重都是一样的,也就是说每一项对平均值的贡献同样重要。而(1.2)中,每一项都不同,尤其是各数值的加权影响力随时间呈指数式递减,时间越靠近当前时刻的数据加权影响力越大。一般我们取 β \beta β为0.9(详细的介绍请看下面参考文献)
把该思想应用到梯度下降中,就发明了动量梯度下降(Momentum),在每次迭代时需要先计算一下当前的动量梯度,然后用此动量梯度来进行更新权重。注意:我们需要设定初始的动量梯度 v 0 v_{0} v0为0,此为冷启动问题,有时为了消除0的影响需要进行偏差修正:每次得到的 v v v除以 1 − β t 1-\beta^t 1βt,t为当前的迭代次数,当t较小时能赋予 d t d_{t} dt较大权重,当t大时,该修正方法趋近于1,对动量结果影响微乎其微。下面是动量梯度更新的方法
V d W = β ∗ V d W + ( 1 − β ) ∗ d W V_{dW}=\beta*V_{dW}+(1-\beta)*dW VdW=βVdW+(1β)dW
V d b = β ∗ V d b + ( 1 − β ) ∗ d b V_{db}=\beta*V_{db}+(1-\beta)*db Vdb=βVdb+(1β)db
W : = W − α ∗ V d W W:=W-\alpha*V_{dW} W:=WαVdW
b : = b − α ∗ V d b b:=b-\alpha*V_{db} b:=bαVdb
吴恩达在这里说此处不需要设置偏差修正
至于为什么Momentum比传统的梯度下降快,可以参考吴恩达的深度学习教程。我个人理解是 当前的梯度下降方向参考了此前已经走过的梯度方向,受到了他们的影响,所以会比传统的梯度下降更快地逼近正确的方向。

1.4 RMSProp

全称为root mean square prop,均方根。我个人理解,此方法的目的是在参数值波动较大的方向上减少学习速率,在参数值波动较小的方向上加快学习速率,这样能更快地逼近极值点。此方法构造了一些式子来完成这个目标。
S d W = β ∗ S d W + ( 1 − β ) ∗ ( d W ) 2 S_{dW}=\beta*S_{dW}+(1-\beta)*(dW)^2 SdW=βSdW+(1β)(dW)2
S d b = β ∗ S d b + ( 1 − β ) ∗ ( d b ) 2 S_{db}=\beta*S_{db}+(1-\beta)*(db)^2 Sdb=βSdb+(1β)(db)2
W : = W − α ∗ d W S d W + e W:=W-\alpha*\frac{dW}{\sqrt{S_{dW}}+e} W:=WαSdW +edW
b : = b − α ∗ d b S d b + e b:=b-\alpha*\frac{db}{\sqrt{S_{db}}+e} b:=bαSdb +edb
当dW小时, S d W S_{dW} SdW同样会小,此时 α S d W + e \frac{\alpha}{\sqrt{S_{dW}}+e} SdW +eα变大,变相的增大了 α \alpha α,所以就会加速。反之,会减速。 e e e通常取 10 e − 8 10e^{-8} 10e8,此为一个防止除法无意义的常量。

1.5 Adam优化算法

这个方法结合了Moment和RMSProp,Adam(Adaptive Moment Estimation)本质上是带有动量项的RMSprop,它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。Adam的优点主要在于经过偏置校正后,每一次迭代学习率都有个确定范围,使得参数比较平稳(参考文献[2])
废话不多说直接上公式
V d W = β 1 ∗ V d W + ( 1 − β 1 ) ∗ d W   V d b = β 1 ∗ V d b + ( 1 − β 1 ) ∗ d b V_{dW}=\beta_{1}*V_{dW}+(1-\beta_{1})*dW \ V_{db}=\beta_{1}*V_{db}+(1-\beta_{1})*db VdW=β1VdW+(1β1)dW Vdb=β1Vdb+(1β1)db
S d W = β 2 ∗ S d W + ( 1 − β 2 ) ∗ ( d W ) 2   S d b = β 1 ∗ S d b + ( 1 − β 1 ) ∗ ( d b ) 2 S_{dW}=\beta_{2}*S_{dW}+(1-\beta_{2})*(dW)^2 \ S_{db}=\beta_{1}*S_{db}+(1-\beta_{1})*(db)^2 SdW=β2SdW+(1β2)(dW)2 Sdb=β1Sdb+(1β1)(db)2
V d W c o r r e c t = V d W 1 − β 1 t   V d b c o r r e c t = V d b 1 − β 1 t V^{correct}_{dW}=\frac{V_{dW}}{1-\beta_{1}^t} \ V^{correct}_{db}=\frac{V_{db}}{1-\beta_{1}^t} VdWcorrect=1β1tVdW Vdbcorrect=1β1tVdb
S d W c o r r e c t = S d W 1 − β 2 t   S d b c o r r e c t = S d b 1 − β 2 t S^{correct}_{dW}=\frac{S_{dW}}{1-\beta_{2}^t} \ S^{correct}_{db}=\frac{S_{db}}{1-\beta_{2}^t} SdWcorrect=1β2tSdW Sdbcorrect=1β2tSdb
W : = W − α ∗ V d W c o r r e c t S d W c o r r e c t + e W:=W-\alpha*\frac{V^{correct}_{dW}}{\sqrt{S^{correct}_{dW}}+e} W:=WαSdWcorrect +eVdWcorrect
b : = b − α ∗ V d b c o r r e c t S d b c o r r e c t + e b:=b-\alpha*\frac{V^{correct}_{db}}{\sqrt{S^{correct}_{db}}+e} b:=bαSdbcorrect +eVdbcorrect
据吴恩达所述,一般 β 1 = 0.9 \beta_1=0.9 β1=0.9 β 2 = 0.999 \beta_2=0.999 β2=0.999 且不常修改。 e e e与RMSProp一致。

2 Python代码及结果

#!/usr/bin/python
# -*- coding:utf-8 -*-
"""
Python 3.6
Author LiHao
Time 2018/10/12 10:28
"""
import numpy as np
import random
from math import sqrt
"""
验证梯度下降程序
"""
def random_num():
    #读取随机数据 50个
    data = []
    func = lambda x:x**2+2*x+1+random.uniform(-0.3,0.3)
    for i in np.arange(-5,5,0.2):
        data.append([i,func(i)])
    return data

class Gradient(object):
    """
    利用数据求解 求解一元二次方程 x**2 + 2*x + 1的系数
    分别利用
    梯度下降法/Mini-Batch梯度下降法
    动量梯度下降法
    RMSProp
    Adam
    """
    def __init__(self,alpha = 0.001, error = 1e-03,A=0.1,B=0.1,C=0.1,data_num=100,max_iter=30000):
        """
        :param alpha: 步长
        :param error: 误差
        :param maxcount: 最大迭代次数
        """
        self._alpha = alpha
        self._error = error
        #读入数据并初始化各个系数
        self.data_num = data_num
        self._data = self.inputs()
        #这里固定了为一元二次方程 x**2+2*x+1  _A _B _C 为真实系数
        self.A = A
        self._A = 1
        self.B = B
        self._B = 2
        self.C = C
        self._C = 1
        self._max_iter = max_iter

    def inputs(self):
        datas = []
        for i in range(self.data_num):
            datas.extend(random_num())
        #print("LH -*- 得到的数据个数:",len(datas))
        return datas

    def get_y_hat(self,mini_data):
        """
        获取预测值 y^
        :param mini_data:
        :return:
        """
        y_hat = self.A * np.power(mini_data[:,0],2) + self.B * mini_data[:, 0] + self.C
        return y_hat

    def gradient(self,mini_data,y_hat,m):
        self.A = self.A - self._alpha * np.sum((y_hat-mini_data[:,1])*np.power(mini_data[:,0],2))/m
        self.B = self.B - self._alpha * np.sum((y_hat-mini_data[:,1])*mini_data[:,0])/m
        self.C = self.C - self._alpha * np.sum(y_hat-mini_data[:,1])/m

    def minibatch_gradient_train(self,m=2,error=1e-02):
        """
        minibatch-梯度下降
        :param m:
        :param error:
        :return:
        """
        self._error = error
        all_lens = len(self._data)
        if all_lens % m ==0:
            epoch = int(all_lens/m)
        else:
            epoch = int(all_lens/m) + 1
        Error = 1.0
        count = 1
        while(Error>self._error and count < self._max_iter):
            #分批次求解 随机在数据集中选取一个epoch,里面含有m个数据,不满m的取剩余的数据
            ie = random.randint(0,epoch-1)
            mini_data = np.array(self._data[ie*m:(ie+1)*m],dtype=np.float32)
            current_m = mini_data.shape[0]
            y_hat = self.get_y_hat(mini_data)
            Error = (abs(self.A - self._A) + abs(self.B - self._B) + abs(self.C - self._C)) / 3
            #print("LH -*- epoch: ",ie,"\tloss : ",Error," A,B,C:",self.A,self.B,self.C)
            self.gradient(mini_data,y_hat,current_m)
            count += 1
        print("LH -*- Minibatch -*-Final A,B,C,iter:",self.A,self.B,self.C,count," error:",Error)

    def momentum_gradient(self,mini_data,y_hat,m,pre_va,pre_vb,pre_vc,beta):
        “”“
        动量梯度求解具体过程
        ”“”
        da =  np.sum((y_hat - mini_data[:, 1]) * np.power(mini_data[:, 0], 2)) / m
        db =  np.sum((y_hat - mini_data[:, 1]) * mini_data[:, 0]) / m
        dc =  np.sum(y_hat - mini_data[:, 1]) / m
        va = da * (1 - beta) + beta * pre_va
        vb = db * (1 - beta) + beta * pre_vb
        vc = dc * (1 - beta) + beta * pre_vc
        self.A = self.A - self._alpha * va
        self.B = self.B - self._alpha * vb
        self.C = self.C - self._alpha * vc
        return va,vb,vc

    def momentum_gradient_train(self,m=2,beta=0.9,error=1e-02):
        """
        动量梯度下降
        较之梯度下降更加快速
        当前步的梯度与历史的梯度方向有关
        :param m:
        :param beta:
        :param error:
        :return:
        """
        self._error = error
        all_lens = len(self._data)
        if all_lens % m == 0:
            epoch = int(all_lens / m)
        else:
            epoch = int(all_lens / m) + 1
        Error = 1.0
        count = 1
        pre_va = 0.0
        pre_vb = 0.0
        pre_vc = 0.0
        while (Error >= self._error and count < self._max_iter):
            ie = random.randint(0,epoch-1)
            mini_data = np.array(self._data[ie * m:(ie + 1) * m], dtype=np.float32)
            current_m = mini_data.shape[0]
            y_hat = self.get_y_hat(mini_data)
            Error =(abs(self.A-self._A)+abs(self.B-self._B)+abs(self.C-self._C))/3
            #print("LH -*- epoch: ", ie, "\terror : ", Error, " A,B,C:", self.A, self.B, self.C)
            pre_va,pre_vb,pre_vc = self.momentum_gradient(mini_data, y_hat, current_m,pre_va,pre_vb,pre_vc,beta)
            count += 1
        print("LH -*- Momentum -*-Final A,B,C,iter:", self.A, self.B, self.C, count, " error:", Error)


    def rmsprop_gradient(self,mini_data,y_hat,m,pre_sa,pre_sb,pre_sc,beta,eps=10e-8):
        da = np.sum((y_hat - mini_data[:, 1]) * np.power(mini_data[:, 0], 2)) / m
        db = np.sum((y_hat - mini_data[:, 1]) * mini_data[:, 0]) / m
        dc = np.sum(y_hat - mini_data[:, 1]) / m
        sa = da**2 * (1 - beta) + beta * pre_sa
        sb = db**2 * (1 - beta) + beta * pre_sb
        sc = dc**2 * (1 - beta) + beta * pre_sc
        self.A = self.A - self._alpha * da / (sqrt(sa) + eps)
        self.B = self.B - self._alpha * db / (sqrt(sb) + eps)
        self.C = self.C - self._alpha * dc / (sqrt(sc) + eps)
        return sa, sb, sc

    def rmsprop_gradient_train(self,m=2,beta=0.9,error=1e-02):
        """
        RMSProp梯度下降
        自适应更新学习速率
        :param m:minibatch
        :param beta:超参数
        :param error:误差
        :return:
        """
        self._error = error
        all_lens = len(self._data)
        if all_lens % m == 0:
            epoch = int(all_lens / m)
        else:
            epoch = int(all_lens / m) + 1
        # 进行分批次求解
        Error = 1.0
        count = 1
        pre_sa = 0.0
        pre_sb = 0.0
        pre_sc = 0.0
        while (Error >= self._error and count < self._max_iter):
            ie = random.randint(0,epoch-1)
            mini_data = np.array(self._data[ie * m:(ie + 1) * m], dtype=np.float32)
            current_m = mini_data.shape[0]
            y_hat = self.get_y_hat(mini_data)
            Error = (abs(self.A - self._A) + abs(self.B - self._B) + abs(self.C - self._C)) / 3
            # print("LH -*- epoch: ", ie, "\terror : ", Error, " A,B,C:", self.A, self.B, self.C)
            pre_sa, pre_sb, pre_sc = self.rmsprop_gradient(mini_data, y_hat, current_m, pre_sa, pre_sb, pre_sc,
                                                                beta)
            count += 1
        print("LH -*- RMSProp -*- Final A,B,C,iter:", self.A, self.B, self.C, count, " error:", Error)


    def adam_gradient(self,mini_data,y_hat,m,pre_sa,pre_sb,pre_sc,pre_va,pre_vb,pre_vc,beta_1,beta_2,count,eps=10e-8):
        #correct值归一化分母
        norm_value_1 = 1-pow(beta_1,count)
        norm_value_2 = 1-pow(beta_2,count)
        #求da db dc
        da = np.sum((y_hat - mini_data[:, 1]) * np.power(mini_data[:, 0], 2)) / m
        db = np.sum((y_hat - mini_data[:, 1]) * mini_data[:, 0]) / m
        dc = np.sum(y_hat - mini_data[:, 1]) / m
        #求va vb vc
        va = da * (1 - beta_1) + beta_1 * pre_va
        vb = db * (1 - beta_1) + beta_1 * pre_vb
        vc = dc * (1 - beta_1) + beta_1 * pre_vc
        va_correct = va / norm_value_1
        vb_correct = vb / norm_value_1
        vc_correct = vc / norm_value_1
        #求sa sb sc
        sa = da ** 2 * (1 - beta_2) + beta_2 * pre_sa
        sb = db ** 2 * (1 - beta_2) + beta_2 * pre_sb
        sc = dc ** 2 * (1 - beta_2) + beta_2 * pre_sc
        sa_correct = sa / norm_value_2
        sb_correct = sb / norm_value_2
        sc_correct = sc / norm_value_2
        self.A = self.A - self._alpha * va_correct / (sqrt(sa_correct) + eps)
        self.B = self.B - self._alpha * vb_correct / (sqrt(sb_correct) + eps)
        self.C = self.C - self._alpha * vc_correct / (sqrt(sc_correct) + eps)
        return va,vb,vc,sa,sb,sc

    def adam_gradient_train(self,m=2,beta_1=0.9,beta_2=0.999,error=1e-02):
        """
        adam优化算法
        结合动量及RMSProp
        :param m:minibatch
        :param error:误差
        :return:
        """
        self._error = error
        all_lens = len(self._data)
        if all_lens % m == 0:
            epoch = int(all_lens / m)
        else:
            epoch = int(all_lens / m) + 1
        Error = 1.0
        count = 1
        pre_sa = 0.0
        pre_sb = 0.0
        pre_sc = 0.0
        pre_va = 0.0
        pre_vb = 0.0
        pre_vc = 0.0
        while (Error >= self._error and count < self._max_iter):
            ie = random.randint(0, epoch-1)
            mini_data = np.array(self._data[ie * m:(ie + 1) * m], dtype=np.float32)
            current_m = mini_data.shape[0]
            y_hat = self.get_y_hat(mini_data)
            Error = (abs(self.A - self._A) + abs(self.B - self._B) + abs(self.C - self._C)) / 3
            # print("LH -*- epoch: ", ie, "\terror : ", Error, " A,B,C:", self.A, self.B, self.C)
            pre_va,pre_vb,pre_vc,pre_sa, pre_sb, pre_sc = self.adam_gradient(mini_data, y_hat,current_m, pre_sa, pre_sb,pre_sc,pre_va,pre_vb,pre_vc,beta_1,beta_2,count)
            count += 1
        print("LH -*- Adam -*- Final A,B,C,iter:", self.A, self.B, self.C, count, " error:", Error)

if __name__ == '__main__':
    g = Gradient()
    #分别测试不同的方法观察结果
    #g.minibatch_gradient_train(m=64,error=0.002)
    #g.momentum_gradient_train(m=64,error=0.002,beta=0.9)
    g.rmsprop_gradient_train(m=64,error=0.002,beta=0.9)
    #g.adam_gradient_train(m=64,error=0.002)
LH -*- Minibatch -*-Final A,B,C,iter: 0.9998391374256507 2.000062286798814 0.994375273081942 15357  error: 0.0019482761020684913
LH -*- Momentum -*-Final A,B,C,iter: 1.000219900542389 2.000187069910188 0.9944682440600149 10864  error: 0.0019906410380585346
LH -*- RMSProp -*- Final A,B,C,iter: 1.000128957762776 2.000499604490694 1.0035405980946732 2109  error: 0.0017750440141715007
LH -*- Adam -*- Final A,B,C,iter: 1.000215617975376 2.0007904489544006 1.004995565781187 5911  error: 0.0019990631734925213

观察结果发现RMSProp最快,其次是Adam,然后是Momentum,最后是一般的梯度下降。
据吴恩达所说,目前最广泛使用的优化算法Adam,也是最稳定的一种。
下面从参考文献[3]中截取了两个动图,形象的说明了各个算法的速度
在这里插入图片描述
在这里插入图片描述

参考文献:

1.吴恩达.深度学习课程笔记v5.54.pdf(黄海广整理)
2.https://blog.csdn.net/u014595019/article/details/52989301
3.http://cs231n.github.io/neural-networks-3/

  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值