NNDL 作业11：优化算法比较

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. 观察梯度方向

这个梯度的特征是，y轴方向上大，x轴方向上小。换句话说, 就是y轴方向的坡度大，而x轴方向的坡度小。这里需要注意的是，虽然式 (6.2)的最小值在(x, y)= (0, 0)处，但是图6-2中的梯度在很多地方并没有指向(0,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会走“之字形”？其它算法为什么会比较平滑？

• SGD有缺陷，呈现之字形，是因为图像的变化并不均匀，所以y方向变化很大时，x方向变化很小，只能迂回往复地寻找，效率很低。
• 其他算法在下降开始阶段，历史速度变量和当前梯度方向相反，则会使得下降的过程更为平滑，避免过度震荡。因此主要作用在于： 有一定几率跳出局部最优解，历史速度变量和当前梯度方向相反时，使得下降的过程更为平滑。

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

• Momentum
  

Momentum借助了物理中的动量的概念，即前几次的梯度也会参与计算。为了表示动量，引入一个新的变量V，V是之前的梯度的累加，但是在每个回合都会有一定的衰减。它的特点是当前后梯度方向不一致时，能够加速学习，前后梯度方向一致时，能够抑制震荡。其中，v就体现了累加的梯度，ε表示学习率，当前后梯度一致时，v的值就越来越大，因而加速训练，当出现震荡时，v能够起到缓冲震荡的作用。也就是图中更为平滑。

• AdaGrad
  

对于梯度大的参数设置小的步长，对于梯度小的参数，设置大的步长。类比于在缓坡上面，我们可以大步长的前进，在陡坡上面，这需要小步长的前进。adagrad则是参考了这个思路。上述的式子中，对梯度的平方进行了累加，所以r值一直都是递增的，故梯度的改变量会越来越小。对于较小的梯度，r的开方若小于1的，故梯度的改变量则较大，对于较大的梯度，r的开放较大，所以梯度改变量则较小。该优化方法的问题是，r的值一直是递增的，导致梯度梯度改变量会一直减小。也就是图中函数值趋向最小值的速度更快。

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

是。对于AdaGrad，虽然在稀疏场景下表现的非常好，但由于$$\sqrt{V_t}$$
是单调递增的，就会使得实际学习率$$\alpha /\sqrt{V_t}$$ 递减至0，训练提前结束。

对于Adam避免二阶动量累积，导致训练过程提前结束。

5. 总结SGD、Momentum、AdaGrad、Adam的优缺点（选做）

• SGD

优点：收敛速度很快。

缺点：选择合适的learning rate比较困难；容易收敛到局部最优，并且在某些情况下可能被困在鞍点。

• Momentum

优点：一方面可以加快收敛速度，另一方面可以提高精度(减少震荡，使模型收敛更稳定)。

缺点：需要人工设定学习率，需要有可靠的初始化参数。

• AdaGrad

优点：前期gt较小的时候，regularizer较大，能够放大梯度；后期gt较大的时候。regularizer较小，能够约束梯度 ，适合处理稀疏梯度 。

缺点：仍依赖于人工设置一个全局学习率，设置过大的话，会使regularizer过于敏感，对梯度的调节太大。中后期，分母上梯度平方的累加将会越来越大，使，使得训练提前结束 。

• Adam

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

缺点：可能不收敛；可能错过全局最优解。

总结

课上听老师讲结合课下自己动手实操观察了一下，对这几种当下热度高的优化算法有了更深的理解。做选做题对比优缺点，也有了更深的认识。

参考

深度学习中常见的优化方法——SGD，Momentum，Adagrad，RMSprop， Adam
常用的优化算法：SGD、Momentum、AdaGrad、RMSProp、Adam