從SGD到NadaMax，十種優化算法原理及實作

點選上方“小白學視覺”，選擇加"星标"或“置頂”

重磅幹貨，第一時間送達
           

導讀

本文總結了SGD、MomentumNesterov、Momentum、AdaGrad...等十種優化算法，每一種算法的講解都附有詳細的公式過程以及代碼實作。

無論是什麼優化算法，最後都可以用一個簡單的公式抽象：

 是參數，而 

 是參數的增量，而各種優化算法的主要差別在于對 

 的計算不同，本文總結了下面十個優化算法的公式，以及簡單的Python實作：

1. SGD
2. Momentum
3. Nesterov Momentum
4. AdaGrad
5. RMSProp
6. AdaDelta
7. Adam
8. AdaMax
9. Nadam
10. NadaMax

SGD

雖然有湊數的嫌疑，不過還是把SGD也順帶說一下，就算做一個符号說明了。正常的随機梯度下降公式如下：

其中 

 是學習率， 

 是損失關于參數的梯度（有的資料中會寫成 

 等形式），不過相比SGD，用的更多的還是小批量梯度下降（mBGD）算法，不同之處在于一次訓練使用多個樣本，然後取所有參與訓練樣本梯度的平均來更新參數，公式如下：

其中 

 是第 

 次訓練中 

 個樣本損失關于參數梯度的均值，如無特别聲明，下文所出現 

 也遵循該定義

另外 

 或者 

 在下面的優化算法中，隻是作為一個傳入的變量，其具體的計算是由其他子產品負責，可以參考下面兩個連結：

Numpy實作神經網絡架構(3)——線性層反向傳播推導及實作

https://zhuanlan.zhihu.com/p/67854272

卷積核梯度計算的推導及實作

https://zhuanlan.zhihu.com/p/64248652

Momentum

Momentum，也就是動量的意思。該算法将梯度下降的過程視為一個實體系統，下圖是在百度圖檔中找的（侵删）

圖檔來自網絡

如上圖所示，在該實體系統中有一個小球（質點），它所處的水準方向的位置對應為 

 的值，而垂直方向對應為損失。設其品質 

 ，在第 

 時刻，在機關時間内，該質點受外力而造成的動量改變為：

(1.1)到(1.2)是因為 

 ，是以約去了。另外受到的外力可以分為兩個分量：重力沿斜面向下的力 

 和粘性阻尼力 

令

代入(1.2)式中：

然後對“位置”進行更新：

是以這裡 

 ，另外 

 的方向與損失的梯度方向相反，并取系數為 

 ，得到：

代入(1.4)，得到速度的更新公式：

進一步的，将(1.6)式展開，可以得到：

可以看出來是一個變相的等比數列之和，且公比小于1，是以存在極限，當 

 足夠大時， 

 趨近于 

實作代碼

import numpy as np

class Momentum(object):
    def __init__(self, alpha=0.9, lr=1e-3):
        self.alpha = alpha  # 動量系數
        self.lr = lr        # 學習率
        self.v = 0          # 初始速度為0

    def update(self, g: np.ndarray):    # g = J'(w) 為本輪訓練參數的梯度
        self.v = self.alpha * self.v - self.lr * g  # 公式
        return self.v    # 傳回的是參數的增量，下同
           

以上是基于指數衰減的實作方式，另外有的Momentum算法中會使用指數權重平均來實作，主要公式如下：

不過該方式因為 

 ，剛開始時 

 會比期望值要小，需要進行修正，下面的Adam等算法會使用該方式

Nesterov Momentum

Nesterov Momentum是Momentum的改進版本，與Momentum唯一差別就是，Nesterov先用目前的速度 

 更新一遍參數，得到一個臨時參數 

 ，然後使用這個臨時參數計算本輪訓練的梯度。相當于是小球預判了自己下一時刻的位置，并提前使用該位置的梯度更新 ：

為了更加直覺，還是上幾個圖吧，以下是Momentum算法 

 的更新過程：

假設下一個位置的梯度如下：

那麼Nesterov Momentum就提前使用這個梯度進行更新：

整體來看Nesterov的表現要好于Momentum，至于代碼實作的話因為主要變化的是 

 ，是以可以之前使用Momentum的代碼

AdaGrad

AdaGrad全稱為Adaptive Subgradient，其主要特點在于不斷累加每次訓練中梯度的平方，公式如下：

其中 

 是一個極小的正數，用來防止除0，而 

 ， 

 是矩陣的哈達瑪積運算符，另外，本文中矩陣的平方或者兩矩陣相乘都是計算哈達瑪積，而不是計算矩陣乘法

從公式中可以看出，随着算法不斷疊代， 

 會越來越大，整體的學習率會越來越小。是以，一般來說AdaGrad算法一開始是激勵收斂，到了後面就慢慢變成懲罰收斂，速度越來越慢

