NNDL 作业11：优化算法比较

最新推荐文章于 2024-06-01 23:14:10 发布

HBU_fangerfang

最新推荐文章于 2024-06-01 23:14:10 发布

阅读量128

点赞数 1

分类专栏：神经网络与深度学习文章标签：算法 python 开发语言

本文链接：https://blog.csdn.net/qq_33573422/article/details/128193841

版权

神经网络与深度学习专栏收录该内容

26 篇文章 2 订阅

订阅专栏

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

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

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

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

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

总结：

编程实现图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()

最底下是弧线，所以有全局最小值

观察梯度方向

底部弧度很小，下降方向基本沿着y轴，很多地方没有指向（0，0）

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

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

分析上图，说明原理

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

选择合适的learning rate比较困难 - 对所有的参数更新使用同样的learning rate。对于稀疏数据或者特征，有时我们可能想更新快一些对于不经常出现的特征，对于常出现的特征更新慢一些，这时候SGD就不太能满足要求了

SGD容易收敛到局部最优，并且在某些情况下可能被困在鞍点

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

SGD方法的一个缺点是，其更新方向完全依赖于当前的batch，因而其更新十分不稳定。解决这一问题的一个简单的做法便是引入momentum。

momentum即动量，它模拟的是物体运动时的惯性，即更新的时候在一定程度上保留之前更新的方向，同时利用当前batch的梯度微调最终的更新方向。这样一来，可以在一定程度上增加稳定性，从而学习地更快，并且还有一定摆脱局部最优的能力。

惯性的获得是基于历史信息的，那么，除了从过去的步伐中获得一股子向前冲的劲儿，还能获得什么呢？我们还期待获得对周围环境的感知，即使蒙上双眼，依靠前几次迈步的感觉，也应该能判断出一些信息，比如这个方向总是坑坑洼洼的，那个方向可能很平坦。

随机梯度下降法对环境的感知是指在参数空间中，根据不同参数的一些经验性判断，自适应地确定参数的学习速率，不同参数的更新步幅是不同的。例如，在文本处理中训练词嵌入模型的参数肘，有的词或词组频繁出现，有的词或词组则极少出现。数据的稀疏性导致相应参数的梯度的稀疏性，不频繁出现的词或词组的参数的梯度在大多数情况下为零，从而这些参数被更新的频率很低。在应用中，我们希望更新频率低的参数可以拥有较大的更新步幅，而更新频率高的参数的步幅可以减小。Ada Grad 方法采用 “历史梯度平方和”来衡量不同参数的梯度的稀疏性，取值越小表明越稀疏。

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

并不是，Adam 方法将惯性保持和环境感知这两个优点集于一身。一方面，Adam 记录梯度的一阶矩（ first moment ），即过往梯度与当前梯度的平均，这体现了惯性保持；另一方面， Adam 还记录梯度的二阶矩( second moment ），即过往梯度平方与当前梯度平方的平均，这类似 AdaGrad 方法，体现了环境感知能力，为不同参数产生自适应的学习速率。一阶矩和二阶矩采用类似于滑动窗口内求平均的思想进行融合，即当前梯度和近一段时间内梯度的平均值，时间久远的梯度对当前平均值的贡献呈指数衰减。

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

0.04188799858093262
0.040869951248168945
0.04188966751098633
0.040892839431762695

符合预期因为参数设置原因，所以都是路径最优的，时间差不多

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

SGD：

SGD容易收敛到局部最优，并且在某些情况下可能被困在鞍点

Momentum：

下降初期时，使用上一次参数更新，下降方向一致，乘上较大的能够进行很好的加速
下降中后期时，在局部最小值来回震荡的时候，，使得更新幅度增大，跳出陷阱
在梯度改变方向的时候，能够减少更新总而言之，momentum项能够在相关方向加速SGD，抑制振荡，从而加快收敛

Adagrad：

优点：

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

缺点：

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

Adam ：

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

总结：

这一部分上课听的还是比较认真，加上之前的基础所以做起来还是不那么难，不过还是有一些收获在里面的，这两天因为家里亲戚阳了，而我又接触过，所以也不小心阳了，有些难受，所以作业跟实验可能写的慢了一些，确实是有点写不下去，总想在床上躺着，等挺过这几天了一定要重新回来把没有做完的选做再做一做。

参考链接：(23条消息) 深度学习优化方法总结比较（SGD，Adagrad，Adadelta，Adam，Adamax，Nadam）_Tom Hardy的博客-CSDN博客

HBU_fangerfang

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
NNDL 作业11：优化算法比较

最底下是弧线，所以有全局最小值底部弧度很小，下降方向基本沿着y轴，很多地方没有指向（0，0）选择合适的learning rate比较困难 - 对所有的参数更新使用同样的learning rate。对于稀疏数据或者特征，有时我们可能想更新快一些对于不经常出现的特征，对于常出现的特征更新慢一些，这时候SGD就不太能满足要求了SGD容易收敛到局部最优，并且在某些情况下可能被困在鞍点SGD方法的一个缺点是，其更新方向完全依赖于当前的batch，因而其更新十分不稳定。解决这一问题的一个简单的做法便是引入m
复制链接

扫一扫