《動手學深度學習》task7_1 優化算法進階

原創 shiinerise 2020-06-25 18:25

系統學習《動手學深度學習》點擊下面這個鏈接，有全目錄哦~
https://blog.csdn.net/Shine_rise/article/details/104754764

文章目錄

11.6 Momentum

在 Section 11.4 中，我們提到，目標函數有關自變量的梯度代表了目標函數在自變量當前位置下降最快的方向。因此，梯度下降也叫作最陡下降（steepest descent）。在每次迭代中，梯度下降根據自變量當前位置，沿着當前位置的梯度更新自變量。然而，如果自變量的迭代方向僅僅取決於自變量當前位置，這可能會帶來一些問題。對於noisy gradient,我們需要謹慎的選取學習率和batch size, 來控制梯度方差和收斂的結果。
gt=∂w1∣Bt∣∑i∈Btf(xi,wt−1)=1∣Bt∣∑i∈Btgi,t−1. \mathbf{g}_t = \partial_{\mathbf{w}} \frac{1}{|\mathcal{B}_t|} \sum_{i \in \mathcal{B}_t} f(\mathbf{x}_{i}, \mathbf{w}_{t-1}) = \frac{1}{|\mathcal{B}_t|} \sum_{i \in \mathcal{B}_t} \mathbf{g}_{i, t-1}.

An ill-conditioned Problem

Condition Number of Hessian Matrix:
condH=λmaxλmin cond_{H} = \frac{\lambda_{max}}{\lambda_{min}}
where λmax,λmin\lambda_{max}, \lambda_{min} is the maximum amd minimum eignvalue of Hessian matrix.

讓我們考慮一個輸入和輸出分別爲二維向量x=[x1,x2]⊤\boldsymbol{x} = [x_1, x_2]^\top和標量的目標函數:
f(x)=0.1x12+2x22 f(\boldsymbol{x})=0.1x_1^2+2x_2^2

condH=40.2=20→ill-conditioned cond_{H} = \frac{4}{0.2} = 20 \quad \rightarrow \quad \text{ill-conditioned}

Maximum Learning Rate

  • For f(x)f(x), according to convex optimizaiton conclusions, we need step size η\eta.
  • To guarantee the convergence, we need to have η\eta .

Supp: Preconditioning

在二階優化中，我們使用Hessian matrix的逆矩陣(或者pseudo inverse)來左乘梯度向量 i.e.Δx=H−1gi.e. \Delta_{x} = H^{-1}\mathbf{g}，這樣的做法稱爲precondition，相當於將 HH 映射爲一個單位矩陣，擁有分佈均勻的Spectrum，也即我們去優化的等價標函數的Hessian matrix爲良好的identity matrix。

與Section 11.4一節中不同，這裏將x12x_1^2係數從11減小到了0.10.1。下面實現基於這個目標函數的梯度下降，並演示使用學習率爲0.40.4時自變量的迭代軌跡。

%matplotlib inline
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l
import torch

eta = 0.4

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

def gd_2d(x1, x2, s1, s2):
    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)

d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))

epoch 20, x1 -0.943467, x2 -0.000073

可以看到，同一位置上，目標函數在豎直方向（x2x_2軸方向）比在水平方向（x1x_1軸方向）的斜率的絕對值更大。因此，給定學習率，梯度下降迭代自變量時會使自變量在豎直方向比在水平方向移動幅度更大。那麼，我們需要一個較小的學習率從而避免自變量在豎直方向上越過目標函數最優解。然而，這會造成自變量在水平方向上朝最優解移動變慢。

下面我們試着將學習率調得稍大一點，此時自變量在豎直方向不斷越過最優解並逐漸發散。

Solution to ill-condition

  • Preconditioning gradient vector: applied in Adam, RMSProp, AdaGrad, Adelta, KFC, Natural gradient and other secord-order optimization algorithms.
  • Averaging history gradient: like momentum, which allows larger learning rates to accelerate convergence; applied in Adam, RMSProp, SGD momentum.
eta = 0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))

epoch 20, x1 -0.387814, x2 -1673.365109

Momentum Algorithm

動量法的提出是爲了解決梯度下降的上述問題。設時間步 tt 的自變量爲 xt\boldsymbol{x}_t，學習率爲 ηt\eta_t。
在時間步 t=0t=0，動量法創建速度變量 m0\boldsymbol{m}_0，並將其元素初始化成 0。在時間步 t>0t>0，動量法對每次迭代的步驟做如下修改：
mt←βmt−1+ηtgt,xt←xt−1−mt, \begin{aligned} \boldsymbol{m}_t &\leftarrow \beta \boldsymbol{m}_{t-1} + \eta_t \boldsymbol{g}_t, \\ \boldsymbol{x}_t &\leftarrow \boldsymbol{x}_{t-1} - \boldsymbol{m}_t, \end{aligned}
Another version:
mt←βmt−1+(1−β)gt,xt←xt−1−αtmt, \begin{aligned} \boldsymbol{m}_t &\leftarrow \beta \boldsymbol{m}_{t-1} + (1-\beta) \boldsymbol{g}_t, \\ \boldsymbol{x}_t &\leftarrow \boldsymbol{x}_{t-1} - \alpha_t \boldsymbol{m}_t, \end{aligned}

