梯度下降算法(SGD, Momentum, NAG, Adagrad, RMProp, Adam)及其收斂效果比較

本文轉載自查看原文 2020-02-22 23:12 770 Adam/ SGD/ NAG/ Momentum/ 梯度下降/ Adagrad/ Deep Learning/ RMProp

1. 梯度下降

沿着目標函數梯度的反方向搜索極小值。

式中，$\theta$是模型參數，$J(\theta)$目標函數（損失函數），$\eta$是學習率。

2. 隨機梯度下降（SGD）

每次隨機選定一小批(mini-batch)數據進行梯度的計算，而不是計算全部的梯度。所有小批量數據都訓練完，我們稱為完成了一個迭代期(epoch)。

3. Momentum

想象損失函數是一個山谷，一個球從山谷滑下來，在一個平坦的地勢，球的滑動速度會慢下來，可能會陷入一些鞍點或局部最小值，如下圖(左)所示。這時候給它增加動量就可以讓高處滑落的勢能轉化為平地滾動的動能，相當於利用慣性增加了小球在平地滑動的速度，從而幫助其跳出鞍點或局部極小點。怎么計算動量呢？動量的計算基於前面的梯度，也就是參數更新不僅基於當前的梯度，也基於之前的梯度，如下圖(右)所示。

(a) 增加動量 (b) 動量的計算

模型參數更新公式：

Momentum梯度下降方法在搜索極小值時，若不發生震盪，則加動量可起到加速收斂的效果；若發生震盪，則加動量可起到減少震盪的效果。具體可參考這篇博客。

4. Nesterov accelerated gradient (NAG)

NAG方法和momentum方法相似。momentum方法計算的是當前位置的梯度，NAG方法計算的是經過更新之后的位置的梯度，其參數更新公式為

經過變換之后的等效形式中，NAG算法相對於Momentum多了一個本次梯度相對上次梯度的變化量，這個變化量本質上是對目標函數二階導的近似。由於利用了二階導的信息，NAG算法才會比Momentum具有更快的收斂速度。

5. Adagrad

上文提到的梯度下降方法中，模型所有的參數在每次更新時使用的是相同的學習率，在Adagrad算法中，每個參數的學習率各不相同。計算某參數的學習率時需將該參數前面所有時間步的梯度求和，隨着時間步的增加，學習率將減小。

式中，$\theta_{t,i}$表示第$t$時間步的第$i$個參數，$g_{t,i}$表示第$t$時間步的第$i$個參數的梯度。Adgrad方法中，學習率一直在衰減，所以可以起到抑制震盪的作用，一個簡單的例子可以參考這篇文章。

6. RMProp

Adagrad方法的學習率有時衰減得太快了，RMProp改善了這個問題。

式中，$\gamma$常設置為0.9，$\theta$常設置為0.001。

越靠前面的梯度，對學習率的影響越小，這樣可以避免學習率過快衰減。

7. Adam

Adam方法可以看作是RMProp方法加上動量(momentum)的學習方法。

8. 各方法收斂效果比較^[3]

代碼：

import torch
import torch.utils.data as Data
import torch.nn.functional as F
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

LR = 0.01
BATCH_SIZE = 32
EPOCH = 12

# fake dataset
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

# plot dataset
plt.scatter(x.numpy(), y.numpy())
plt.show()

# put dateset into torch dataset
torch_dataset = Data.TensorDataset(x, y)
loader = Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2,)


# default network
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 20)   # hidden layer
        self.predict = torch.nn.Linear(20, 1)   # output layer

    def forward(self, x):
        x = F.relu(self.hidden(x))      # activation function for hidden layer
        x = self.predict(x)             # linear output
        return x

if __name__ == '__main__':
    # different nets
    net_SGD         = Net()
    net_Momentum    = Net()
    net_RMSprop     = Net()
    net_Adam        = Net()
    nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

    # different optimizers
    opt_SGD         = torch.optim.SGD(net_SGD.parameters(), lr=LR)
    opt_Momentum    = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
    opt_RMSprop     = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
    opt_Adam        = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
    optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]

    loss_func = torch.nn.MSELoss()
    losses_his = [[], [], [], []]   # record loss

    # training
    for epoch in range(EPOCH):
        print('Epoch: ', epoch)
        for step, (b_x, b_y) in enumerate(loader):          # for each training step
            for net, opt, l_his in zip(nets, optimizers, losses_his):
                output = net(b_x)              # get output for every net
                loss = loss_func(output, b_y)  # compute loss for every net
                opt.zero_grad()                # clear gradients for next train
                loss.backward()                # backpropagation, compute gradients
                opt.step()                     # apply gradients
                l_his.append(loss.data.numpy())     # loss recoder

    labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
    for i, l_his in enumerate(losses_his):
        plt.plot(l_his, label=labels[i])
    plt.legend(loc='best')
    plt.xlabel('Steps')
    plt.ylabel('Loss')
    plt.ylim((0, 0.2))
    plt.show()

收斂效果比較：