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

写在前面的一些内容

本次习题来源于 NNDL 作业11：优化算法比较 。
水平有限，难免有误，如有错漏之处敬请指正。

习题1

编程实现下图，并观察特征。

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

# https://blog.youkuaiyun.com/weixin_39228381/article/details/108511882

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

观察上题结果的梯度方向。

根据上题中运行结果，y轴方向的梯度方向大，x轴方向的梯度方向小，大部分的梯度方向为y=0平面。

习题3

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

# coding: utf-8
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()

代码执行结果如下图所示：

习题4

分析上图，尝试解释下列问题：

1. 为什么SGD会走“之字形”？其它算法为什么会比较平滑？
2. Momentum、AdaGrad对SGD的改进体现在哪里？速度？方向？在图上有哪些体现？
3. 仅从轨迹来看，Adam似乎不如AdaGrad效果好，是这样么？
4. 四种方法分别用了多长时间？是否符合预期？
5. 调整学习率、动量等超参数，轨迹有哪些变化？

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

①因为图像的变化并不均匀，所以y方向变化很大时，x方向变化很小，只能迂回往复地寻找，效率很低。
②因为其他算法的梯度方向基本指向最小值的方向。

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

①为了消除梯度摆动带来的问题，可以知道梯度在过去的一段时间内的大致走向，以消除当前轮迭代梯度向量存在的方向抖动。通过指数加权平均，纵向的分量基本可以抵消，原因是锯齿状存在一上一下的配对向量，方向基本反向。因为从长期的一段时间来看，梯度优化的大方向始终指向最小值，因此，横向的更新方向基本稳定。这可以解决SGD梯度摆动的缺点，速度较SGD快，能够跳出局部极小值。
②因为随着我们更新次数的增大，我们是希望我们的学习率越来越慢。因为我们认为在学习率的最初阶段，我们是距离损失函数最优解很远的，随着更新的次数的增多，我们认为越来越接近最优解，于是学习速率也随之变慢。所以图像比较平滑，最终收敛至最优点。

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

显然，由图可以看出，Adam算法似乎错过了全局最优解。如果目标函数非凸，可能会出现引入动量后直接越过了峰值的情况。

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

（略）

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

先把学习率调为题给的1/10.

学习率调回去，将轮次扩大10倍。

学习率为题给的1/10的情况下将轮次扩大10倍。

显然，AdaGrad掉队了，Adam次之。Momentum最接近，SGD其次。

统一学习率参数lr=1，再来一次原始10倍轮次的。

由于题给AdaGrad的学习率要高于1，所以看起来最稳定。

统一学习率参数lr=100，来一次原始10倍轮次的。

不愧是AdaGrad，能找到全局最小值还没有经过太多次搜索。而SGD和Momentum直接错过了全局最小值。至于Adam，只能说像是漏斗上正在做圆周运动的钢珠，转了很多圈才找到漏斗的孔。

习题6

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

存在即合理。
我们一般在计算机视觉领域，使用SGD作为优化器。
在自然语言处理中，优化器用Adam时居多。

习题7

增加RMSprop、Nesterov算法。

optimizers['RMSprop'] = RMSprop(lr=0.2)
optimizers['Nesterov'] = Nesterov(lr=0.1)
for key in optimizers:
    ...
    
    # plot
    plt.subplot(2, 3, idx)
    ...

代码执行结果如下图所示：