αt=ηt1−β \alpha_t = \frac{\eta_t}{1-\beta}

其中，動量超參數 β\beta滿足 0≤β<10 \leq \beta < 1。當 β=0\beta=0 時，動量法等價於小批量隨機梯度下降。

在解釋動量法的數學原理前，讓我們先從實驗中觀察梯度下降在使用動量法後的迭代軌跡。

def momentum_2d(x1, x2, v1, v2):
    v1 = beta * v1 + eta * 0.2 * x1
    v2 = beta * v2 + eta * 4 * x2
    return x1 - v1, x2 - v2, v1, v2

eta, beta = 0.4, 0.5
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))

epoch 20, x1 -0.062843, x2 0.001202

可以看到使用較小的學習率 η=0.4\eta=0.4 和動量超參數 β=0.5\beta=0.5 時，動量法在豎直方向上的移動更加平滑，且在水平方向上更快逼近最優解。下面使用較大的學習率 η=0.6\eta=0.6，此時自變量也不再發散。

eta = 0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))

epoch 20, x1 0.007188, x2 0.002553

Exponential Moving Average

爲了從數學上理解動量法，讓我們先解釋一下指數加權移動平均（exponential moving average）。給定超參數 0≤β<10 \leq \beta < 1，當前時間步 tt 的變量 yty_t 是上一時間步 t−1t-1 的變量 yt−1y_{t-1} 和當前時間步另一變量 xtx_t 的線性組合：
yt=βyt−1+(1−β)xt. y_t = \beta y_{t-1} + (1-\beta) x_t.
我們可以對 yty_t 展開：
yt=(1−β)xt+βyt−1=(1−β)xt+(1−β)⋅βxt−1+β2yt−2=(1−β)xt+(1−β)⋅βxt−1+(1−β)⋅β2xt−2+β3yt−3=(1−β)∑i=0tβixt−i \begin{aligned} y_t &= (1-\beta) x_t + \beta y_{t-1}\\ &= (1-\beta)x_t + (1-\beta) \cdot \beta x_{t-1} + \beta^2y_{t-2}\\ &= (1-\beta)x_t + (1-\beta) \cdot \beta x_{t-1} + (1-\beta) \cdot \beta^2x_{t-2} + \beta^3y_{t-3}\\ &= (1-\beta) \sum_{i=0}^{t} \beta^{i}x_{t-i} \end{aligned}

(1−β)∑i=0tβi=1−βt1−β(1−β)=(1−βt) (1-\beta)\sum_{i=0}^{t} \beta^{i} = \frac{1-\beta^{t}}{1-\beta} (1-\beta) = (1-\beta^{t})

Supp

Approximate Average of 11−β\frac{1}{1-\beta} Steps

令 n=1/(1−β)n = 1/(1-\beta)，那麼 (1−1/n)n=β1/(1−β)\left(1-1/n\right)^n = \beta^{1/(1-\beta)}。因爲
lim⁡n→∞(1−1n)n=exp⁡(−1)≈0.3679, \lim_{n \rightarrow \infty} \left(1-\frac{1}{n}\right)^n = \exp(-1) \approx 0.3679,
所以當 β→1\beta \rightarrow 1時，β1/(1−β)=exp⁡(−1)\beta^{1/(1-\beta)}=\exp(-1)，如 0.9520≈exp⁡(−1)0.95^{20} \approx \exp(-1)。如果把 exp⁡(−1)\exp(-1) 當作一個比較小的數，我們可以在近似中忽略所有含 β1/(1−β)\beta^{1/(1-\beta)} 和比 β1/(1−β)\beta^{1/(1-\beta)} 更高階的係數的項。例如，當 β=0.95\beta=0.95 時，
yt≈0.05∑i=0190.95ixt−i. y_t \approx 0.05 \sum_{i=0}^{19} 0.95^i x_{t-i}.
因此，在實際中，我們常常將 yty_t 看作是對最近 1/(1−β)1/(1-\beta) 個時間步的 xtx_t 值的加權平均。例如，當 γ=0.95\gamma = 0.95 時，yty_t 可以被看作對最近20個時間步的 xtx_t 值的加權平均；當 β=0.9\beta = 0.9 時，yty_t 可以看作是對最近10個時間步的 xtx_t 值的加權平均。而且，離當前時間步 tt 越近的 xtx_t 值獲得的權重越大（越接近1）。

