NNDL 作业11:优化算法比较

文章目录

  • 1. 编程实现图6-1,并观察特征
  • 2. 观察梯度方向
  • 3. 编写代码实现算法,并可视化轨迹
  • 4. 分析上图,说明原理(选做)
    • 1.为什么SGD会走“之字形”?其它算法为什么会比较平滑?
    • 2.Momentum、AdaGrad对SGD的改进体现在哪里?速度?方向?在图上有哪些体现?
    • 3.仅从轨迹来看,Adam似乎不如AdaGrad效果好,是这样么?
    • 5、调整学习率、动量等超参数,轨迹有哪些变化?
  • 5. 总结SGD、Momentum、AdaGrad、Adam的优缺点(选做)
  • 6. Adam这么好,SGD是不是就用不到了?(选做)
  • 总结
  • 参考文章

NNDL 作业11:优化算法比较_第1张图片

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

NNDL 作业11:优化算法比较_第2张图片

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()

运行结果:
NNDL 作业11:优化算法比较_第3张图片
特征:
在这里插入图片描述

2. 观察梯度方向

NNDL 作业11:优化算法比较_第4张图片
特征:
这个梯度的特征是,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()

运行结果:
NNDL 作业11:优化算法比较_第5张图片

4. 分析上图,说明原理(选做)

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

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

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

  • Momentum
    动量优化法,相比于SGD仅仅关注当前的梯度,该方法引入了动量向量的概念,参数沿着动量向量进行更新,即更新的时候在一定程度上保留之前更新的方向,同时利用当前batch的梯度微调最终的更新方向。公式表示如下图所示,dW与db分别表示当前的权重梯度和偏移量梯度,其中β取值越大,过去的梯度影响越大,梯度下降更加顺滑,但是β太大也不行,一般取到0.9。
    NNDL 作业11:优化算法比较_第6张图片
    总的来说,该方法从梯方面进行了优化。

  • Adagrad
    该方法使梯度在各个维度上按比例地缩小,也就是降低学习率,随着迭代次数的增加,学习率会越来越小,并且在某个维度上越陡峭,学习率降低得就越快,在这个维度上越平缓,学习率降低得就越慢。所以,该方法非常适合处理稀疏数据。公式表示如下图所示,学习率η除以了过往梯度的平方和的开方。
    NNDL 作业11:优化算法比较_第7张图片
    随着训练迭代轮数的增加,学习率会越来越小,后期可能学不到任何东西,导致训练提前结束。
    总的来说,该方法是从学习率的角度进行了优化。

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

是,AdaGrad擅长学习稀疏feature和稀疏梯度。学习率衰减的Adam算法在imdb数据集(Bow feature)上,可以取得和AdaGrad一样的效果。

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

调整学习率
lr=0.6
NNDL 作业11:优化算法比较_第8张图片
lr=1
NNDL 作业11:优化算法比较_第9张图片
lr=3
NNDL 作业11:优化算法比较_第10张图片
lr=5
NNDL 作业11:优化算法比较_第11张图片
从以上实验结果可以发现,AdaGrad效果最好。

5. 总结SGD、Momentum、AdaGrad、Adam的优缺点(选做)

  • SGD
    优点:训练收敛速度快,可以在线更新模型,有几率跳出局部最优达到更好的局部最优或者全局最优 。
    缺点:不稳定,容易陷入局部最优,在某些情况下可能被困在鞍点。

  • Momentum
    优点:在相关方向加速SGD,抑制振荡,从而加快收敛;在一定程度上增加稳定性,从而学习更快,并且还有摆脱局部最优的能力。
    缺点:需要人工设定学习率,需要有可靠的初始化参数。

  • AdaGrad
    优点:前期gt 较小的时候, regularizer较大,能够放大梯度 ;后期gt 较大的时候,regularizer较小,能够约束梯度 ;适合处理稀疏梯度。
    缺点:依赖于人工设置一个全局学习率, η \etaη设置过大的话,会使regularizer过于敏感,对梯度的调节太大;中后期,分母上梯度平方的累加将会越来越大,使gradient→0,使得训练提前结束。

  • Adam
    优点:结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点;对内存需求较小;为不同的参数计算不同的自适应学习率;也适用于大多非凸优化 ,适用于大数据集和高维空间 。
    缺点:不能适应所有的场合,泛化能力差:可能不收敛,可能错过全局最优解。

6. Adam这么好,SGD是不是就用不到了?(选做)

不是,先来看SGD,SGD没有动量的概念,也就是说:在这里插入图片描述
可以看到下降梯度就是最简单的 η t = α ⋅ g t η t = α ⋅ g t ηt=αgt
SGD最大的缺点是下降速度慢,而且可能会在沟壑的两边持续震荡,停留在一个局部最优点。
SGD-M在SGD基础上增加了一阶动量,AdaGrad和AdaDelta在SGD基础上增加了二阶动量。把一阶动量和二阶动量都用起来,就是Adam了——Adaptive + Momentum。
SGD的一阶动量:
在这里插入图片描述
加上AdaDelta的二阶动量:
在这里插入图片描述
优化算法里最常见的两个超参数 就都在这里了,前者控制一阶动量,后者控制二阶动量。
但Adam并不能适应所有的场合,首先Adam可能不收敛,二阶动量是固定时间窗口内的累积,随着时间窗口的变化,遇到的数据可能发生巨变,使得 Vt 可能会时大时小,不是单调变化。这就可能在训练后期引起学习率的震荡,导致模型无法收敛;其次,使用Adam可能错过全局最优解,同样的一个优化问题,不同的优化算法可能会找到不同的答案,但自适应学习率的算法往往找到非常差的答案。

总结

课上听老师讲结合课下自己动手实操,通过对几种优化算法的比较,对SGD、Momentum、AdaGrad、Adam有了一定的了解,SGD最大的缺点是下降速度慢,而且可能会陷入局部最优,Adam结合了几种算法的优点,但泛化能力差,所以不如SGD。

参考文章

https://www.cnblogs.com/pandaLiu666/articles/15833534.html
https://blog.51cto.com/u_15279692/2944322
https://blog.csdn.net/lvhao92/article/details/79742122

你可能感兴趣的:(算法,python)