神经网络与深度学习 作业11：优化算法比较

目录

1. 编程实现图6-1，并观察特征

2. 观察梯度方向 

3. 编写代码实现算法，并可视化轨迹 

4. 分析上图，说明原理

（1）为什么SGD会走“之字形”？其它算法为什么会比较平滑？

（2）Momentum、AdaGrad对SGD的改进体现在哪里？速度？方向？在图上有哪些体现？

（3）仅从轨迹来看，Adam似乎不如AdaGrad效果好，是这样么？

（4）四种方法分别用了多长时间？是否符合预期？

（5）调整学习率、动量等超参数，轨迹有哪些变化？

5. 总结SGD、Momentum、AdaGrad、Adam的优缺点 

SGD

Momentum 

AdaGrad 

Adam 

6. Adam这么好，SGD是不是就用不到了？ 

参考资料 

---

1. 编程实现图6-1，并观察特征

import numpy as np
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D


def func(x, y):
    return x * x / 20 + y * y


def paint_loss_func():
    x = np.linspace(-50, 50, 100)  # x的绘制范围是-50到50，从改区间均匀取100个数
    y = np.linspace(-50, 50, 100)  # y的绘制范围是-50到50，从改区间均匀取100个数

    X, Y = np.meshgrid(x, y)
    Z = func(X, Y)

    fig = plt.figure()  # figsize=(10, 10))
    ax = Axes3D(fig)
    plt.xlabel('x')
    plt.ylabel('y')

    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='rainbow')
    plt.show()


paint_loss_func()

运行结果：

2. 观察梯度方向 

 

上式表示的函数梯度如下图所示： 

由图像能够看出该函数梯度的特征为：

1. 在y轴方向的坡度大，在x轴方向的坡度小。
2. 虽然最小值在(x,y)=(0,0)处，但梯度在很多地方并没有指向(0,0)。

3. 编写代码实现算法，并可视化轨迹 

最优化方法的比较SGD、Momentum、Adagrad、Adam

import numpy as np
import matplotlib.pyplot as plt
from collections import OrderedDict


class SGD:
    """随机梯度下降法（Stochastic Gradient Descent）"""

    def __init__(self, lr=0.01):
        self.lr = lr

    def update(self, params, grads):
        for key in params.keys():
            params[key] -= self.lr * grads[key]


class Momentum:
    """Momentum SGD"""

    def __init__(self, lr=0.01, momentum=0.9):
        self.lr = lr
        self.momentum = momentum
        self.v = None

    def update(self, params, grads):
        if self.v is None:
            self.v = {}
            for key, val in params.items():
                self.v[key] = np.zeros_like(val)

        for key in params.keys():
            self.v[key] = self.momentum * self.v[key] - self.lr * grads[key]
            params[key] += self.v[key]


class Nesterov:
    """Nesterov's Accelerated Gradient (http://arxiv.org/abs/1212.0901)"""

    def __init__(self, lr=0.01, momentum=0.9):
        self.lr = lr
        self.momentum = momentum
        self.v = None

    def update(self, params, grads):
        if self.v is None:
            self.v = {}
            for key, val in params.items():
                self.v[key] = np.zeros_like(val)

        for key in params.keys():
            self.v[key] *= self.momentum
            self.v[key] -= self.lr * grads[key]
            params[key] += self.momentum * self.momentum * self.v[key]
            params[key] -= (1 + self.momentum) * self.lr * grads[key]


class AdaGrad:
    """AdaGrad"""

    def __init__(self, lr=0.01):
        self.lr = lr
        self.h = None

    def update(self, params, grads):
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)

        for key in params.keys():
            self.h[key] += grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)


class RMSprop:
    """RMSprop"""

    def __init__(self, lr=0.01, decay_rate=0.99):
        self.lr = lr
        self.decay_rate = decay_rate
        self.h = None

    def update(self, params, grads):
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)

        for key in params.keys():
            self.h[key] *= self.decay_rate
            self.h[key] += (1 - self.decay_rate) * grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)


class Adam:
    """Adam (http://arxiv.org/abs/1412.6980v8)"""

    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None
        self.v = None

    def update(self, params, grads):
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)

        self.iter += 1
        lr_t = self.lr * np.sqrt(1.0 - self.beta2 ** self.iter) / (1.0 - self.beta1 ** self.iter)

        for key in params.keys():
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
            self.v[key] += (1 - self.beta2) * (grads[key] ** 2 - self.v[key])

            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)


def f(x, y):
    return x ** 2 / 20.0 + y ** 2


def df(x, y):
    return x / 10.0, 2.0 * y


init_pos = (-7.0, 2.0)
params = {}
params['x'], params['y'] = init_pos[0], init_pos[1]
grads = {}
grads['x'], grads['y'] = 0, 0

optimizers = OrderedDict()
optimizers["SGD"] = SGD(lr=0.95)
optimizers["Momentum"] = Momentum(lr=0.1)
optimizers["AdaGrad"] = AdaGrad(lr=1.5)
optimizers["Adam"] = Adam(lr=0.3)

idx = 1