由指數加權移動平均理解動量法

現在，我們對動量法的速度變量做變形：
mt←βmt−1+(1−β)(ηt1−βgt). \boldsymbol{m}_t \leftarrow \beta \boldsymbol{m}_{t-1} + (1 - \beta) \left(\frac{\eta_t}{1 - \beta} \boldsymbol{g}_t\right).
Another version:
mt←βmt−1+(1−β)gt. \boldsymbol{m}_t \leftarrow \beta \boldsymbol{m}_{t-1} + (1 - \beta) \boldsymbol{g}_t.

xt←xt−1−αtmt, \begin{aligned} \boldsymbol{x}_t &\leftarrow \boldsymbol{x}_{t-1} - \alpha_t \boldsymbol{m}_t, \end{aligned}

αt=ηt1−β \alpha_t = \frac{\eta_t}{1-\beta}

由指數加權移動平均的形式可得，速度變量 vt\boldsymbol{v}_t 實際上對序列 {ηt−igt−i/(1−β):i=0,…,1/(1−β)−1}\{\eta_{t-i}\boldsymbol{g}_{t-i} /(1-\beta):i=0,\ldots,1/(1-\beta)-1\} 做了指數加權移動平均。換句話說，相比於小批量隨機梯度下降，動量法在每個時間步的自變量更新量近似於將前者對應的最近 1/(1−β)1/(1-\beta) 個時間步的更新量做了指數加權移動平均後再除以 1−β1-\beta。所以，在動量法中，自變量在各個方向上的移動幅度不僅取決當前梯度，還取決於過去的各個梯度在各個方向上是否一致。在本節之前示例的優化問題中，所有梯度在水平方向上爲正（向右），而在豎直方向上時正（向上）時負（向下）。這樣，我們就可以使用較大的學習率，從而使自變量向最優解更快移動。

Implement

相對於小批量隨機梯度下降，動量法需要對每一個自變量維護一個同它一樣形狀的速度變量，且超參數裏多了動量超參數。實現中，我們將速度變量用更廣義的狀態變量states表示。

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)

features, labels = get_data_ch7()

def init_momentum_states():
    v_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
    v_b = torch.zeros(1, dtype=torch.float32)
    return (v_w, v_b)

def sgd_momentum(params, states, hyperparams):
    for p, v in zip(params, states):
        v.data = hyperparams['momentum'] * v.data + hyperparams['lr'] * p.grad.data
        p.data -= v.data

我們先將動量超參數momentum設0.5

d2l.train_ch7(sgd_momentum, init_momentum_states(),
              {'lr': 0.02, 'momentum': 0.5}, features, labels)

loss: 0.243297, 0.057950 sec per epoch

將動量超參數momentum增大到0.9

d2l.train_ch7(sgd_momentum, init_momentum_states(),
              {'lr': 0.02, 'momentum': 0.9}, features, labels)

loss: 0.260418, 0.059441 sec per epoch

可見目標函數值在後期迭代過程中的變化不夠平滑。直覺上，10倍小批量梯度比2倍小批量梯度大了5倍，我們可以試着將學習率減小到原來的1/5。此時目標函數值在下降了一段時間後變化更加平滑。

d2l.train_ch7(sgd_momentum, init_momentum_states(),
              {'lr': 0.004, 'momentum': 0.9}, features, labels)

loss: 0.243650, 0.063532 sec per epoch

Pytorch Class

在Pytorch中，torch.optim.SGD已實現了Momentum。

d2l.train_pytorch_ch7(torch.optim.SGD, {'lr': 0.004, 'momentum': 0.9},
                    features, labels)

loss: 0.243692, 0.048604 sec per epoch

11.7 AdaGrad

在之前介紹過的優化算法中，目標函數自變量的每一個元素在相同時間步都使用同一個學習率來自我迭代。舉個例子，假設目標函數爲ff，自變量爲一個二維向量[x1,x2]⊤[x_1, x_2]^\top，該向量中每一個元素在迭代時都使用相同的學習率。例如，在學習率爲η\eta的梯度下降中，元素x1x_1和x2x_2都使用相同的學習率η\eta來自我迭代：
x1←x1−η∂f∂x1,x2←x2−η∂f∂x2. x_1 \leftarrow x_1 - \eta \frac{\partial{f}}{\partial{x_1}}, \quad x_2 \leftarrow x_2 - \eta \frac{\partial{f}}{\partial{x_2}}.
在“動量法”一節裏我們看到當x1x_1和x2x_2的梯度值有較大差別時，需要選擇足夠小的學習率使得自變量在梯度值較大的維度上不發散。但這樣會導致自變量在梯度值較小的維度上迭代過慢。動量法依賴指數加權移動平均使得自變量的更新方向更加一致，從而降低發散的可能。本節我們介紹AdaGrad算法，它根據自變量在每個維度的梯度值的大小來調整各個維度上的學習率，從而避免統一的學習率難以適應所有維度的問題 [1]。

