NNDL 作业11:优化算法比较

目录

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

2. 观察梯度方向

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

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

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

6. Adam这么好,SGD是不是就用不到了?

ref


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张图片 NNDL 作业11:优化算法比较_第4张图片

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

2. 观察梯度方向

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

  特征:y轴方向梯度大,x轴方向梯度小;很多位置的梯度并没有指向最小位置(0,0)。

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

NNDL 作业11:优化算法比较_第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()

paint_loss_func()

结果:

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

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

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

由于函数的形状非均向,图像的变化并不均匀,所以y方向变化很大时,x方向变化很小,梯度的方向并没有指向最小值的方向,只能迂回往复地寻找,效率很低。

其他算法通过调整参数减弱之字形变动幅度从而更加平滑。
2.Momentum、AdaGrad对SGD的改进体现在哪里?速度?方向?在图上有哪些体现?

Momentum引入了动量的概念,增加了新变量v,表示物体在梯度方向上受力,在这个力的作用下,物体的速度增加。使得虽然x轴方向上受到的力非常小,但是一直在同一方向上受力,所以朝同一个方向会有一定的加速。反过来,虽然y轴方向上受到的力很大,但是因为交互地受到正方向和反方向的力,它们会互相抵消,所以y轴方向上的速度不稳定。因此,和SGD时的情形相比,可以更快地朝x轴方向靠近。

 AdaGard引入了学习率衰减的方法,即一开始多学,后来逐渐少学。为参数的每个元素适当地调整学习率,增加了新变量h,NNDL 作业11:优化算法比较_第10张图片使得变动大的参数的学习率逐渐减小。由于y轴方向上的梯度较大,因此刚开始变动较大,但是后面会根据这个较大的变动按比例进行调整,减小更新的步伐。因此, y轴方向上的更新程度被减弱。
3.仅从轨迹来看,Adam似乎不如AdaGrad效果好,是这样么?

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

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

符合预期。
5.调整学习率、动量等超参数,轨迹有哪些变化?
lr=2:

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

 lr=0.01:

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

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

SGD:

优点:训练收敛速度快,可以在线更新模型,有几率跳出局部最优达到更好的局部最优或者全局最优。
缺点:更新方向完全依赖于当前的batch,不稳定,容易陷入局部最优,容易困在鞍点。

Momentum:

优点:

  1. 下降初期时,使用上一次参数更新,下降方向一致,乘上较大的47dbbf976690b1c1f6ba4a64ab1fe31e.png能够进行很好的加速 
  2. 下降中后期时,在局部最小值来回震荡的时候,03dbe28ba33bd06fc2cb22055995c779.png, 使得更新幅度增大,跳出陷阱 

  3. 在梯度改变方向的时候,996a40cd4c9e7bf6faaffd4560e12ece.png能够减少更新 总而言之,momentum项能够在相关方向加速SGD,抑制振荡,从而加快收敛

缺点:需要人工设定学习率

Adagrad:

优点:能够实现学习率的自动更改。如果这次梯度大,那么学习速率衰减的就快一些;如果这次梯度小,那么学习速率衰减的就满一些。

缺点:

仍依赖于人工设置一个全局学习率,学习率设置过大,对梯度的调节太大。中后期,梯度接近于0,使得训练提前结束。

Adam:

优点:对内存需求较小,为不同的参数计算不同的自适应学习率。参数更新的大小不随着梯度大小的缩放而变化;更新参数时的步长的边界受限于超参的步长的设定;不需要固定的目标函数;支持稀疏梯度;它能够自然的执行一种步长的退火。

缺点:可能不收敛或错过全局最优解。

6. Adam这么好,SGD是不是就用不到了?

Adam之流虽然说已经简化了调参,但是并没有一劳永逸地解决问题,默认参数虽然好,但也不是放之四海而皆准。因此,在充分理解数据的基础上,依然需要根据数据特性、算法特性进行充分的
调参实验。Adam和SGD可以互补,每个算法都有优缺点,具体问题具体分析,合作才能共赢。

ref

Adam那么棒,为什么还对SGD念念不忘 (2)—— Adam的两宗罪

 SGD、Momentum、 AdaGrad、Adam

你可能感兴趣的:(算法,python,开发语言)