深度学习笔记之优化算法(五)AdaGrad算法的简单认识

深度学习笔记之优化算法------AdaGrad算法的简单认识

• 引言
• • 回顾：动量法与Nesterov动量法
  • 优化学习率的合理性
  • AdaGrad算法的简单认识
  • AdaGrad的算法过程描述
  • (2023/10/10)补充：AdaGrad示例代码

引言

上一节对 Nesterov \text{Nesterov} Nesterov动量法 进行了简单认识，本节将介绍 AdaGrad \text{AdaGrad} AdaGrad方法。

回顾：动量法与Nesterov动量法

关于动量法 ( Momentum ) (\text{Momentum}) (Momentum)的迭代过程 使用数学符号表示如下：
{ m t = β ⋅ m t − 1 + ( 1 − β ) ⋅ ∇ θ ; t − 1 J ( θ t − 1 ) θ t = θ t − 1 − η ⋅ m t \begin{cases} m_t = \beta \cdot m_{t-1} + (1 - \beta) \cdot \nabla_{\theta;t-1} \mathcal J(\theta_{t-1}) \\ \theta_t = \theta_{t-1} - \eta \cdot m_t \end{cases} {mt=β⋅mt−1+(1−β)⋅∇θ;t−1J(θt−1)θt=θt−1−η⋅mt

• 其中 β \beta β表示动量因子，它可理解为权衡历史梯度信息 m t − 1 m_{t-1} mt−1与当前梯度信息 ∇ θ ; t − 1 J ( θ t − 1 ) \nabla_{\theta;t-1} \mathcal J(\theta_{t-1}) ∇θ;t−1J(θt−1)之间比例的量，或者说：由于历史梯度信息参与当前迭代步骤的梯度贡献， β \beta β表示历史梯度信息的贡献衰减得有多快。

• η \eta η表示学习率，它描述是沿着梯度更新方向前进的步长大小 。而动量法 的核心思想在于：合理利用历史梯度信息，结合当前迭代步骤的梯度信息 ，共同优化当前迭代步骤的梯度更新方向。

同理， Nesterov \text{Nesterov} Nesterov动量法的核心思想与动量法 基本一致，只不过将当前迭代步骤的梯度信息 替换为超前梯度信息：
{ m t = β ⋅ m t − 1 + ( 1 − β ) ⋅ ∇ θ ; t − 1 J ( θ t − 1 + γ ⋅ m t − 1 ) θ t = θ t − 1 − η ⋅ m t \begin{cases} m_t = \beta \cdot m_{t-1} + (1 - \beta) \cdot \nabla_{\theta;t-1} \mathcal J(\theta_{t-1} + \gamma \cdot m_{t-1}) \\ \theta_t = \theta_{t-1} - \eta \cdot m_t \end{cases} {mt=β⋅mt−1+(1−β)⋅∇θ;t−1J(θt−1+γ⋅mt−1)θt=θt−1−η⋅mt

可以看出：无论是动量法 还是 Nesterov \text{Nesterov} Nesterov动量法 ，它们的底层逻辑都是针对梯度的更新方向，也就是 m t m_t mt自身；我们不否认，在 m t m_t mt的优化过程 中，也伴随着梯度大小 的变化。但真正掌握梯度大小的参数，是学习率 η \eta η。而在这两种算法中， η \eta η至始至终 都是一个固定的超参数。我们是否也可以对学习率进行优化 呢 ? ? ?

优化学习率的合理性

在优化学习率之前，需要认识以下：对于学习率的优化是否是有必要的 ? ? ?在线搜索方法(步长角度)中，我们从精确搜索 、非精确搜索 两种角度对步长进行了充分的描述，并延伸出一系列的搜索准则，如 Armijo \text{Armijo} Armijo准则、 wolfe \text{wolfe} wolfe准则等等。

• 这个小例子可能不是很贴切~因为无论是精确搜索还是非精确搜索,它们都建立在方向固定是负梯度方向这个条件下。但是像动量法或者是 Nesterov \text{Nesterov} Nesterov动量法,它的梯度方向会随着迭代步骤发生变化。
• 但也可以从侧面看出，步长的选择是有优劣之分的，并不是一成不变的。

基于上面的简单描述，无论使用哪类 方法，做为调整梯度大小(步长)的学习率 η \eta η都不应该是一个确定 的值。我们不否认：梯度向量自身会随着迭代步骤的增加而减小，并向零向量逼近；但如果学习率不跟随梯度向量进行变化，可能会出现下面的情况：

• 在极值点 附近无法收敛。这种情况可能发生的条件是：在某迭代过程 中，即便梯度信息已经足够小 了，但由于学习率是定值 ，依然会导致虽然梯度方向指向正确，但梯度向量不够小 而穿过极值点：
  
• 在后续的迭代过程中，它可能都无法收敛 至极值点，从而在极值点周围震荡：
  

因而无论使用哪类 方法，关于学习率的变化趋势我们都希望：学习率随着迭代过程慢慢减小。既然已经知道了目标，我们可以想到一种硬核的 学习率优化方式：学习率随着每一次迭代减小一个固定 的数值，当学习率减小至 0 0 0时，整个学习过程结束。

很明显，这种方式自然是不够优秀的，它的缺陷主要体现在：

• 减小的固定数值是人为 设定的，实际上它也间接地人为设定了 迭代步骤的上界。如果迭代次数超过 了该上界------即便是没有到达极值点，也要强行将迭代停止；
• 相反地，如果人为设定 的固定数值过小------意味着在迭代次数内已经到达极值点，它会一直在极值点处震荡 ，直到学习率为 0 0 0。

可以看出：人为设定学习率的衰减是不可取 的，但也给我们提供新的思路：是否能够让学习率在迭代过程中自主进行调整 ? ? ?

AdaGrad算法的简单认识

AdaGrad \text{AdaGrad} AdaGrad算法的核心思想 是：使学习率在算法迭代过程中进行自适应调节，而自适应调节 同样依靠历史梯度信息。关于 AdaGrad \text{AdaGrad} AdaGrad的迭代过程使用数学符号 表示如下：
{ G t = ∇ θ ; t − 1 J ( θ t − 1 ) R t ⇐ R t − 1 + G t ⊙ G t θ t ⇐ θ t − 1 − η R t + ϵ ⊙ G t \begin{cases} \mathcal G_t = \nabla_{\theta;t-1} \mathcal J(\theta_{t-1}) \\ \mathcal R_t \Leftarrow \mathcal R_{t-1} + \mathcal G_t \odot \mathcal G_t \\ \begin{aligned} \theta_t \Leftarrow \theta_{t-1} - \frac{\eta}{\sqrt{\mathcal R_t} + \epsilon} \odot \mathcal G_t \end{aligned} \end{cases} ⎩ ⎨ ⎧Gt=∇θ;t−1J(θt−1)Rt⇐Rt−1+Gt⊙Gtθt⇐θt−1−Rt +ϵη⊙Gt

其中：

• G t \mathcal G_t Gt表示当前步骤的梯度方向；
• R t \mathcal R_t Rt与动量法 中的 m t m_t mt一样，是历史信息的一个累积载体；而这里的历史信息 并不是单纯的历史梯度信息 G t \mathcal G_t Gt，而是 G t \mathcal G_t Gt与自身的内积结果 ： G t ⊙ G t \mathcal G_t \odot \mathcal G_t Gt⊙Gt；
• ϵ \epsilon ϵ是一个较小的正数，仅为保证分母项不为 0 0 0；

很明显，由于 G t ∈ R p \mathcal G_t \in \mathbb R^p Gt∈Rp( p p p表示权重空间维数)，因而 G t ⊙ G t = ∥ G t ∥ 2 ∈ R \mathcal G_t \odot \mathcal G_t = \|\mathcal G_t \|^2 \in \mathbb R Gt⊙Gt=∥Gt∥2∈R，是一个实数 ；因而 R t = R t + G t ⊙ G t = ∑ i = 1 t ∥ G i ∥ 2 ∈ R \begin{aligned}\mathcal R_t = \mathcal R_t + \mathcal G_t \odot \mathcal G_t = \sum_{i=1}^t \|\mathcal G_i \|^2 \in \mathbb R \end{aligned} Rt=Rt+Gt⊙Gt=i=1∑t∥Gi∥2∈R也是一个实数 。观察 最后一项关于学习率的优化： η ⇒ η R t + ϵ \begin{aligned}\eta \Rightarrow \frac{\eta}{\sqrt{\mathcal R_t} + \epsilon}\end{aligned} η⇒Rt +ϵη：

• 关于分母 部分： R t + ϵ = ∑ i = 1 t ∥ G i ∥ 2 + ϵ \sqrt{\mathcal R_t} + \epsilon = \sqrt{\sum_{i=1}^t \|\mathcal G_i\|^2} + \epsilon Rt +ϵ=∑i=1t∥Gi∥2 +ϵ可以发现：这个函数是单调递增的，也就是说：关于 η \eta η的优化结果只会减小，不会增加；在梯度结果 G t \mathcal G_t Gt存在较大变化时， η \eta η会相应减小；
• 可以将 G t \mathcal G_t Gt拿到分子 上，可以得到： η ⋅ G t R t + ϵ \begin{aligned}\frac{\eta \cdot \mathcal G_t}{\sqrt{\mathcal R_t} + \epsilon}\end{aligned} Rt +ϵη⋅Gt(由于 ⊙ \odot ⊙的两项分别是实数与向量，因而这里的内积 ⊙ \odot ⊙就是乘法)，其中分子 的项 η ⋅ G t \eta \cdot \mathcal G_t η⋅Gt实际上就是真实更新梯度，而 AdaGrad \text{AdaGrad} AdaGrad的操作就是将真实更新梯度执行标准化操作。
  这种操作和批标准化( Batch Normalization \text{Batch Normalization} Batch Normalization)中也出现过类似的形式。该部分欢迎小伙伴们一起讨论~

这种学习率优化的优势在于：

• 若某迭代步骤 t t t的梯度 G t = ∇ θ ; t − 1 J ( θ t − 1 ) \mathcal G_t = \nabla_{\theta;t-1} \mathcal J(\theta_{t-1}) Gt=∇θ;t−1J(θt−1)过大，其会相应地 得到一个快速下降的学习率；
• 相反，对于梯度 G t \mathcal G_t Gt较小的部分，虽然学习率依然在减小 ，但但减小的幅度也会下降 。这种情况会使参数 在更新过程中面对平缓的倾斜方向会存在不错的收敛效果。

AdaGrad \text{AdaGrad} AdaGrad算法对于学习率 的优化也存在明显的缺陷：

• 由于初始化状态 下的参数可能是随机生成的，这种情况下有可能导致初始梯度 G \mathcal G G的结果极大/变化非常剧烈，而这种剧烈变化 会使得 R t \mathcal R_t Rt累积了较大的内积信息，从而导致本在有效收敛的过程中，由于学习率过早地 、并且过量的减少，最终使：参数没有动力 收敛到预期的极值点而产生欠拟合。

AdaGrad的算法过程描述

基于 AdaGrad \text{AdaGrad} AdaGrad的算法步骤表示如下：
初始化操作：

• 全局学习率 η \eta η，初始化参数 θ \theta θ；
• 超参数 ϵ = 1 0 − 7 \epsilon = 10^{-7} ϵ=10−7，梯度累积 信息 R = 0 \mathcal R = 0 R=0；

算法过程：

• While \text{While} While没有达到停止 准则 do \text{do} do
• 从训练集 D \mathcal D D中采集出包含 k k k个样本的小批量： { ( x ( i ) , y ( i ) ) } i = 1 k \{(x^{(i)},y^{(i)})\}_{i=1}^k {(x(i),y(i))}i=1k；
• 计算当前步骤参数 θ \theta θ的梯度信息 ：
  G ⇐ 1 k ∑ i = 1 k ∇ θ L [ f ( x ( i ) ; θ ) , y ( i ) ] \mathcal G \Leftarrow \frac{1}{k} \sum_{i=1}^k \nabla_{\theta} \mathcal L[f(x^{(i)};\theta),y^{(i)}] G⇐k1i=1∑k∇θL[f(x(i);θ),y(i)]
• 使用 R \mathcal R R对梯度内积进行累积 ：
  R ⇐ R + G ⊙ G \mathcal R \Leftarrow \mathcal R + \mathcal G \odot \mathcal G R⇐R+G⊙G
• 计算更新的梯度量：
  Δ θ = − η ϵ + R ⊙ G \Delta \theta = - \frac{\eta}{\epsilon + \sqrt{\mathcal R}} \odot \mathcal G Δθ=−ϵ+R η⊙G
• 更新梯度 θ \theta θ：
  θ ⇐ θ + Δ θ \theta \Leftarrow \theta + \Delta \theta θ⇐θ+Δθ
• End While \text{End While} End While

(2023/10/10)补充：AdaGrad示例代码

由于之前的算法如动量法、 Nesterov \text{Nesterov} Nesterov动量法，这些方法核心是在随机梯度下降算法的基础上，对梯度向量的方向进行优化；因而在之前的代码中，关于步长 的描述，可以使用最速下降法来摸鱼~ 但 AdaGrad \text{AdaGrad} AdaGrad算法 是对梯度向量的大小 (步长)，也就是对学习率进行优化，因此这次我们老老实实地使用学习率进行实现~

和之前的文章一样，这里使用标准二次型 f ( x ) = x T Q x ; x = ( x 1 , x 2 ) T ; Q = ( 0.5 0 0 20 ) f(x) = x^T \mathcal Q x;x = (x_1,x_2)^T;\mathcal Q = \begin{pmatrix}0.5 \quad 0 \\ 0 \quad 20\end{pmatrix} f(x)=xTQx;x=(x1,x2)T;Q=(0.50020)作为目标函数，起始点位置： ( 8 1 ) T (8 \quad 1)^T (81)T，对应代码表示如下：

import numpy as np
import math
import matplotlib.pyplot as plt
from tqdm import tqdm

def f(x, y):
    return 0.5 * (x ** 2) + 20 * (y ** 2)

def ConTourFunction(x, Contour):
    return math.sqrt(0.05 * (Contour - (0.5 * (x ** 2))))

def Derfx(x):
    return x

def Derfy(y):
    return 40 * y

def DrawBackGround():
    ContourList = [0.2, 1.0, 4.0, 8.0, 16.0, 32.0]
    LimitParameter = 0.0001
    plt.figure(figsize=(10, 5))
    for Contour in ContourList:
        # 设置范围时，需要满足x的定义域描述。
        x = np.linspace(-1 * math.sqrt(2 * Contour) + LimitParameter, math.sqrt(2 * Contour) - LimitParameter, 200)
        y1 = [ConTourFunction(i, Contour) for i in x]
        y2 = [-1 * j for j in y1]
        plt.plot(x, y1, '--', c="tab:blue")
        plt.plot(x, y2, '--', c="tab:blue")

def AdaGrad():
    Start = (8.0, 1.0)
    LocList = list()
    LocList.append(Start)
    Eta = 0.5
    Epsilon = 0.0000001
    R = 0.0
    Delta = 0.1

    while True:
        DerStart = (Derfx(Start[0]),Derfy(Start[1]))
        InnerProduct = (DerStart[0] ** 2) + (DerStart[1] ** 2)
        R += InnerProduct
        UpdateEta = -1 * (Eta / (Epsilon + math.sqrt(R)))
        UpdateMessage = (UpdateEta * DerStart[0],UpdateEta * DerStart[1])

        Next = (Start[0] + UpdateMessage[0],Start[1] + UpdateMessage[1])
        DerNext = (Derfx(Next[0]),Derfy(Next[1]))
		
		# 这里终止条件使用梯度向量的模接近于Delta，一个很小的正值;
        if math.sqrt((DerNext[0] ** 2) + (DerNext[1] ** 2)) < Delta:
            break
        else:
            LocList.append(Next)
            Start = Next
            
    plotList = list()
    DrawBackGround()
    for (x, y) in tqdm(LocList):
        plotList.append((x, y))
        plt.scatter(x, y, s=30, facecolor="none", edgecolors="tab:red", marker='o')
        if len(plotList) < 2:
            continue
        else:
            plt.plot([plotList[0][0], plotList[1][0]], [plotList[0][1], plotList[1][1]], c="tab:red")
            plotList.pop(0)
    plt.show()

if __name__ == '__main__':
    AdaGrad()

对应图像结果表示如下：

观察上述图像，可以发现：

• 关于初始位置的梯度 非常大，这导致学习率有一个大幅度地削减。这具体表现在：一开始更新点移动的步长非常大，但仅仅在有限次地迭代步骤内，这个步长被缩减成非常小的数值；
• 观察中后段 的迭代步骤，发现此时更新移动的步长极小，验证了《深度学习(花书)》 P187 8.5.1 AdaGrad \text{P187 8.5.1 AdaGrad} P187 8.5.1 AdaGrad中的：净效果在参数空间中更为平缓的倾斜方向会取得更大的进步。

但是如果将上述代码 中的衡量终止时刻的Delta逐步趋近于 0 0 0，观察算法的迭代次数 的变化情况：

观察上图，其中横坐标 表示参数Delta趋近于 0 0 0的程度，纵坐标 表示相应 AdaGrad \text{AdaGrad} AdaGrad算法的迭代次数，可以发现：Delta趋近于 0 0 0的过程中，即便存在一个很小的变化，但依然需要极高的迭代步骤进行收敛。因此可以判断 ： AdaGrad \text{AdaGrad} AdaGrad算法并不具备二次终止性。

Reference \text{Reference} Reference：
"随机梯度下降、牛顿法、动量法、Nesterov、AdaGrad、RMSprop、Adam"，打包理解对梯度下降的优化

《深度学习(花书)》 P187 8.5.1 AdaGrad \text{P187 8.5.1 AdaGrad} P187 8.5.1 AdaGrad