Algorithm

AdaGrad算法會使用一個小批量隨機梯度gt\boldsymbol{g}_t按元素平方的累加變量st\boldsymbol{s}_t。在時間步0，AdaGrad將s0\boldsymbol{s}_0中每個元素初始化爲0。在時間步tt，首先將小批量隨機梯度gt\boldsymbol{g}_t按元素平方後累加到變量st\boldsymbol{s}_t：
st←st−1+gt⊙gt, \boldsymbol{s}_t \leftarrow \boldsymbol{s}_{t-1} + \boldsymbol{g}_t \odot \boldsymbol{g}_t,
其中⊙\odot是按元素相乘。接着，我們將目標函數自變量中每個元素的學習率通過按元素運算重新調整一下：
xt←xt−1−ηst+ϵ⊙gt, \boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \frac{\eta}{\sqrt{\boldsymbol{s}_t + \epsilon}} \odot \boldsymbol{g}_t,
其中η\eta是學習率，ϵ\epsilon是爲了維持數值穩定性而添加的常數，如10−610^{-6}。這裏開方、除法和乘法的運算都是按元素運算的。這些按元素運算使得目標函數自變量中每個元素都分別擁有自己的學習率。

Feature

需要強調的是，小批量隨機梯度按元素平方的累加變量st\boldsymbol{s}_t出現在學習率的分母項中。因此，如果目標函數有關自變量中某個元素的偏導數一直都較大，那麼該元素的學習率將下降較快；反之，如果目標函數有關自變量中某個元素的偏導數一直都較小，那麼該元素的學習率將下降較慢。然而，由於st\boldsymbol{s}_t一直在累加按元素平方的梯度，自變量中每個元素的學習率在迭代過程中一直在降低（或不變）。所以，當學習率在迭代早期降得較快且當前解依然不佳時，AdaGrad算法在迭代後期由於學習率過小，可能較難找到一個有用的解。

下面我們仍然以目標函數f(x)=0.1x12+2x22f(\boldsymbol{x})=0.1x_1^2+2x_2^2爲例觀察AdaGrad算法對自變量的迭代軌跡。我們實現AdaGrad算法並使用和上一節實驗中相同的學習率0.4。可以看到，自變量的迭代軌跡較平滑。但由於st\boldsymbol{s}_t的累加效果使學習率不斷衰減，自變量在迭代後期的移動幅度較小。

%matplotlib inline
import math
import torch
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l

def adagrad_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6  # 前兩項爲自變量梯度
    s1 += g1 ** 2
    s2 += g2 ** 2
    x1 -= eta / math.sqrt(s1 + eps) * g1
    x2 -= eta / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

eta = 0.4
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))


epoch 20, x1 -2.382563, x2 -0.158591

下面將學習率增大到2。可以看到自變量更爲迅速地逼近了最優解。

eta = 2
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))


epoch 20, x1 -0.002295, x2 -0.000000

Implement

同動量法一樣，AdaGrad算法需要對每個自變量維護同它一樣形狀的狀態變量。我們根據AdaGrad算法中的公式實現該算法。

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)
        
features, labels = get_data_ch7()

def init_adagrad_states():
    s_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
    s_b = torch.zeros(1, dtype=torch.float32)
    return (s_w, s_b)

def adagrad(params, states, hyperparams):
    eps = 1e-6
    for p, s in zip(params, states):
        s.data += (p.grad.data**2)
        p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)

使用更大的學習率來訓練模型。

d2l.train_ch7(adagrad, init_adagrad_states(), {'lr': 0.1}, features, labels)


loss: 0.242258, 0.061548 sec per epoch

Pytorch Class

通過名稱爲“adagrad”的Trainer實例，我們便可使用Pytorch提供的AdaGrad算法來訓練模型。

d2l.train_pytorch_ch7(torch.optim.Adagrad, {'lr': 0.1}, features, labels)


loss: 0.243800, 0.060953 sec per epoch

11.8 RMSProp

我們在“AdaGrad算法”一節中提到，因爲調整學習率時分母上的變量st\boldsymbol{s}_t一直在累加按元素平方的小批量隨機梯度，所以目標函數自變量每個元素的學習率在迭代過程中一直在降低（或不變）。因此，當學習率在迭代早期降得較快且當前解依然不佳時，AdaGrad算法在迭代後期由於學習率過小，可能較難找到一個有用的解。爲了解決這一問題，RMSProp算法對AdaGrad算法做了修改。該算法源自Coursera上的一門課程，即“機器學習的神經網絡”。