對于代碼實作，首先将 

 展開得到：

通常 

 ，是以在第一次訓練時(2.2)式為：

因為每次訓練 

 的值是不确定的，是以要防止處0，但是可以令 

 ，這樣就可以在(2.2)式中去掉 

将 

 代入(2.3)式，可以得到：

可知 

 恒大于0，是以不必在計算 

 中額外加入 

 ，代碼如下：

class AdaGrad(object):
    def __init__(self, eps=1e-8, lr=1e-3):
        self.r = eps    # r_0 = epsilon
        self.lr = lr

    def update(self, g: np.ndarray):
        r = r + np.square(g)
        return -self.lr * g / np.sqrt(r)
           

RMSProp

RMSProp是AdaGrad的改進算法，其公式和AdaGrad的差別隻有 

 的計算不同，先看公式

可以看出，與AdaGrad不同，RMSProp隻會累積近期的梯度資訊，對于“遙遠的曆史”會以指數衰減的形式放棄

并且AdaGrad算法雖然在凸函數(Convex Functions)上表現較好，但是當目标函數非凸時，算法梯度下降的軌迹所經曆的結構會複雜的多，早期梯度對目前訓練沒有太多意義，此時RMSProp往往表現更好

以下是将 

 展開後的公式：

與AdaGrad一樣，令 

 ，進而去掉計算 

 時的 

 ，實作代碼：

class RMSProp(object):
    def __init__(self, lr=1e-3, beta=0.999, eps=1e-8):
        self.r = eps
        self.lr = lr
        self.beta = beta

    def update(self, g: np.ndarray):
        r = r * self.beta + (1-self.beta) * np.square(g)
        return -self.lr * g / np.sqrt(r)
           

AdaDelta

AdaDelta是與RMSProp相同時間對立發展出來的一個算法，在實作上可以看作是RMSProp的一個變種，先看公式：

可以看到該算法不需要設定學習率 

 ，這是該算法的一大優勢。除了同樣以 

 來累積梯度的資訊之外，該算法還多了一個 

 以指數衰減的形式來累積 

 的資訊

與前面相同，令：

然後去掉(3.1)中的 

 ，得到：

這樣的話可以減少一些計算，代碼如下：

class AdaDelta(object):
    def __init__(self, beta=0.999, eps=1e-8):
        self.r = eps
        self.s = eps
        self.beta = beta

    def update(self, g: np.ndarray):
        g_square = (1-self.beta) * np.square(g)     # (1-beta)*g^2
        r = r * self.beta + g_square
        frac = s / r
        res = -np.sqrt(frac) * g
        s = s * self.beta + frac * g_squaretmp      # 少一次乘法。。。
        return res
           

關于以上幾個算法的對比：

其中NAG是Nesterov Momentum

更多關于AdaDelta的資訊，可以參考這篇文章：自适應學習率調整：AdaDelta（https://www.cnblogs.com/neopenx/p/4768388.html）

Adam

Adam的名稱來自Adaptive Momentum，可以看作是Momentum與RMSProp的一個結合體，該算法通過計算梯度的一階矩估計和二階矩估計而為不同的參數設計獨立的自适應性學習率，公式如下：

(4.1)和(4.2)在Momentum和RMSProp中已經介紹過了，而不直接使用 

 計算 

 卻先經過(4.3)和(4.4)式是因為通常會設 

 ，是以此時梯度的一階矩估計和二階矩估是有偏的，需要進行修正

雖然沒辦法避免修正計算，但是還是可以省去一些計算過程，初始化時令：

然後(4.5)式變為：

因為 

 ，可知當 

 足夠大時修正将不起作用（也不需要修正了）：

代碼如下：

class Adam(object):
    def __init__(self, lr=1e-3, alpha=0.9, beta=0.999, eps=1e-8):
        self.s = 0
        self.r = eps
        self.lr = lr
        self.alpha = alpha
        self.beta = beta
        self.alpha_i = 1
        self.beta_i = 1

    def update(self, g: np.ndarray):
        self.s = self.s * self.alpha + (1-self.alpha) * g
        self.r = self.r * self.beta + (1-self.beta) * np.square(g)
        self.alpha_i *= self.alpha
        self.beta_i *= self.beta_i
        lr = -self.lr * (1-self.beta_i)**0.5 / (1-self.alpha_i)
        return lr * self.s / np.sqrt(self.r)
           

AdaMax

首先回顧RSMSProp中 

 的展開式并且令 

 ，得到：

可以看到這相當于是一個 

 的 

 範數，也就是說 

 的各次元的增量是根據該次元上梯度的 

 範數的累積量進行縮放的。如果用 

 範數替代就得到了Adam的不同變種，不過其中 

 範數對應的變種算法簡單且穩定

