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

hw11 - 优化算法比较

写在开头

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

task1

题目内容

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

题目思路

本题考查的是对三维图像的绘制技巧，以及对于函数最小值的可视化理解。通过定义x和y的范围，我们很容易得到函数$f(x,y)=\frac{1}{20}{x}^2+y^2$对应的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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果如下：

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

题目总结

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

task2

题目内容

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

题目思路

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

题目解答

该函数的梯度如下图：

通过观察，我们不难发现，该函数图像的梯度特征为：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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

输出结果如下：

题目总结

本题考查的是对于不同的优化算法对于极值点的收敛过程，通过观察可以发现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)
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39