nndl 作业12 优化算法2D可视化
简要介绍图中的优化算法，编程实现并2D可视化
优化算法：优化的目标是网络模型中的参数
（集合），损失函数L变量就是θ，其中L中的参数是整个训练集，换句话说，目标函数（损失函数）是通过整个训练集来确定的，训练集全集不同，则损失函数的图像也不同。
1. 被优化函数 
SGD算法
SGD又称为随机梯度下降算法 ，用于求解损失函数最小值，对于SGD而言，每次使用的损失函数只是通过这一个小批量的数据确定的，其函数图像与真实全集损失函数有所不同，所以其求解的梯度也含有一定的随机性，在鞍点或者局部最小值点的时候，震荡跳动，如果是mini-batch或者SGD，每次找到的梯度都是不同的，就会发生震荡，来回跳动。
SGD 一次只进行一次更新，就没有冗余，而且比较快，并且可以新增样本。
缺点：更新比较频繁，会造成 cost function 有严重的震荡。
Adagrad
可以对低频的参数做较大的更新，对高频的做较小的更新，也因此，对于稀疏的数据它的表现很好，很好地提高了 SGD 的鲁棒性
梯度更新
优点是减少了学习率的手动调节，超参数设定值：一般η选取0.01
缺点：
它的缺点是分母会不断积累，这样学习率就会收缩并最终会变得非常小。
RMSprop
RMSprop 为了解决 Adagrad 学习率急剧下降问题的，
梯度更新规则:
使用的是指数加权平均，旨在消除梯度下降中的摆动，与Momentum的效果一样，某一维度的导数比较大，则指数加权平均就大，某一维度的导数比较小，则其指数加权平均就小，这样就保证了各维度导数都在一个量级，进而减少了摆动。允许使用一个更大的学习率η）
Momentum
加速 SGD， 并且抑制震荡
当我们将一个小球从山上滚下来时，没有阻力的话，它的动量会越来越大，但是如果遇到了阻力，速度就会变小。 加入的这一项，可以使得梯度方向不变的维度上速度变快，梯度方向有所改变的维度上的更新速度变慢，这样就可以加快收敛并减小震荡。
超参数设定值: 一般 γ 取值 0.9 左右。
缺点：
这种情况相当于小球从山上滚下来时是在盲目地沿着坡滚，如果它能具备一些先知，例如快要上坡时，就知道需要减速了的话，适应性会更好。
Adam
计算每个参数的自适应学习率的方法。相当于 RMSprop + Momentum
除了像 Adadelta 和 RMSprop 一样存储了过去梯度的平方 vt 的指数衰减平均值 ，也像 momentum 一样保持了过去梯度 mt 的指数衰减平均值
每个优化器实现代码
import torch
from abc import abstractmethod
class Op(object):
def __init__(self):
pass
def __call__(self, inputs):
return self.forward(inputs)
# 输入：张量inputs
# 输出：张量outputs
def forward(self, inputs):
# return outputs
raise NotImplementedError
# 输入：最终输出对outputs的梯度outputs_grads
# 输出：最终输出对inputs的梯度inputs_grads
def backward(self, outputs_grads):
# return inputs_grads
raise NotImplementedError
# 优化器基类
class Optimizer(object):
def __init__(self, init_lr, model):
"""
优化器类初始化
"""
# 初始化学习率，用于参数更新的计算
self.init_lr = init_lr
# 指定优化器需要优化的模型
self.model = model
@abstractmethod
def step(self):
"""
定义每次迭代如何更新参数
"""
pass
class SimpleBatchGD(Optimizer): # SGD,实际是批量梯度下降
# 初始化方法，接受初始学习率 init_lr 和模型 model 作为参数
def __init__(self, init_lr, model):
super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)
def step(self):
# 参数更新
# 首先检查模型的参数是否为字典类型
if isinstance(self.model.params, dict):
for key in self.model.params.keys():
# 对每一个参数执行更新操作：原参数 - 学习率 * 对应参数的梯度
# 这里假设 self.model.grads[key] 存储了对应参数的梯度信息
self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]
class Adagrad(Optimizer):
# 初始化方法，接受初始学习率init_lr、模型model和一个小量epsilon作为参数
def __init__(self, init_lr, model, epsilon):
super(Adagrad, self).__init__(init_lr=init_lr, model=model)
# 初始化一个字典G，用于存储每个参数的历史梯度平方
self.G = {}
for key in self.model.params.keys():
self.G[key] = 0
# 存储epsilon，用于防止除数为0的情况
self.epsilon = epsilon
# adagrad方法，用于计算参数更新和梯度平方的更新
def adagrad(self, x, gradient_x, G, init_lr):
# 更新梯度平方的历史记录，将新的梯度平方加到原来的值上
G += gradient_x ** 2
# 根据Adagrad算法计算参数的更新量
x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
return x, G
def step(self):
for key in self.model.params.keys():
# 调用adagrad方法进行参数更新和梯度平方的更新，并将结果存储回model.params和G字典中
self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
self.model.grads[key],
self.G[key],
self.init_lr)
class RMSprop(Optimizer):
def __init__(self, init_lr, model, beta, epsilon):
super(RMSprop, self).__init__(init_lr=init_lr, model=model)
# 初始化一个字典G，用于存储每个参数的历史梯度平方的加权移动平均
self.G = {}
for key in self.model.params.keys():
self.G[key] = 0
# 存储衰减率beta和epsilon，其中epsilon用于防止除数为0的情况
self.beta = beta
self.epsilon = epsilon
# rmsprop方法，用于计算参数更新和梯度平方加权移动平均的更新
def rmsprop(self, x, gradient_x, G, init_lr):
"""
rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
"""
G = self.beta * G + (1 - self.beta) * gradient_x ** 2
x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
return x, G
def step(self):
"""参数更新"""
for key in self.model.params.keys():
self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key],
self.model.grads[key],
self.G[key],
self.init_lr)
class Momentum(Optimizer):
# 初始化方法，接受初始学习率init_lr、模型model和动量系数rho作为参数
def __init__(self, init_lr, model, rho):
super(Momentum, self).__init__(init_lr=init_lr, model=model)
self.delta_x = {}
for key in self.model.params.keys():
self.delta_x[key] = 0
self.rho = rho
def momentum(self, x, gradient_x, delta_x, init_lr):
"""
momentum算法更新参数，delta_x为梯度的加权移动平均
"""
delta_x = self.rho * delta_x - init_lr * gradient_x
x += delta_x
return x, delta_x
def step(self):
"""参数更新"""
for key in self.model.params.keys():
self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key],
self.model.grads[key],
self.delta_x[key],
self.init_lr)
class Adam(Optimizer):
def __init__(self, init_lr, model, beta1, beta2, epsilon):
super(Adam, self).__init__(init_lr=init_lr, model=model)
self.beta1 = beta1
self.beta2 = beta2
self.epsilon = epsilon
self.M, self.G = {}, {}
for key in self.model.params.keys():
self.M[key] = 0 # 将每个参数的历史梯度的一阶矩初始化为0
self.G[key] = 0 # 将每个参数的历史梯度的二阶矩初始化为0
self.t = 1 # 初始化时间步t为1
def adam(self, x, gradient_x, G, M, t, init_lr):
M = self.beta1 * M + (1 - self.beta1) * gradient_x # 更新一阶矩，即历史梯度的加权平均
G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2 # 更新二阶矩，即历史梯度的平方的加权平均
M_hat = M / (1 - self.beta1 ** t) # 对一阶矩进行正规化，使其除以(1 - beta1的t次方)
G_hat = G / (1 - self.beta2 ** t) # 对二阶矩进行正规化，使其除以(1 - beta2的t次方)
t += 1
x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
return x, G, M, t # 返回更新后的参数、二阶矩、一阶矩和时间步
def step(self):
"""参数更新"""
for key in self.model.params.keys():
self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
self.model.grads[key],
self.G[key],
self.M[key],
self.t,
self.init_lr)调用优化器可视化
# coding=gbk
from Op import *
import torch
import numpy as np
from matplotlib import pyplot as plt
class OptimizedFunction(Op):
def __init__(self, w):
super(OptimizedFunction, self).__init__()
self.w = w
self.params = {'x': 0}
self.grads = {'x': 0}
def forward(self, x):
self.params['x'] = x
return torch.matmul(self.w.T, torch.tensor(torch.square(self.params['x']), dtype=torch.float32))
def backward(self):
self.grads['x'] = 2 * torch.multiply(self.w.T, self.params['x'])
import copy
def train_f(model, optimizer, x_init, epoch):
"""
训练函数
输入：
- model：被优化函数
- optimizer：优化器
- x_init：x初始值
- epoch：训练回合数
"""
x = x_init
all_x = []
losses = []
for i in range(epoch):
all_x.append(copy.copy(x.numpy()))
loss = model(x)
losses.append(loss)
model.backward()
optimizer.step()
x = model.params['x']
#print(all_x)
return torch.tensor(all_x), losses
class Visualization(object):
def __init__(self):
"""
初始化可视化类
"""
# 只画出参数x1和x2在区间[-5, 5]的曲线部分
x1 = np.arange(-5, 5, 0.1)
x2 = np.arange(-5, 5, 0.1)
x1, x2 = np.meshgrid(x1, x2)
self.init_x = torch.tensor([x1, x2])
def plot_2d(self, model, x, fig_name):
"""
可视化参数更新轨迹
"""
fig, ax = plt.subplots(figsize=(10, 6))
cp = ax.contourf(self.init_x[0], self.init_x[1], model(self.init_x.transpose(0, 1)),
colors=['#e4007f', '#f19ec2', '#e86096', '#eb7aaa', '#f6c8dc', '#f5f5f5', '#000000'])
'''
这行代码使用contourf方法绘制了一个填充的等高线图。
self.init_x[0]和self.init_x[1]是x1和x2的网格点。
model(self.init_x.transpose([1, 0, 2]))表示将self.init_x转置后传递给模型函数，得到每个网格点的值。
colors=['#e4007f', ...]定义了等高线填充的颜色。
'''
c = ax.contour(self.init_x[0], self.init_x[1], model(self.init_x.transpose(0, 1)), colors='black')
#绘制了等高线的轮廓线，其颜色为黑色
cbar = fig.colorbar(cp)#创建了一个颜色条，与填充的等高线图相关联
ax.plot(x[:, 0], x[:, 1], '-o', color='#000000')#不断更新的x,y绘制点，连成线
ax.plot(0, 'r*', markersize=18, color='#fefefe')#标记0，0点
ax.set_xlabel('$x1$')#标签名称
ax.set_ylabel('$x2$')
ax.set_xlim((-2, 5))#标签范围
ax.set_ylim((-2, 5))
plt.savefig(fig_name)
plt.show()
import numpy as np
def train_and_plot_f(model, optimizer, epoch, fig_name):
"""
训练模型并可视化参数更新轨迹
"""
# 设置x的初始值
x_init = torch.tensor([3, 4], dtype=torch.float32)#初始值在这确定的
# print('x1 initiate: {}, x2 initiate: {}'.format(x_init[0].numpy(), x_init[1].numpy()))
x, losses = train_f(model, optimizer, x_init, epoch)
# print(x)
losses = np.array(losses)
# 展示x1、x2的更新轨迹
vis = Visualization()
vis.plot_2d(model, x, fig_name)
# 固定随机种子
torch.seed()
w = torch.as_tensor([0.2, 2])
model = OptimizedFunction(w)
opt = SimpleBatchGD(init_lr=0.2, model=model)
train_and_plot_f(model, opt, epoch=20, fig_name='opti-vis-para.pdf')
# 固定随机种子
torch.seed()
w = torch.as_tensor([0.2, 2])
model2 = OptimizedFunction(w)
opt2 = Adagrad(init_lr=0.5, model=model2, epsilon=1e-7)
train_and_plot_f(model2, opt2, epoch=50, fig_name='opti-vis-para2.pdf')
torch.seed()
w = torch.as_tensor([0.2, 2])
model3 = OptimizedFunction(w)
opt3 = RMSprop(init_lr=0.1, model=model3, beta=0.9, epsilon=1e-7)
train_and_plot_f(model3, opt3, epoch=50, fig_name='opti-vis-para3.pdf')
# 固定随机种子
torch.seed()
w = torch.as_tensor([0.2, 2])
model4 = OptimizedFunction(w)
opt4 = Momentum(init_lr=0.01, model=model4, rho=0.9)
train_and_plot_f(model4, opt4, epoch=50, fig_name='opti-vis-para4.pdf')
# 固定随机种子
torch.seed()
w = torch.as_tensor([0.2, 2])
model5 = OptimizedFunction(w)
opt5 = Adam(init_lr=0.2, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
train_and_plot_f(model5, opt5, epoch=20, fig_name='opti-vis-para5.pdf')
2.被优化函数 :
# 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.m[key]也可使用(1 - self.beta1)
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
learningrate = [0.9, 0.3, 0.3, 0.6, 0.6, 0.6, 0.6]
optimizers = OrderedDict()
optimizers["SGD"] = SGD(lr=learningrate[0])
optimizers["Momentum"] = Momentum(lr=learningrate[1])
optimizers["Nesterov"] = Nesterov(lr=learningrate[2])
optimizers["AdaGrad"] = AdaGrad(lr=learningrate[3])
optimizers["RMSprop"] = RMSprop(lr=learningrate[4])
optimizers["Adam"] = Adam(lr=learningrate[5])
idx = 1
id_lr = 0
for key in optimizers:
optimizer = optimizers[key]
lr = learningrate[id_lr]
id_lr = id_lr + 1
x_history = []
y_history = []
params['x'], params['y'] = init_pos[0], init_pos[1]
for i in range(50):
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
# 将数组Z中所有大于7的值都设置为0
# plot
plt.subplot(2, 3, idx)
idx += 1
plt.plot(x_history, y_history, 'o-', color="b")
# plt.contour(X, Y, Z) # 绘制等高线
plt.contour(X, Y, Z, cmap='copper') # 颜色填充
# plt.contour()函数用于绘制等高线图
# X 和 Y 是网格点的x和y坐标。
# Z 是每个网格点上的值。
# cmap 是一个可选参数，cmap='gray' 指定了颜色映射为灰度。这意味着等高线图将使用灰度颜色来表示不同的高度或值。
plt.ylim(-10, 10)
plt.xlim(-10, 10)
plt.plot(0, 0, '+')
# plt.axis('off')
# plt.title(key+'\nlr='+str(lr), fontstyle='italic')
plt.text(0, 10, key + '\nlr=' + str(lr), fontsize=10, color="r",
verticalalignment='top', horizontalalignment='center', fontstyle='normal')
'''
0, 10: 这是文本的坐标位置。0是x坐标，10是y坐标。
key + '\nlr=' + str(lr): 这是要添加到图上的文本字符串。key是一个变量，'\n'是一个换行符，将文本分成两行。lr是另一个变量，使用str()函数将其转换为字符串类型，以便与key连接。
fontsize=20: 设置文本的字体大小为10。
color="b": 设置文本的颜色为红色（red）。
verticalalignment='top': 设置文本的垂直对齐方式为顶部对齐。
horizontalalignment='center': 设置文本的水平对齐方式为居中对齐。
fontstyle='italic': 设置文本的字体样式为正常。
'''
plt.xlabel("x")
plt.ylabel("y")
plt.subplots_adjust(wspace=0, hspace=0) # 调整子图间距wspace: 水平间距，即子图之间的宽度间距。hspace: 垂直间距，即子图之间的高度间距。
plt.show()
3. 解释不同轨迹的形成原因
SGD轨迹形成原因：
1、因为是随机梯度下降，SGD在每一步仅仅使用一个样本的梯度信息，这使得它对函数局部特性的估计可能不够准确。当函数具有非均向性（如一个维度上的变化远大于另一个维度）时，SGD可能会在最优解附近来回震荡，呈现出“之”字形的轨迹，
2、学习率设置不合适：如果学习率设置得过大，SGD可能会跳过最优解；如果学习率设置得过小，SGD可能会在最优解附近徘徊不前。当学习率的调整不恰当时，SGD的收敛轨迹就可能呈现出“之”字形。
Adagrad
y轴梯度较大，后面会根据前面较大的变动进行调整，减小更新的步伐，呈现稳定的向最优点收敛。
RMSprop
RMSprop因为逐渐遗忘过去的梯度，只被近期的梯度影响，在最初的时候会收敛的更快，变化幅度大。
Momentum
对以前的梯度做了指数加权平均，不会像原始的那样直接折线那么厉害，因为有之前速度影响，所以瞬间就折，而是会再向原来那个方向前进一段距离,也可以理解为对原始梯度做了一个平滑,然后再用来做梯度下降
Adam
前期收敛幅度较大，后期逐渐平稳，朝着最优点不断移动。Adam算法由于可以结合了动量法和 RMSprop 。
动量法
动量相当于给梯度一个惯性，使其能够在相同方向上持续更新。这可以帮助算法跳过局部最小值并加速收敛。动量系数是一个介于0和1之间的值，通常设置为0.9。该值越高，算法越趋向于保持之前的方向。在每次迭代中，算法会计算梯度，并将其与之前的梯度相加，产生一个新的梯度。它可以跳过局部最小值并加速收敛。另外，由于动量系数的引入，该算法具有一定的平滑性，这可以帮助防止过度拟合。
缺点：
它需要更多的内存来存储之前的梯度。此外，由于动量系数的引入，该算法可能会导致权重更新过多。这可以通过调整动量系数和学习率来解决。
Adam中使用一阶矩和二阶矩，一阶矩就是期望值，换句话说就是平均数，二阶矩方差
当 一阶矩大，且二阶矩大，梯度大且稳定
当一阶矩小，二阶矩很大，振荡，考虑成可能是向下更新到一个局部的波谷，又进行一波反弹
当 一阶矩 趋近于 0，且 二阶矩也趋近于 0 ：梯度趋于零，可能达到局部最低点，也可能走到一个极度平缓的平地
如何选择优化算法深度学习——优化器算法Optimizer详解（BGD、SGD、MBGD、Momentum、NAG、Adagrad、Adadelta、RMSprop、Adam）-腾讯云开发者社区-腾讯云 (tencent.com)
如果数据是稀疏的，就用自适用方法，即 Adagrad, Adadelta, RMSprop, Adam。
RMSprop, Adadelta, Adam 在很多情况下的效果是相似的。
Adam 就是在 RMSprop 的基础上加了 bias-correction 和 momentum，
随着梯度变的稀疏，Adam 比 RMSprop 效果会好。
整体来讲，Adam 是最好的选择。
很多论文里都会用 SGD，没有 momentum 等。SGD 虽然能达到极小值，但是比其它算法用的时间长，而且可能会被困在鞍点。
如果需要更快的收敛，或者是训练更深更复杂的神经网络，需要用一种自适应的算法。
REF:
【23-24 秋学期】NNDL 作业12 优化算法2D可视化-CSDN博客
深度学习——优化器算法Optimizer详解（BGD、SGD、MBGD、Momentum、NAG、Adagrad、Adadelta、RMSprop、Adam）-腾讯云开发者社区-腾讯云 (tencent.com)
【23-24 秋学期】NNDL 作业12 优化算法2D可视化-CSDN博客
NNDL 作业12-优化算法2D可视化 [HBU]-CSDN博客
Adam Algorithm & First-order moment, Second moment_一阶矩估计-CSDN博客