Algorithm

我們在“動量法”一節裏介紹過指數加權移動平均。不同於AdaGrad算法裏狀態變量st\boldsymbol{s}_t是截至時間步tt所有小批量隨機梯度gt\boldsymbol{g}_t按元素平方和，RMSProp算法將這些梯度按元素平方做指數加權移動平均。具體來說，給定超參數0≤γ00 \leq \gamma 0計算
vt←βvt−1+(1−β)gt⊙gt. \boldsymbol{v}_t \leftarrow \beta \boldsymbol{v}_{t-1} + (1 - \beta) \boldsymbol{g}_t \odot \boldsymbol{g}_t.
和AdaGrad算法一樣，RMSProp算法將目標函數自變量中每個元素的學習率通過按元素運算重新調整，然後更新自變量
xt←xt−1−αvt+ϵ⊙gt, \boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \frac{\alpha}{\sqrt{\boldsymbol{v}_t + \epsilon}} \odot \boldsymbol{g}_t,
其中η\eta是學習率，ϵ\epsilon是爲了維持數值穩定性而添加的常數，如10−610^{-6}。因爲RMSProp算法的狀態變量st\boldsymbol{s}_t是對平方項gt⊙gt\boldsymbol{g}_t \odot \boldsymbol{g}_t的指數加權移動平均，所以可以看作是最近1/(1−β)1/(1-\beta)個時間步的小批量隨機梯度平方項的加權平均。如此一來，自變量每個元素的學習率在迭代過程中就不再一直降低（或不變）。

照例，讓我們先觀察RMSProp算法對目標函數f(x)=0.1x12+2x22f(\boldsymbol{x})=0.1x_1^2+2x_2^2中自變量的迭代軌跡。回憶在“AdaGrad算法”一節使用的學習率爲0.4的AdaGrad算法，自變量在迭代後期的移動幅度較小。但在同樣的學習率下，RMSProp算法可以更快逼近最優解。

%matplotlib inline
import math
import torch
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l

def rmsprop_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
    s1 = beta * s1 + (1 - beta) * g1 ** 2
    s2 = beta * s2 + (1 - beta) * g2 ** 2
    x1 -= alpha / math.sqrt(s1 + eps) * g1
    x2 -= alpha / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

alpha, beta = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))


epoch 20, x1 -0.010599, x2 0.000000

Implement

接下來按照RMSProp算法中的公式實現該算法。

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)
        
features, labels = get_data_ch7()

def init_rmsprop_states():
    s_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
    s_b = torch.zeros(1, dtype=torch.float32)
    return (s_w, s_b)

def rmsprop(params, states, hyperparams):
    gamma, eps = hyperparams['beta'], 1e-6
    for p, s in zip(params, states):
        s.data = gamma * s.data + (1 - gamma) * (p.grad.data)**2
        p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)

我們將初始學習率設爲0.01，並將超參數γ\gamma設爲0.9。此時，變量st\boldsymbol{s}_t可看作是最近1/(1−0.9)=101/(1-0.9) = 10個時間步的平方項gt⊙gt\boldsymbol{g}_t \odot \boldsymbol{g}_t的加權平均。

d2l.train_ch7(rmsprop, init_rmsprop_states(), {'lr': 0.01, 'beta': 0.9},
              features, labels)


loss: 0.243334, 0.063004 sec per epoch

Pytorch Class

通過名稱爲“rmsprop”的Trainer實例，我們便可使用Gluon提供的RMSProp算法來訓練模型。注意，超參數γ\gamma通過gamma1指定。

d2l.train_pytorch_ch7(torch.optim.RMSprop, {'lr': 0.01, 'alpha': 0.9},
                    features, labels)


loss: 0.244934, 0.062977 sec per epoch

11.9 AdaDelta

除了RMSProp算法以外，另一個常用優化算法AdaDelta算法也針對AdaGrad算法在迭代後期可能較難找到有用解的問題做了改進 [1]。有意思的是，AdaDelta算法沒有學習率這一超參數。

Algorithm