for key in optimizers:
    optimizer = optimizers[key]
    x_history = []
    y_history = []
    params['x'], params['y'] = init_pos[0], init_pos[1]

    for i in range(30):
        x_history.append(params['x'])
        y_history.append(params['y'])

        grads['x'], grads['y'] = df(params['x'], params['y'])
        optimizer.update(params, grads)

    x = np.arange(-10, 10, 0.01)
    y = np.arange(-5, 5, 0.01)

    X, Y = np.meshgrid(x, y)
    Z = f(X, Y)
    # for simple contour line
    mask = Z > 7
    Z[mask] = 0

    # plot
    plt.subplot(2, 2, idx)
    idx += 1
    plt.plot(x_history, y_history, 'o-', color="red")
    plt.contour(X, Y, Z)  # 绘制等高线
    plt.ylim(-10, 10)
    plt.xlim(-10, 10)
    plt.plot(0, 0, '+')
    plt.title(key)
    plt.xlabel("x")
    plt.ylabel("y")

plt.subplots_adjust(wspace=0, hspace=0)  # 调整子图间距
plt.show()

 运行结果：

由图可以看出这四个最优化方法中AdaGrad的收敛效果最好。 

4. 分析上图，说明原理

（1）为什么SGD会走“之字形”？其它算法为什么会比较平滑？

SGD算法是从样本中随机抽出一组，训练后按梯度更新一次，然后再抽取一组，再更新一次，在样本量及其大的情况下，可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型，而且SGD没有动量的概念。
其他算法比较平滑是因为对SGD梯度摆动的问题进行解决，例如Momentum就是引入了动量这一概念来减弱Z字型走位。从而得到的图像比较平滑。

（2）Momentum、AdaGrad对SGD的改进体现在哪里？速度？方向？在图上有哪些体现？

Momentum

 SGD下降方法的缺点是参数更新方向只依赖于当前batch计算出的梯度，因此十分的不稳定。为了抑制SGD的震荡，动量认为梯度下降的过程中可以加入惯性。动量梯度下降法运行速度总是快于标准的梯度下降法，其基本思想是在SGD的基础上引入了一阶动量：

一阶动量指的是各个时刻梯度的指数加权平均，约等于个历史时刻的梯度向量和的平均值，也就是t时刻的下降方向，不仅由当前点的梯度方向决定，还由此前的累积的梯度来决定，β的经验值一般为0.9，也就是意味着下降方向主要是此前累积的下降方向，并略微偏向当前时刻的下降方向。并利用当前batch微调最终的更新方向。如果当前梯度方向与历史梯度一致，会增强该方向的梯度。如果不一致，能够减少更新。

AdaGrad

AdaGrad其实是对学习率进行了约束，AdaGrad独立地适应所有模型参数的学习率，缩放每个参数反比于其它所有梯度历史平方值总和的平方根。损失较大偏导的参数相应地拥有一个快速下降的学习率，而较小偏导的参数在学习率上有相对较小的下降。净效果是在参数空间中更为平缓的倾斜方向会取得更大的进步。

（3）仅从轨迹来看，Adam似乎不如AdaGrad效果好，是这样么？

从轨迹来看，Adam的效果确实不如AdaGrad 。

（4）四种方法分别用了多长时间？是否符合预期？

SGD:0.29798
Momentum:0.11013
AdaGrad:0.20334
Adam:0.23995

符合预期

（5）调整学习率、动量等超参数，轨迹有哪些变化？

当学习率过大时

当学习率过小时

 

5. 总结SGD、Momentum、AdaGrad、Adam的优缺点 

SGD

优点

• 算法收敛速度快(在Batch Gradient Descent算法中, 每轮会计算很多相似样本的梯度, 这部分是冗余的)
• 可以在线更新
• 有几率跳出一个比较差的局部最优而收敛到一个更好的局部最优甚至是全局最优

缺点

• 容易收敛到局部最优，并且容易被困在鞍点

Momentum 

优点

• 与梯度下降相比，下降速度快，因为如果方向是一直下降的，那么速度将是之前梯度的和，所以比仅用当前梯度下降快。
• 对于窄长的等梯度图，会减轻梯度下降的震荡程度，因为考虑了当前时刻是考虑了之前的梯度方向，加快收敛。
• 增加了稳定性。
• 还有一定摆脱局部最优的能力。

缺点

• 其更新方向完全依赖于当前batch计算出的梯度，因而十分不稳定。

AdaGrad 

优点

• 不同更新频率的参数具有不同的学习率，减少摆动，在稀疏数据场景下表现会非常好；
• 允许使用一个更大的学习率α \alphaα，从而加快算法的学习速度；

缺点

• 仍需要手动设置一个全局学习率 , 如果学习率设置过大的话，会使regularizer过于敏感，对梯度的调节太大。
• 训练到中后期，分母中对历史梯度一直累加，学习率将逐渐下降至0，使得训练提前结束。
• 初始化W影响初始化梯度，如果初始梯度很大的话，会导致整个训练过程的学习率很小，导致学习时间变长。

Adam 

优点

• 结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点
• 对内存需求较小
• 为不同的参数计算不同的自适应学习率
• 也适用于大多非凸优化
• 适用于大数据集和高维空间

缺点

• 可能不收敛。
• 可能错过全局最优解。

6. Adam这么好，SGD是不是就用不到了？ 

并不是，从几篇怒怼Adam的文章来看，多数都构造了一些比较极端的例子来演示了Adam失效的可能性。这些例子一般过于极端，实际情况中可能未必会这样，但这提醒了我们，理解数据对于设计算法的必要性。优化算法的演变历史，都是基于对数据的某种假设而进行的优化，那么某种算法是否有效，就要看你的数据是否符合该算法的胃口了。

参考资料 

各种梯度优化算法介绍（SGD Loss剧烈波动）_rookie_chenzhi的博客-CSDN博客

SGD、Momentum、RMSprop、Adam区别与联系 - 知乎 (zhihu.com)