對于 

 範數，第 

 輪訓練時梯度的累積為：

然後求無窮範數：

由此再來遞推 

 ：

需要注意，這個max比較的是梯度各個次元上的目前值和曆史最大值，具體可以結合代碼來看，最後其公式總結如下：

另外，因為 

 是累積的梯度各個分量的絕對值最大值，是以直接用做分母且不需要修正，代碼如下：

class AdaMax(object):
    def __init__(self, lr=1e-3, alpha=0.9, beta=0.999):
        self.s = 0
        self.r = 0
        self.lr = lr
        self.alpha = alpha
        self.alpha_i = 1
        self.beta = beta

    def update(self, g: np.ndarray):
        self.s = self.s * self.alpha + (1-self.alpha) * g
        self.r = np.maximum(self.r*self.beta, np.abs(g))
        self.alpha_i *= self.alpha
        lr = -self.lr / (1-self.alpha_i)
        return lr * self.s / self.r
           

Nadam

Adam可以看作是Momentum與RMSProp的結合，既然Nesterov的表現較Momentum更優，那麼自然也就可以把Nesterov Momentum與RMSProp組合到一起了，首先來看Nesterov的主要公式：

為了令其更加接近Momentum，将(5.1)和(5.2)修改為：

然後列出Adam中Momentum的部分：

将(5.5)和(5.6)式代入到(5.7)式中：

将上式中标紅部分進行近似：

代入原式，得到：

接着，按照(5.4)式的套路，将 

 替換成 

 ，得到：

整理一下公式：

同樣令 

 ，消去(5.8)式種的 

 ：

代碼

class Nadam(object):
    def __init__(self, lr=1e-3, alpha=0.9, beta=0.999, eps=1e-8):
        self.s = 0
        self.r = eps
        self.lr = lr
        self.alpha = alpha
        self.beta = beta
        self.alpha_i = 1
        self.beta_i = 1

    def update(self, g: np.ndarray):
        self.s = self.s * self.alpha + (1-self.alpha) * g
        self.r = self.r * self.beta + (1-self.beta) * np.square(g)
        self.alpha_i *= self.alpha
        self.beta_i *= self.beta_i
        lr = -self.lr * (1-self.beta_i)**0.5 / (1-self.alpha_i)
        return lr * (self.s * self.alpha + (1-self.alpha) * g) / np.sqrt(self.r)
           

NadaMax

按照同樣的思路，可以将Nesterov與AdaMax結合變成NadaMax，回顧以下(5.8)式：

然後是AdaMax的二階矩估計部分：

用(6.2)式替換掉(6.1)式中标紅部分，得到：

最後，整理公式：

代碼實作：

class NadaMax(object):
    def __init__(self, lr=1e-3, alpha=0.9, beta=0.999):
        self.s = 0
        self.r = 0
        self.lr = lr
        self.alpha = alpha
        self.alpha_i = 1
        self.beta = beta

    def update(self, g: np.ndarray):
        self.s = self.s * self.alpha + (1-self.alpha) * g
        self.r = np.maximum(self.r*self.beta, np.abs(g))
        self.alpha_i *= self.alpha
        lr = -self.lr / (1-self.alpha_i)
        return lr * (self.s * self.alpha + (1-self.alpha) * g) / self.r
           

下載下傳1：OpenCV-Contrib擴充子產品中文版教程

在「小白學視覺」公衆号背景回複：擴充子產品中文教程，即可下載下傳全網第一份OpenCV擴充子產品教程中文版，涵蓋擴充子產品安裝、SFM算法、立體視覺、目标跟蹤、生物視覺、超分辨率處理等二十多章内容。

下載下傳2：Python視覺實戰項目52講

在「小白學視覺」公衆号背景回複：Python視覺實戰項目，即可下載下傳包括圖像分割、口罩檢測、車道線檢測、車輛計數、添加眼線、車牌識别、字元識别、情緒檢測、文本内容提取、面部識别等31個視覺實戰項目，助力快速學校計算機視覺。

下載下傳3：OpenCV實戰項目20講

在「小白學視覺」公衆号背景回複：OpenCV實戰項目20講，即可下載下傳含有20個基于OpenCV實作20個實戰項目，實作OpenCV學習進階。

交流群

歡迎加入公衆号讀者群一起和同行交流，目前有SLAM、三維視覺、傳感器、自動駕駛、計算攝影、檢測、分割、識别、醫學影像、GAN、算法競賽等微信群（以後會逐漸細分），請掃描下面微信号加群，備注：”昵稱+學校/公司+研究方向“，例如：”張三 + 上海交大 + 視覺SLAM“。請按照格式備注，否則不予通過。添加成功後會根據研究方向邀請進入相關微信群。請勿在群内發送廣告，否則會請出群，謝謝了解~