AdaDelta算法也像RMSProp算法一樣，使用了小批量隨機梯度gt\boldsymbol{g}_t按元素平方的指數加權移動平均變量st\boldsymbol{s}_t。在時間步0，它的所有元素被初始化爲0。給定超參數0≤ρ00 \leq \rho 0，同RMSProp算法一樣計算
st←ρst−1+(1−ρ)gt⊙gt. \boldsymbol{s}_t \leftarrow \rho \boldsymbol{s}_{t-1} + (1 - \rho) \boldsymbol{g}_t \odot \boldsymbol{g}_t.
與RMSProp算法不同的是，AdaDelta算法還維護一個額外的狀態變量Δxt\Delta\boldsymbol{x}_t，其元素同樣在時間步0時被初始化爲0。我們使用Δxt−1\Delta\boldsymbol{x}_{t-1}來計算自變量的變化量：
gt′←Δxt−1+ϵst+ϵ⊙gt, \boldsymbol{g}_t' \leftarrow \sqrt{\frac{\Delta\boldsymbol{x}_{t-1} + \epsilon}{\boldsymbol{s}_t + \epsilon}} \odot \boldsymbol{g}_t,
其中ϵ\epsilon是爲了維持數值穩定性而添加的常數，如10−510^{-5}。接着更新自變量：
xt←xt−1−gt′. \boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \boldsymbol{g}'_t.
最後，我們使用Δxt\Delta\boldsymbol{x}_t來記錄自變量變化量gt′\boldsymbol{g}'_t按元素平方的指數加權移動平均：
Δxt←ρΔxt−1+(1−ρ)gt′⊙gt′. \Delta\boldsymbol{x}_t \leftarrow \rho \Delta\boldsymbol{x}_{t-1} + (1 - \rho) \boldsymbol{g}'_t \odot \boldsymbol{g}'_t.
可以看到，如不考慮ϵ\epsilon的影響，AdaDelta算法與RMSProp算法的不同之處在於使用Δxt−1\sqrt{\Delta\boldsymbol{x}_{t-1}}來替代超參數η\eta。

Implement

AdaDelta算法需要對每個自變量維護兩個狀態變量，即st\boldsymbol{s}_t和Δxt\Delta\boldsymbol{x}_t。我們按AdaDelta算法中的公式實現該算法。

def init_adadelta_states():
    s_w, s_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    delta_w, delta_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    return ((s_w, delta_w), (s_b, delta_b))

def adadelta(params, states, hyperparams):
    rho, eps = hyperparams['rho'], 1e-5
    for p, (s, delta) in zip(params, states):
        s[:] = rho * s + (1 - rho) * (p.grad.data**2)
        g =  p.grad.data * torch.sqrt((delta + eps) / (s + eps))
        p.data -= g
        delta[:] = rho * delta + (1 - rho) * g * g


d2l.train_ch7(adadelta, init_adadelta_states(), {'rho': 0.9}, features, labels)


loss: 0.243485, 0.084914 sec per epoch

Pytorch Class

通過名稱爲“adadelta”的Trainer實例，我們便可使用pytorch提供的AdaDelta算法。它的超參數可以通過rho來指定。

d2l.train_pytorch_ch7(torch.optim.Adadelta, {'rho': 0.9}, features, labels)


loss: 0.267756, 0.061329 sec per epoch

11.10 Adam

Adam算法在RMSProp算法基礎上對小批量隨機梯度也做了指數加權移動平均 [1]。下面我們來介紹這個算法。

Algorithm

Adam算法使用了動量變量mt\boldsymbol{m}_t和RMSProp算法中小批量隨機梯度按元素平方的指數加權移動平均變量vt\boldsymbol{v}_t，並在時間步0將它們中每個元素初始化爲0。給定超參數0≤β1<10 \leq \beta_1 < 1（算法作者建議設爲0.9），時間步tt的動量變量mt\boldsymbol{m}_t即小批量隨機梯度gt\boldsymbol{g}_t的指數加權移動平均：
mt←β1mt−1+(1−β1)gt. \boldsymbol{m}_t \leftarrow \beta_1 \boldsymbol{m}_{t-1} + (1 - \beta_1) \boldsymbol{g}_t.
和RMSProp算法中一樣，給定超參數0≤β2<10 \leq \beta_2 < 1（算法作者建議設爲0.999），
將小批量隨機梯度按元素平方後的項gt⊙gt\boldsymbol{g}_t \odot \boldsymbol{g}_t做指數加權移動平均得到vt\boldsymbol{v}_t：
vt←β2vt−1+(1−β2)gt⊙gt. \boldsymbol{v}_t \leftarrow \beta_2 \boldsymbol{v}_{t-1} + (1 - \beta_2) \boldsymbol{g}_t \odot \boldsymbol{g}_t.
由於我們將m0\boldsymbol{m}_0和s0\boldsymbol{s}_0中的元素都初始化爲0，
在時間步tt我們得到mt=(1−β1)∑i=1tβ1t−igi\boldsymbol{m}_t = (1-\beta_1) \sum_{i=1}^t \beta_1^{t-i} \boldsymbol{g}_i。將過去各時間步小批量隨機梯度的權值相加，得到 (1−β1)∑i=1tβ1t−i=1−β1t(1-\beta_1) \sum_{i=1}^t \beta_1^{t-i} = 1 - \beta_1^t。需要注意的是，當tt較小時，過去各時間步小批量隨機梯度權值之和會較小。例如，當β1=0.9\beta_1 = 0.9時，m1=0.1g1\boldsymbol{m}_1 = 0.1\boldsymbol{g}_1。爲了消除這樣的影響，對於任意時間步tt，我們可以將mt\boldsymbol{m}_t再除以1−β1t1 - \beta_1^t，從而使過去各時間步小批量隨機梯度權值之和爲1。這也叫作偏差修正。在Adam算法中，我們對變量mt\boldsymbol{m}_t和vt\boldsymbol{v}_t均作偏差修正：
m^t←mt1−β1t, \hat{\boldsymbol{m}}_t \leftarrow \frac{\boldsymbol{m}_t}{1 - \beta_1^t},

