[2022-12-06]神经网络与深度学习hw11 - 各种优化算法比较

contents

• hw11 - 优化算法比较
• • 写在开头
  • task1
  • task2
  • task3
  • task4
  • task5
  • task6
  • task7

hw11 - 优化算法比较

写在开头

出租屋断网了，得等到几天后师傅才来装宽带，这篇是买了个流量包给电脑开热点才发布的/(ㄒoㄒ)/~~

task1

题目内容

编程实现 f ( x , y ) = 1 20 x 2 + y 2 f(x, y) = \frac{1}{20}x^2+y^2 f(x,y)=201​x2+y2对应的图像，并进行观察。

题目思路

本题考查的是对三维图像的绘制技巧，以及对于函数最小值的可视化理解。通过定义x和y的范围，我们很容易得到函数 f ( x , y ) = 1 20 x 2 + y 2 f(x, y) = \frac{1}{20}x^2+y^2 f(x,y)=201​x2+y2对应的z轴集合，从而很方便地能够进行可视化和观察函数特征。

题目解答

生成图像的代码如下：

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
%matplotlib
f = lambda x, y : x * x / 20 + y * y
def plot_loss():
    x = np.linspace(-50, 50, 100) # 在[-50, 50]均匀取100个数
    y = np.linspace(-50, 50, 100) # 在[-50, 50]均匀取100个数
    X, Y = np.meshgrid(x, y)
    Z = f(X, Y)
    fig = plt.figure()
    ax = Axes3D(fig)
    plt.xlabel('x')
    plt.ylabel('y')
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap = 'cool')
    plt.show()
plot_loss()

输出结果如下：

从函数图像可见，这是一个往中间不断下降的三维中的“二次函数型”的函数图像，其最小值点为(0, 0, 0)。

题目总结

本题考查的是对函数的绘制以及看图说话。

task2

题目内容

观察函数 f ( x , y ) = 1 20 x 2 + y 2 f(x, y) = \frac{1}{20}x^2+y^2 f(x,y)=201​x2+y2梯度方向。

题目思路

本题为对于函数梯度的观察，通过查看梯度方向，我们可以得到很多有趣的结论。

题目解答

该函数的梯度如下图：

通过观察，我们不难发现，该函数图像的梯度特征为：y轴方向上大，x轴方向上小。特别地，虽然最小值点为(0, 0, 0)，但是梯度并非都指向这一最小值点(0, 0)。

题目总结

本题考查了梯度的特点和对于梯度图像的观察。

task3

题目内容

编写代码实现算法，并可视化轨迹。
要实现的算法有SGD, Momentum, Adagrad, Adam等。

题目思路

我们需要将这些算法的核心计算公式转换成对应代码，封装成类并且进行绘制即可。

题目解答

这些优化函数的定义代码如下：

# 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 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 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的震荡最大，而Adam的收敛路径最为优美。

task4

题目内容

分析上图，说明原理：

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

题目思路

首先需要想清楚各种优化算法的计算原理和过程。然后分析加入动量参数后发生的变化和计算方式的优化，由这些加以分析即可解答以上问题。

题目解答

答：

• 对于SGD为什么走之字形，由于SGD为在样本中随机抽出一组并按照梯度更新一次，循环往复，但是由于函数的梯度方向影响，SGD有可能会跳过全局最优解而找到一个局部最优解。其他算法对SGD的摆动问题加以不同处理方法，因此能够得到较为平滑的结果。
• • Momentum方法通过指数加权平均知道梯度的大致走向，从而消除纵向分量，使得方向基本稳定，可以解决梯度摆动的问题，比SGD更快且更容易跳出局部极小值。
  • AdaGrad采用这是因为随着我们更新次数的增大，我们是希望我们的学习率越来越慢。因为我们认为在学习率的最初阶段，我们是距离损失函数最优解很远的，随着更新的次数的增多，我们认为越来越接近最优解，于是学习速率也随之变慢。所以图像比较平滑，最终收敛至最优点。
  • Adam 是一种可以替代传统随机梯度下降过程的一阶优化算法，它能基于训练数据迭代地更新神经网络权重。主要在于经过偏置校正后，每一次迭代学习率都有个确定范围，使得参数比较平稳,从而图像比较平滑。
• Adagrad采用的是学习率递减的办法，而Adam的学习采用的是一定范围内学习率的办法，两种存在差异，但是Adagrad要优于Adam下题6是解释在同种情况下的办法。
• 运行时间SGD:0.21，Momentum:0.11，AdaGrad:0.04，Adam:0.03；符合预期。
• • 学习率调小十倍：
    • 学习率调大十倍：

题目总结

本题考查的是各种优化算法的优化过程和参数调整的结果。这边给出一张动态图片：

task5

题目内容

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

题目解答

• SGD：算法简单，且由于其不是在全部训练数据上进行损失计算的特点，参数更新速度快；下降速度慢，会有震荡导致结果为局部最优点。
• Momentum：加入动量的概念，保证梯度方向不变的情况下收敛速度变快，减少震荡；由于收敛过程没有预知性，其收敛适应性不是很好。
• AdaGrad：能够放大梯度；但是该优化算法依赖于设置好的学习率，损失收敛过快，会提前结束。
• Adam：算法计算简单高效，参数更新不受梯度伸缩变换影响，超参数有很好的解释性，调整参数少，能够自动调整学习率；虽然Adam算法目前成为主流的优化算法，不过在很多领域里通常比Momentum算法效果更差。

题目总结

本题考查各种算法的理解、由其实现机理推导其优缺点。

task6

题目内容

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

题目解答

虽然Adam效果好，但是其在很多实际项目中效果不如SGD或是改良版本SGD（如增加动量），应当具体情况具体讨论。

task7

题目内容

增加RMSprop、Nesterov算法

题目解答

代码如下：

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