v^t←vt1−β2t. \hat{\boldsymbol{v}}_t \leftarrow \frac{\boldsymbol{v}_t}{1 - \beta_2^t}.

接下來，Adam算法使用以上偏差修正後的變量m^t\hat{\boldsymbol{m}}_t和m^t\hat{\boldsymbol{m}}_t，將模型參數中每個元素的學習率通過按元素運算重新調整：
gt′←ηm^tv^t+ϵ, \boldsymbol{g}_t' \leftarrow \frac{\eta \hat{\boldsymbol{m}}_t}{\sqrt{\hat{\boldsymbol{v}}_t} + \epsilon},
其中η\eta是學習率，ϵ\epsilon是爲了維持數值穩定性而添加的常數，如10−810^{-8}。和AdaGrad算法、RMSProp算法以及AdaDelta算法一樣，目標函數自變量中每個元素都分別擁有自己的學習率。最後，使用gt′\boldsymbol{g}_t'迭代自變量：
xt←xt−1−gt′. \boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \boldsymbol{g}_t'.

Implement

我們按照Adam算法中的公式實現該算法。其中時間步tt通過hyperparams參數傳入adam函數。

%matplotlib inline
import torch
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)
        
features, labels = get_data_ch7()

def init_adam_states():
    v_w, v_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    s_w, s_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    return ((v_w, s_w), (v_b, s_b))

def adam(params, states, hyperparams):
    beta1, beta2, eps = 0.9, 0.999, 1e-6
    for p, (v, s) in zip(params, states):
        v[:] = beta1 * v + (1 - beta1) * p.grad.data
        s[:] = beta2 * s + (1 - beta2) * p.grad.data**2
        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])
        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])
        p.data -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)
    hyperparams['t'] += 1


d2l.train_ch7(adam, init_adam_states(), {'lr': 0.01, 't': 1}, features, labels)


loss: 0.242722, 0.089254 sec per epoch

Pytorch Class

d2l.train_pytorch_ch7(torch.optim.Adam, {'lr': 0.01}, features, labels)


loss: 0.242389, 0.073228 sec per epoch
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

5月21日相聚上海張江！與文心大模型一起共建大模型產業應用生態圈

5月21日，文心中國行將走進上海，在張江科學會堂舉行。屆時，政府、企業與高校的相關專家和業界同仁將現場分享生成式人工智能與大模型最新進展，主要圍繞大模型技術如何賦能產業級應用創新展開探討，還有百度風投從投資視角帶來的觀點，讓參會者全方位瞭解

原創 2024-05-17 00:28:21

網絡爬蟲安全：90後小夥，用軟件非法搬運他人原創視頻被判刑

央視《今日說法》欄目近日報道了一名程序員開發非法視頻搬運軟件獲利超700多萬，最終獲刑的案例。 國內某知名短視頻平臺報警稱，有人在網絡上售賣一款視頻搬運軟件，使用軟件的人可以繞過平臺的審覈機制，一鍵“搬運”竊取他人作品非法轉載投稿。警方調查

原創 2024-05-16 00:19:26

探索大語言模型：理解Self Attention| 京東物流技術團隊

一、背景知識 在ChatGPT引發全球關注之後，學習和運用大型語言模型迅速成爲了熱門趨勢。作爲程序員，我們不僅要理解其表象，更要探究其背後的原理。究竟是什麼使得ChatGPT能夠實現如此卓越的問答性能？自注意力機制的巧妙融入無疑是關鍵因素

原創 2024-05-14 23:57:26

GPU 硬件指標說明

流處理器：也叫渲染管、着色器。畫面都是由一個又一個像素點組成的，而流處理器就負責這些像素點的渲染工作； RT核心：光追核心，用作於光線追蹤效果； CUDA 核心和Tensor 核心：CUDA Core和Tensor Core，爲G

原創 2024-05-13 22:35:43

舌尖上的AI：人工智能技術正在被“端上”餐桌

來源 | 人民數字FINTECH 責編 | 晉兆雨 頭圖 | CSDN 下載自視覺中國 #人工智能技術正在被“端上”餐桌 四方食事，不過一碗人間煙火。人工智能作爲一門新的技術科學，正在被人間煙火氣“端”上餐桌。 人工智能“洗手”

osc_bv96h8zs 2024-05-13 21:17:25

攻擊者正在利用AI，對保險公司發起大規模欺詐

保險欺詐一直是保險行業面臨的重要挑戰之一，尤其隨着技術的進步，欺詐者也在不斷更新其手段，利用AI技術，包括生成式模型、機器學習和數據分析工具等欺騙保險公司，而AI技術的應用正成爲他們的新工具，使其犯罪行爲更加隱蔽和複雜，挑戰保險行業的防欺詐

原創 2024-05-10 00:55:17

AIGC在京東廣告創意的技術應用

一、前言       電商廣告圖片不僅能夠抓住消費者的眼球，還可以傳遞品牌核心價值和故事，建立起與消費者之間的情感聯繫。然而現有的廣告圖片大多依賴人工製作，存在效率和成本的限制。儘管最近AIGC技術取得了卓越的進展，但其在廣告圖片的應

京東雲開發者 2024-05-08 23:24:18

AI繪圖新選擇：Fooocus工具發佈，小顯存助力大模型運行

隨着人工智能技術的飛速發展，AI繪圖工具已經成爲了衆多創作者們的得力助手。它們能夠基於深度學習算法，快速生成高質量的圖像，爲設計、藝術等領域注入了新的活力。然而，傳統的AI繪圖工具往往對硬件要求較高，使得許多擁有較低配置設備的用戶望而卻步。

原創 2024-05-07 23:30:10

GLM國產大模型訓練加速：高效性能與成本優化的實踐

隨着人工智能技術的不斷進步，大模型的訓練成爲了推動深度學習領域發展的重要力量。然而，傳統的訓練方式往往面臨着性能瓶頸和高昂的成本問題，這使得許多研究者和開發者望而卻步。爲了解決這一難題，我們探索了使用OneFlow框架對GLM國產大模型進行

原創 2024-05-07 23:30:09

LoRA微調語言大模型的實用技巧

一、引言 隨着深度學習技術的快速發展，語言大模型在自然語言處理領域取得了顯著的進展。然而，傳統的微調方法通常需要大量的計算資源和時間，對於實際應用來說並不友好。爲了解決這個問題，LoRA微調技術應運而生。LoRA（Low-Rank Adap

原創 2024-04-28 11:30:13

京東廣告研發——效率爲王：廣告統一檢索平臺實踐

1、系統概述 實踐證明，將互聯網流量變現的在線廣告是互聯網最成功的商業模式，而電商場景是在線廣告的核心場景。京東服務中國數億的用戶和大量的商家，商品池海量。平臺在兼顧用戶體驗、平臺、廣告主收益的前提推送商品具有挑戰性。京東廣告檢索平臺

原創 2024-04-25 23:17:47

Stable Diffusion中的embedding

Stable Diffusion中的embedding 嵌入，也稱爲文本反轉，是在 Stable Diffusion 中控制圖像樣式的另一種方法。在這篇文章中，我們將學習什麼是嵌入，在哪裏可以找到它們，以及如何使用它們。 什麼是嵌入embe

原創 2024-04-25 21:31:13

大模型區域落地再加速！百度“文心中國行”西部首站落地成都錦江

​4 月 24 日，“文心中國行”西部地區首站落地成都錦江。成都市錦江區白鷺灣新經濟總部功能區、錦江區投資促進局與百度飛槳攜手合作，打造成都人工智能的新產業、新模式、新業態。來自成都政產學研各界的領導、專家、企業嘉賓，共同探討如何降低 AI

原創 2024-04-25 11:41:53

文心中國行走進成都！4 月 24 日一起把握大模型時代的產業新機遇

​4 月 24 日，文心中國行將走進成都。屆時，政府、企業與高校的相關專家和業界同仁將現場分享生成式人工智能與大模型最新進展，從人工智能政策解讀、大模型技術，到產業創新應用的實踐案例，讓參會者全方位瞭解大模型時期的發展與創新機遇。大會還特別

原創 2024-04-23 11:41:07

文心大模型“你說我畫”：PaddleHub與PaddleSpeech的協同實踐

在人工智能領域中，自然語言處理和計算機視覺是兩個非常活躍的研究方向。隨着深度學習技術的發展，這兩個領域之間的交叉融合產生了許多令人興奮的應用場景。其中，“你說我畫”就是這樣一個結合自然語言處理和計算機視覺技術的創新應用。 “你說我畫”的核心

原創 2024-04-22 11:29:20