devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【23-24 秋学期】NNDL 作业13 优化算法3D可视化

作者：IT小白 | 2024-05-20 23:11:40

赞

踩

【23-24 秋学期】NNDL 作业13 优化算法3D可视化

编程实现优化算法，并3D可视化

1. 函数3D可视化

分别画出x[0]^{2}+x[1]^{2}+x[1]^{3}+x[0]*x[1] 和 x^{2} /20+y^{2}的3D图

代码如下：

  1. from mpl_toolkits.mplot3d import Axes3D
  2. import numpy as np
  3. from matplotlib import pyplot as plt
  4. import torch
  5. from nndl.op import Op
  6.  
  7. # 画出x**2
  8. class OptimizedFunction3D(Op):
  9.     def __init__(self):
  10.         super(OptimizedFunction3D, self).__init__()
  11.         self.params = {'x': 0}
  12.         self.grads = {'x': 0}
  13.  
  14.     def forward(self, x):
  15.         self.params['x'] = x
  16.         return x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  17.  
  18.     def backward(self):
  19.         x = self.params['x']
  20.         gradient1 = 2 * x[0] + x[1]
  21.         gradient2 = 2 * x[1] + 3 * x[1] ** 2 + x[0]
  22.         grad1 = torch.Tensor([gradient1])
  23.         grad2 = torch.Tensor([gradient2])
  24.         self.grads['x'] = torch.cat([grad1, grad2])
  25.  
  26. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  27. x1 = np.arange(-3, 3, 0.1)
  28. x2 = np.arange(-3, 3, 0.1)
  29. x1, x2 = np.meshgrid(x1, x2)
  30. init_x = torch.Tensor(np.array([x1, x2]))
  31.  
  32. model = OptimizedFunction3D()
  33.  
  34. # 绘制 f_3d函数 的 三维图像
  35. fig = plt.figure()
  36. ax = plt.axes(projection='3d')
  37. X = init_x[0].numpy()
  38. Y = init_x[1].numpy()
  39. Z = model(init_x).numpy()
  40. ax.plot_surface(X, Y, Z, cmap='rainbow')
  41.  
  42. ax.set_xlabel('x1')
  43. ax.set_ylabel('x2')
  44. ax.set_zlabel('f(x1,x2)')
  45. plt.show()
  46.  
  47. # 画出x * x / 20 + y * y
  48. def func(x, y):
  49.     return x * x / 20 + y * y
  50.  
  51. def paint_loss_func():
  52.     x = np.linspace(-50, 50, 100)  # x的绘制范围是-50到50，从改区间均匀取100个数
  53.     y = np.linspace(-50, 50, 100)  # y的绘制范围是-50到50，从改区间均匀取100个数
  54.  
  55.     X, Y = np.meshgrid(x, y)
  56.     Z = func(X, Y)
  57.  
  58.     fig = plt.figure()  # figsize=(10, 10))
  59.     ax = Axes3D(fig)
  60.     plt.xlabel('x')
  61.     plt.ylabel('y')
  62.  
  63.     ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='rainbow')
  64.     plt.show()
  65.  
  66.  
  67. paint_loss_func()
  68.

2.加入优化算法，画出轨迹

分别画出x[0]^{2}+x[1]^{2}+x[1]^{3}+x[0]*x[1] 和 x^{2} /20+y^{2}的3D轨迹图

（1）x[0]^{2}+x[1]^{2}+x[1]^{3}+x[0]*x[1]

  1. import torch
  2. import numpy as np
  3. import copy
  4. from matplotlib import pyplot as plt
  5. from matplotlib import animation
  6. from itertools import zip_longest
  7. from nndl.op import Op
  8.  
  9.  
  10. class Optimizer(object):  # 优化器基类
  11.     def __init__(self, init_lr, model):
  12.         """
  13.         优化器类初始化
  14.         """
  15.         # 初始化学习率，用于参数更新的计算
  16.         self.init_lr = init_lr
  17.         # 指定优化器需要优化的模型
  18.         self.model = model
  19.  
  20.     def step(self):
  21.         """
  22.         定义每次迭代如何更新参数
  23.         """
  24.         pass
  25.  
  26.  
  27. class SimpleBatchGD(Optimizer):
  28.     def __init__(self, init_lr, model):
  29.         super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)
  30.  
  31.     def step(self):
  32.         # 参数更新
  33.         if isinstance(self.model.params, dict):
  34.             for key in self.model.params.keys():
  35.                 self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]
  36.  
  37.  
  38. class Adagrad(Optimizer):
  39.     def __init__(self, init_lr, model, epsilon):
  40.         """
  41.         Adagrad 优化器初始化
  42.         输入：
  43.             - init_lr： 初始学习率 - model：模型，model.params存储模型参数值  - epsilon：保持数值稳定性而设置的非常小的常数
  44.         """
  45.         super(Adagrad, self).__init__(init_lr=init_lr, model=model)
  46.         self.G = {}
  47.         for key in self.model.params.keys():
  48.             self.G[key] = 0
  49.         self.epsilon = epsilon
  50.  
  51.     def adagrad(self, x, gradient_x, G, init_lr):
  52.         """
  53.         adagrad算法更新参数，G为参数梯度平方的累计值。
  54.         """
  55.         G += gradient_x ** 2
  56.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  57.         return x, G
  58.  
  59.     def step(self):
  60.         """
  61.         参数更新
  62.         """
  63.         for key in self.model.params.keys():
  64.             self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
  65.                                                                self.model.grads[key],
  66.                                                                self.G[key],
  67.                                                                self.init_lr)
  68.  
  69.  
  70. class RMSprop(Optimizer):
  71.     def __init__(self, init_lr, model, beta, epsilon):
  72.         """
  73.         RMSprop优化器初始化
  74.         输入：
  75.             - init_lr：初始学习率
  76.             - model：模型，model.params存储模型参数值
  77.             - beta：衰减率
  78.             - epsilon：保持数值稳定性而设置的常数
  79.         """
  80.         super(RMSprop, self).__init__(init_lr=init_lr, model=model)
  81.         self.G = {}
  82.         for key in self.model.params.keys():
  83.             self.G[key] = 0
  84.         self.beta = beta
  85.         self.epsilon = epsilon
  86.  
  87.     def rmsprop(self, x, gradient_x, G, init_lr):
  88.         """
  89.         rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
  90.         """
  91.         G = self.beta * G + (1 - self.beta) * gradient_x ** 2
  92.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  93.         return x, G
  94.  
  95.     def step(self):
  96.         """参数更新"""
  97.         for key in self.model.params.keys():
  98.             self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key],
  99.                                                                self.model.grads[key],
  100.                                                                self.G[key],
  101.                                                                self.init_lr)
  102.  
  103.  
  104. class Momentum(Optimizer):
  105.     def __init__(self, init_lr, model, rho):
  106.         """
  107.         Momentum优化器初始化
  108.         输入：
  109.             - init_lr：初始学习率
  110.             - model：模型，model.params存储模型参数值
  111.             - rho：动量因子
  112.         """
  113.         super(Momentum, self).__init__(init_lr=init_lr, model=model)
  114.         self.delta_x = {}
  115.         for key in self.model.params.keys():
  116.             self.delta_x[key] = 0
  117.         self.rho = rho
  118.  
  119.     def momentum(self, x, gradient_x, delta_x, init_lr):
  120.         """
  121.         momentum算法更新参数，delta_x为梯度的加权移动平均
  122.         """
  123.         delta_x = self.rho * delta_x - init_lr * gradient_x
  124.         x += delta_x
  125.         return x, delta_x
  126.  
  127.     def step(self):
  128.         """参数更新"""
  129.         for key in self.model.params.keys():
  130.             self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key],
  131.                                                                       self.model.grads[key],
  132.                                                                       self.delta_x[key],
  133.                                                                       self.init_lr)
  134. class Nesterov(Optimizer):
  135.     def __init__(self, init_lr, model, rho):
  136.         """
  137.         Nesterov优化器初始化
  138.         输入：
  139.             - init_lr：初始学习率
  140.             - model：模型，model.params存储模型参数值
  141.             - rho：动量因子
  142.         """
  143.         super(Nesterov, self).__init__(init_lr=init_lr, model=model)
  144.         self.delta_x = {}
  145.         for key in self.model.params.keys():
  146.             self.delta_x[key] = 0
  147.         self.rho = rho
  148.  
  149.     def nesterov(self, x, gradient_x, delta_x, init_lr):
  150.         """
  151.         Nesterov算法更新参数，delta_x为梯度的加权移动平均
  152.         """
  153.         delta_x_prev = delta_x
  154.         delta_x = self.rho * delta_x - init_lr * gradient_x
  155.         x += -self.rho * delta_x_prev + (1 + self.rho) * delta_x
  156.         return x, delta_x
  157.  
  158.     def step(self):
  159.         """参数更新"""
  160.         for key in self.model.params.keys():
  161.             self.model.params[key], self.delta_x[key] = self.nesterov(self.model.params[key],
  162.                                                                       self.model.grads[key],
  163.                                                                       self.delta_x[key],
  164.                                                                       self.init_lr)
  165.  
  166.  
  167. class Adam(Optimizer):
  168.     def __init__(self, init_lr, model, beta1, beta2, epsilon):
  169.         """
  170.         Adam优化器初始化
  171.         输入：
  172.             - init_lr：初始学习率
  173.             - model：模型，model.params存储模型参数值
  174.             - beta1, beta2：移动平均的衰减率
  175.             - epsilon：保持数值稳定性而设置的常数
  176.         """
  177.         super(Adam, self).__init__(init_lr=init_lr, model=model)
  178.         self.beta1 = beta1
  179.         self.beta2 = beta2
  180.         self.epsilon = epsilon
  181.         self.M, self.G = {}, {}
  182.         for key in self.model.params.keys():
  183.             self.M[key] = 0
  184.             self.G[key] = 0
  185.         self.t = 1
  186.  
  187.     def adam(self, x, gradient_x, G, M, t, init_lr):
  188.         """
  189.         adam算法更新参数
  190.         输入：
  191.             - x：参数
  192.             - G：梯度平方的加权移动平均
  193.             - M：梯度的加权移动平均
  194.             - t：迭代次数
  195.             - init_lr：初始学习率
  196.         """
  197.         M = self.beta1 * M + (1 - self.beta1) * gradient_x
  198.         G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
  199.         M_hat = M / (1 - self.beta1 ** t)
  200.         G_hat = G / (1 - self.beta2 ** t)
  201.         t += 1
  202.         x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
  203.         return x, G, M, t
  204.  
  205.     def step(self):
  206.         """参数更新"""
  207.         for key in self.model.params.keys():
  208.             self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
  209.                                                                                  self.model.grads[key],
  210.                                                                                  self.G[key],
  211.                                                                                  self.M[key],
  212.                                                                                  self.t,
  213.                                                                                  self.init_lr)
  214.  
  215.  
  216. class OptimizedFunction3D(Op):
  217.     def __init__(self):
  218.         super(OptimizedFunction3D, self).__init__()
  219.         self.params = {'x': 0}
  220.         self.grads = {'x': 0}
  221.  
  222.     def forward(self, x):
  223.         self.params['x'] = x
  224.         return x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  225.  
  226.     def backward(self):
  227.         x = self.params['x']
  228.         gradient1 = 2 * x[0] + x[1]
  229.         gradient2 = 2 * x[1] + 3 * x[1] ** 2 + x[0]
  230.         grad1 = torch.Tensor([gradient1])
  231.         grad2 = torch.Tensor([gradient2])
  232.         self.grads['x'] = torch.cat([grad1, grad2])
  233.  
  234.  
  235. class Visualization3D(animation.FuncAnimation):
  236.     """    绘制动态图像，可视化参数更新轨迹    """
  237.  
  238.     def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=600, blit=True, **kwargs):
  239.         """
  240.         初始化3d可视化类
  241.         输入：
  242.             xy_values：三维中x,y维度的值
  243.             z_values：三维中z维度的值
  244.             labels：每个参数更新轨迹的标签
  245.             colors：每个轨迹的颜色
  246.             interval：帧之间的延迟（以毫秒为单位）
  247.             blit：是否优化绘图
  248.         """
  249.         self.fig = fig
  250.         self.ax = ax
  251.         self.xy_values = xy_values
  252.         self.z_values = z_values
  253.  
  254.         frames = max(xy_value.shape[0] for xy_value in xy_values)
  255.         self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
  256.                       for _, label, color in zip_longest(xy_values, labels, colors)]
  257.         super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
  258.                                               interval=interval, blit=blit, **kwargs)
  259.  
  260.     def init_animation(self):
  261.         # 数值初始化
  262.         for line in self.lines:
  263.             line.set_data([], [])
  264.             # line.set_3d_properties(np.asarray([]))  # 源程序中有这一行，加上会报错。 Edit by David 2022.12.4
  265.         return self.lines
  266.  
  267.     def animate(self, i):
  268.         # 将x,y,z三个数据传入，绘制三维图像
  269.         for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
  270.             line.set_data(xy_value[:i, 0], xy_value[:i, 1])
  271.             line.set_3d_properties(z_value[:i])
  272.         return self.lines
  273.  
  274.  
  275. def train_f(model, optimizer, x_init, epoch):
  276.     x = x_init
  277.     all_x = []
  278.     losses = []
  279.     for i in range(epoch):
  280.         all_x.append(copy.deepcopy(x.numpy()))  # 浅拷贝 改为 深拷贝, 否则List的原值会被改变。 Edit by David 2022.12.4.
  281.         loss = model(x)
  282.         losses.append(loss)
  283.         model.backward()
  284.         optimizer.step()
  285.         x = model.params['x']
  286.     return torch.Tensor(np.array(all_x)), losses
  287.  
  288.  
  289. # 构建6个模型，分别配备不同的优化器
  290. model1 = OptimizedFunction3D()
  291. opt_gd = SimpleBatchGD(init_lr=0.01, model=model1)
  292.  
  293. model2 = OptimizedFunction3D()
  294. opt_adagrad = Adagrad(init_lr=0.5, model=model2, epsilon=1e-7)
  295.  
  296. model3 = OptimizedFunction3D()
  297. opt_rmsprop = RMSprop(init_lr=0.1, model=model3, beta=0.9, epsilon=1e-7)
  298.  
  299. model4 = OptimizedFunction3D()
  300. opt_momentum = Momentum(init_lr=0.01, model=model4, rho=0.9)
  301.  
  302. model5 = OptimizedFunction3D()
  303. opt_adam = Adam(init_lr=0.1, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  304.  
  305. model6 = OptimizedFunction3D()
  306. opt_Nesterov = Nesterov(init_lr=0.1, model=model6, rho=0.9)
  307.  
  308. models = [model1, model2, model3, model4, model5, model6]
  309. opts = [opt_gd, opt_adagrad, opt_rmsprop, opt_momentum, opt_adam, opt_Nesterov]
  310.  
  311. x_all_opts = []
  312. z_all_opts = []
  313.  
  314. # 使用不同优化器训练
  315.  
  316. for model, opt in zip(models, opts):
  317.     x_init = torch.FloatTensor([2, 3])
  318.     x_one_opt, z_one_opt = train_f(model, opt, x_init, 150)  # epoch
  319.     # 保存参数值
  320.     x_all_opts.append(x_one_opt.numpy())
  321.     z_all_opts.append(np.squeeze(z_one_opt))
  322.  
  323. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  324. x1 = np.arange(-3, 3, 0.1)
  325. x2 = np.arange(-3, 3, 0.1)
  326. x1, x2 = np.meshgrid(x1, x2)
  327. init_x = torch.Tensor(np.array([x1, x2]))
  328.  
  329. model = OptimizedFunction3D()
  330.  
  331. # 绘制 f_3d函数 的 三维图像
  332. fig = plt.figure()
  333. ax = plt.axes(projection='3d')
  334. X = init_x[0].numpy()
  335. Y = init_x[1].numpy()
  336. Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
  337. ax.plot_surface(X, Y, Z, cmap='rainbow')
  338.  
  339. ax.set_xlabel('x1')
  340. ax.set_ylabel('x2')
  341. ax.set_zlabel('f(x1,x2)')
  342.  
  343. labels = ['SGD', 'AdaGrad', 'RMSprop', 'Momentum', 'Adam', 'Nesterov']
  344. colors = ['#8B0000', '#0000FF', '#000000', '#008B00', '#FF0000']
  345.  
  346. animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
  347. ax.legend(loc='upper left')
  348.  
  349. plt.show()
  350. animator.save('animation.gif')  # 效果不好，估计被挡住了…… 有待进一步提高 Edit by David 2022.12.4

结果如下：

 （2）x^{2} /20+y^{2}

  1. import torch
  2. import numpy as np
  3. import copy
  4. from matplotlib import pyplot as plt
  5. from matplotlib import animation
  6. from itertools import zip_longest
  7. from matplotlib import cm
  8.  
  9. class Op(object):
  10.     def __init__(self):
  11.         pass
  12.  
  13.     def __call__(self, inputs):
  14.         return self.forward(inputs)
  15.  
  16.     # 输入：张量inputs
  17.     # 输出：张量outputs
  18.     def forward(self, inputs):
  19.         # return outputs
  20.         raise NotImplementedError
  21.  
  22.     # 输入：最终输出对outputs的梯度outputs_grads
  23.     # 输出：最终输出对inputs的梯度inputs_grads
  24.     def backward(self, outputs_grads):
  25.         # return inputs_grads
  26.         raise NotImplementedError
  27. # 优化器基类
  28. class Optimizer(object):
  29.     def __init__(self, init_lr, model):
  30.         """
  31.         优化器类初始化
  32.         """
  33.         # 初始化学习率，用于参数更新的计算
  34.         self.init_lr = init_lr
  35.         # 指定优化器需要优化的模型
  36.         self.model = model
  37.  
  38.     def step(self):
  39.         """
  40.         定义每次迭代如何更新参数
  41.         """
  42.         pass
  43. #SGD
  44. class SimpleBatchGD(Optimizer):
  45.     def __init__(self, init_lr, model):
  46.         super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)
  47.  
  48.     def step(self):
  49.         # 参数更新
  50.         if isinstance(self.model.params, dict):
  51.             for key in self.model.params.keys():
  52.                 self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]
  53. #Adagrad
  54. class Adagrad(Optimizer):
  55.     def __init__(self, init_lr, model, epsilon):
  56.         """
  57.         Adagrad 优化器初始化
  58.         输入：
  59.             - init_lr： 初始学习率 - model：模型，model.params存储模型参数值  - epsilon：保持数值稳定性而设置的非常小的常数
  60.         """
  61.         super(Adagrad, self).__init__(init_lr=init_lr, model=model)
  62.         self.G = {}
  63.         for key in self.model.params.keys():
  64.             self.G[key] = 0
  65.         self.epsilon = epsilon
  66.  
  67.     def adagrad(self, x, gradient_x, G, init_lr):
  68.         """
  69.         adagrad算法更新参数，G为参数梯度平方的累计值。
  70.         """
  71.         G += gradient_x ** 2
  72.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  73.         return x, G
  74.  
  75.     def step(self):
  76.         """
  77.         参数更新
  78.         """
  79.         for key in self.model.params.keys():
  80.             self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
  81.                                                                self.model.grads[key],
  82.                                                                self.G[key],
  83.                                                                self.init_lr)
  84. #RMSprop
  85. class RMSprop(Optimizer):
  86.     def __init__(self, init_lr, model, beta, epsilon):
  87.         """
  88.         RMSprop优化器初始化
  89.         输入：
  90.             - init_lr：初始学习率
  91.             - model：模型，model.params存储模型参数值
  92.             - beta：衰减率
  93.             - epsilon：保持数值稳定性而设置的常数
  94.         """
  95.         super(RMSprop, self).__init__(init_lr=init_lr, model=model)
  96.         self.G = {}
  97.         for key in self.model.params.keys():
  98.             self.G[key] = 0
  99.         self.beta = beta
  100.         self.epsilon = epsilon
  101.  
  102.     def rmsprop(self, x, gradient_x, G, init_lr):
  103.         """
  104.         rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
  105.         """
  106.         G = self.beta * G + (1 - self.beta) * gradient_x ** 2
  107.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  108.         return x, G
  109.  
  110.     def step(self):
  111.         """参数更新"""
  112.         for key in self.model.params.keys():
  113.             self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key],
  114.                                                                self.model.grads[key],
  115.                                                                self.G[key],
  116.                                                                self.init_lr)
  117. #动量法
  118. class Momentum(Optimizer):
  119.     def __init__(self, init_lr, model, rho):
  120.         """
  121.         Momentum优化器初始化
  122.         输入：
  123.             - init_lr：初始学习率
  124.             - model：模型，model.params存储模型参数值
  125.             - rho：动量因子
  126.         """
  127.         super(Momentum, self).__init__(init_lr=init_lr, model=model)
  128.         self.delta_x = {}
  129.         for key in self.model.params.keys():
  130.             self.delta_x[key] = 0
  131.         self.rho = rho
  132.  
  133.     def momentum(self, x, gradient_x, delta_x, init_lr):
  134.         """
  135.         momentum算法更新参数，delta_x为梯度的加权移动平均
  136.         """
  137.         delta_x = self.rho * delta_x - init_lr * gradient_x
  138.         x += delta_x
  139.         return x, delta_x
  140.  
  141.     def step(self):
  142.         """参数更新"""
  143.         for key in self.model.params.keys():
  144.             self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key],
  145.                                                                       self.model.grads[key],
  146.                                                                       self.delta_x[key],
  147.                                                                       self.init_lr)
  148. #Adam
  149. class Adam(Optimizer):
  150.     def __init__(self, init_lr, model, beta1, beta2, epsilon):
  151.         """
  152.         Adam优化器初始化
  153.         输入：
  154.             - init_lr：初始学习率
  155.             - model：模型，model.params存储模型参数值
  156.             - beta1, beta2：移动平均的衰减率
  157.             - epsilon：保持数值稳定性而设置的常数
  158.         """
  159.         super(Adam, self).__init__(init_lr=init_lr, model=model)
  160.         self.beta1 = beta1
  161.         self.beta2 = beta2
  162.         self.epsilon = epsilon
  163.         self.M, self.G = {}, {}
  164.         for key in self.model.params.keys():
  165.             self.M[key] = 0
  166.             self.G[key] = 0
  167.         self.t = 1
  168.  
  169.     def adam(self, x, gradient_x, G, M, t, init_lr):
  170.         """
  171.         adam算法更新参数
  172.         输入：
  173.             - x：参数
  174.             - G：梯度平方的加权移动平均
  175.             - M：梯度的加权移动平均
  176.             - t：迭代次数
  177.             - init_lr：初始学习率
  178.         """
  179.         M = self.beta1 * M + (1 - self.beta1) * gradient_x
  180.         G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
  181.         M_hat = M / (1 - self.beta1 ** t)
  182.         G_hat = G / (1 - self.beta2 ** t)
  183.         t += 1
  184.         x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
  185.         return x, G, M, t
  186.  
  187.     def step(self):
  188.         """参数更新"""
  189.         for key in self.model.params.keys():
  190.             self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
  191.                                                                                  self.model.grads[key],
  192.                                                                                  self.G[key],
  193.                                                                                  self.M[key],
  194.                                                                                  self.t,
  195.                                                                                  self.init_lr)
  196. #三维函数--实现前向传播和反向传播
  197. class OptimizedFunction3D(Op):
  198.     def __init__(self):
  199.         super(OptimizedFunction3D, self).__init__()
  200.         self.params = {'x': 0}
  201.         self.grads = {'x': 0}
  202.  
  203.     def forward(self, x):
  204.         self.params['x'] = x
  205.         return x[0] * x[0] / 20 + x[1] * x[1] / 1  # x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  206.  
  207.     def backward(self):
  208.         x = self.params['x']
  209.         gradient1 = 2 * x[0] / 20
  210.         gradient2 = 2 * x[1] / 1
  211.         grad1 = torch.Tensor([gradient1])
  212.         grad2 = torch.Tensor([gradient2])
  213.         self.grads['x'] = torch.cat([grad1, grad2])
  214. #动态三维图像--可视化参数更新轨迹
  215. class Visualization3D(animation.FuncAnimation):
  216.     """    绘制动态图像，可视化参数更新轨迹    """
  217.     def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=100, blit=True, **kwargs):
  218.         """
  219.         初始化3d可视化类
  220.         输入：
  221.             xy_values：三维中x,y维度的值
  222.             z_values：三维中z维度的值
  223.             labels：每个参数更新轨迹的标签
  224.             colors：每个轨迹的颜色
  225.             interval：帧之间的延迟（以毫秒为单位）
  226.             blit：是否优化绘图
  227.         """
  228.         self.fig = fig
  229.         self.ax = ax
  230.         self.xy_values = xy_values
  231.         self.z_values = z_values
  232.  
  233.         frames = max(xy_value.shape[0] for xy_value in xy_values)
  234.  
  235.         self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
  236.                       for _, label, color in zip_longest(xy_values, labels, colors)]
  237.         self.points = [ax.plot([], [], [], color=color, markeredgewidth=1, markeredgecolor='black', marker='o')[0]
  238.                        for _, color in zip_longest(xy_values, colors)]
  239.         # print(self.lines)
  240.         super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
  241.                                               interval=interval, blit=blit, **kwargs)
  242.  
  243.     def init_animation(self):
  244.         # 数值初始化
  245.         for line in self.lines:
  246.             line.set_data_3d([], [], [])
  247.         for point in self.points:
  248.             point.set_data_3d([], [], [])
  249.         return self.points + self.lines
  250.     #实现动态效果-根据i更新line和point的位置
  251.     def animate(self, i):
  252.         # 将x,y,z三个数据传入，绘制三维图像
  253.         for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
  254.             line.set_data_3d(xy_value[:i, 0], xy_value[:i, 1], z_value[:i])
  255.         for point, xy_value, z_value in zip(self.points, self.xy_values, self.z_values):
  256.             point.set_data_3d(xy_value[i, 0], xy_value[i, 1], z_value[i])
  257.         return self.points + self.lines
  258. def train_f(model, optimizer, x_init, epoch):
  259.     x = x_init
  260.     all_x = []
  261.     losses = []
  262.     for i in range(epoch):
  263.         all_x.append(copy.deepcopy(x.numpy()))  # 浅拷贝 改为 深拷贝, 否则List的原值会被改变。 Edit by David 2022.12.4.
  264.         loss = model(x)
  265.         losses.append(loss)
  266.         model.backward()
  267.         optimizer.step()
  268.         x = model.params['x']
  269.     return torch.Tensor(np.array(all_x)), losses
  270.  
  271. # 构建5个模型，分别配备不同的优化器
  272. model1 = OptimizedFunction3D()
  273. opt_gd = SimpleBatchGD(init_lr=0.95, model=model1)
  274.  
  275. model2 = OptimizedFunction3D()
  276. opt_adagrad = Adagrad(init_lr=1.5, model=model2, epsilon=1e-7)
  277.  
  278. model3 = OptimizedFunction3D()
  279. opt_rmsprop = RMSprop(init_lr=0.05, model=model3, beta=0.9, epsilon=1e-7)
  280.  
  281. model4 = OptimizedFunction3D()
  282. opt_momentum = Momentum(init_lr=0.1, model=model4, rho=0.9)
  283.  
  284. model5 = OptimizedFunction3D()
  285. opt_adam = Adam(init_lr=0.3, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  286.  
  287. models = [model1, model2, model3, model4, model5]
  288. opts = [opt_gd, opt_adagrad, opt_rmsprop, opt_momentum, opt_adam]
  289.  
  290. x_all_opts = []
  291. z_all_opts = []
  292.  
  293. # 使用不同优化器训练
  294. for model, opt in zip(models, opts):
  295.     x_init = torch.FloatTensor([-7, 2])
  296.     x_one_opt, z_one_opt = train_f(model, opt, x_init, 100)  # epoch
  297.     # 保存参数值
  298.     x_all_opts.append(x_one_opt.numpy())
  299.     z_all_opts.append(np.squeeze(z_one_opt))
  300. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  301. x1 = np.arange(-10, 10, 0.01)
  302. x2 = np.arange(-5, 5, 0.01)
  303. x1, x2 = np.meshgrid(x1, x2)
  304. init_x = torch.Tensor(np.array([x1, x2]))
  305.  
  306. model = OptimizedFunction3D()
  307.  
  308. # 绘制 f_3d函数 的 三维图像
  309. fig = plt.figure()
  310. ax = plt.axes(projection='3d')
  311. X = init_x[0].numpy()
  312. Y = init_x[1].numpy()
  313. Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
  314. surf = ax.plot_surface(X, Y, Z, edgecolor='grey', cmap=cm.coolwarm)
  315. # fig.colorbar(surf, shrink=0.5, aspect=1)
  316. # ax.set_zlim(-3, 2)
  317. ax.set_xlabel('x1')
  318. ax.set_ylabel('x2')
  319. ax.set_zlabel('f(x1,x2)')
  320.  
  321. labels = ['SGD', 'AdaGrad', 'RMSprop', 'Momentum', 'Adam']
  322. colors = ['#8B0000', '#0000FF', '#000000', '#008B00', '#FF0000']
  323.  
  324. animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
  325. ax.legend(loc='upper right')
  326.  
  327. plt.show()

结合3D动画，用自己的语言，从轨迹、速度等多个角度讲解各个算法优缺点

3.复现CS231经典动画


Animations that may help your intuitions about the learning process dynamics. 

Left: Contours of a loss surface and time evolution of different optimization algorithms. Notice the "overshooting" behavior of momentum-based methods, which make the optimization look like a ball rolling down the hill. 

Right: A visualization of a saddle point in the optimization landscape, where the curvature along different dimension has different signs (one dimension curves up and another down). Notice that SGD has a very hard time breaking symmetry and gets stuck on the top. Conversely, algorithms such as RMSprop will see very low gradients in the saddle direction. Due to the denominator term in the RMSprop update, this will increase the effective learning rate along this direction, helping RMSProp proceed. 

下边代码加上了Nesterov算法（对动量法进行改进：计算速度时先对当前位置进行一次预更新，然后再根据预更新的位置计算速度）

参考NNDL 作业13 优化算法3D可视化-CSDN博客

  1. import torch
  2. import numpy as np
  3. import copy
  4. from matplotlib import pyplot as plt
  5. from matplotlib import animation
  6. from itertools import zip_longest
  7. from matplotlib import cm
  8.  
  9.  
  10. class Op(object):
  11.     def __init__(self):
  12.         pass
  13.  
  14.     def __call__(self, inputs):
  15.         return self.forward(inputs)
  16.  
  17.     # 输入：张量inputs
  18.     # 输出：张量outputs
  19.     def forward(self, inputs):
  20.         # return outputs
  21.         raise NotImplementedError
  22.  
  23.     # 输入：最终输出对outputs的梯度outputs_grads
  24.     # 输出：最终输出对inputs的梯度inputs_grads
  25.     def backward(self, outputs_grads):
  26.         # return inputs_grads
  27.         raise NotImplementedError
  28.  
  29.  
  30. class Optimizer(object):  # 优化器基类
  31.     def __init__(self, init_lr, model):
  32.         """
  33.         优化器类初始化
  34.         """
  35.         # 初始化学习率，用于参数更新的计算
  36.         self.init_lr = init_lr
  37.         # 指定优化器需要优化的模型
  38.         self.model = model
  39.  
  40.     def step(self):
  41.         """
  42.         定义每次迭代如何更新参数
  43.         """
  44.         pass
  45.  
  46.  
  47. class SimpleBatchGD(Optimizer):
  48.     def __init__(self, init_lr, model):
  49.         super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)
  50.  
  51.     def step(self):
  52.         # 参数更新
  53.         if isinstance(self.model.params, dict):
  54.             for key in self.model.params.keys():
  55.                 self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]
  56.  
  57.  
  58. class Adagrad(Optimizer):
  59.     def __init__(self, init_lr, model, epsilon):
  60.         """
  61.         Adagrad 优化器初始化
  62.         输入：
  63.             - init_lr： 初始学习率 - model：模型，model.params存储模型参数值  - epsilon：保持数值稳定性而设置的非常小的常数
  64.         """
  65.         super(Adagrad, self).__init__(init_lr=init_lr, model=model)
  66.         self.G = {}
  67.         for key in self.model.params.keys():
  68.             self.G[key] = 0
  69.         self.epsilon = epsilon
  70.  
  71.     def adagrad(self, x, gradient_x, G, init_lr):
  72.         """
  73.         adagrad算法更新参数，G为参数梯度平方的累计值。
  74.         """
  75.         G += gradient_x ** 2
  76.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  77.         return x, G
  78.  
  79.     def step(self):
  80.         """
  81.         参数更新
  82.         """
  83.         for key in self.model.params.keys():
  84.             self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
  85.                                                                self.model.grads[key],
  86.                                                                self.G[key],
  87.                                                                self.init_lr)
  88.  
  89.  
  90. class RMSprop(Optimizer):
  91.     def __init__(self, init_lr, model, beta, epsilon):
  92.         """
  93.         RMSprop优化器初始化
  94.         输入：
  95.             - init_lr：初始学习率
  96.             - model：模型，model.params存储模型参数值
  97.             - beta：衰减率
  98.             - epsilon：保持数值稳定性而设置的常数
  99.         """
  100.         super(RMSprop, self).__init__(init_lr=init_lr, model=model)
  101.         self.G = {}
  102.         for key in self.model.params.keys():
  103.             self.G[key] = 0
  104.         self.beta = beta
  105.         self.epsilon = epsilon
  106.  
  107.     def rmsprop(self, x, gradient_x, G, init_lr):
  108.         """
  109.         rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
  110.         """
  111.         G = self.beta * G + (1 - self.beta) * gradient_x ** 2
  112.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  113.         return x, G
  114.  
  115.     def step(self):
  116.         """参数更新"""
  117.         for key in self.model.params.keys():
  118.             self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key],
  119.                                                                self.model.grads[key],
  120.                                                                self.G[key],
  121.                                                                self.init_lr)
  122.  
  123.  
  124. class Momentum(Optimizer):
  125.     def __init__(self, init_lr, model, rho):
  126.         """
  127.         Momentum优化器初始化
  128.         输入：
  129.             - init_lr：初始学习率
  130.             - model：模型，model.params存储模型参数值
  131.             - rho：动量因子
  132.         """
  133.         super(Momentum, self).__init__(init_lr=init_lr, model=model)
  134.         self.delta_x = {}
  135.         for key in self.model.params.keys():
  136.             self.delta_x[key] = 0
  137.         self.rho = rho
  138.  
  139.     def momentum(self, x, gradient_x, delta_x, init_lr):
  140.         """
  141.         momentum算法更新参数，delta_x为梯度的加权移动平均
  142.         """
  143.         delta_x = self.rho * delta_x - init_lr * gradient_x
  144.         x += delta_x
  145.         return x, delta_x
  146.  
  147.     def step(self):
  148.         """参数更新"""
  149.         for key in self.model.params.keys():
  150.             self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key],
  151.                                                                       self.model.grads[key],
  152.                                                                       self.delta_x[key],
  153.                                                                       self.init_lr)
  154.  
  155. class Nesterov(Optimizer):
  156.     def __init__(self, init_lr, model, rho):
  157.         """
  158.         Nesterov优化器初始化
  159.         输入：
  160.             - init_lr：初始学习率
  161.             - model：模型，model.params存储模型参数值
  162.             - rho：动量因子
  163.         """
  164.         super(Nesterov, self).__init__(init_lr=init_lr, model=model)
  165.         self.delta_x = {}
  166.         for key in self.model.params.keys():
  167.             self.delta_x[key] = 0
  168.         self.rho = rho
  169.  
  170.     def nesterov(self, x, gradient_x, delta_x, init_lr):
  171.         """
  172.         Nesterov算法更新参数，delta_x为梯度的加权移动平均
  173.         """
  174.         delta_x_prev = delta_x
  175.         delta_x = self.rho * delta_x - init_lr * gradient_x
  176.         x += -self.rho * delta_x_prev + (1 + self.rho) * delta_x
  177.         return x, delta_x
  178.  
  179.     def step(self):
  180.         """参数更新"""
  181.         for key in self.model.params.keys():
  182.             self.model.params[key], self.delta_x[key] = self.nesterov(self.model.params[key],
  183.                                                                       self.model.grads[key],
  184.                                                                       self.delta_x[key],
  185.                                                                       self.init_lr)
  186.  
  187.  
  188. class Adam(Optimizer):
  189.     def __init__(self, init_lr, model, beta1, beta2, epsilon):
  190.         """
  191.         Adam优化器初始化
  192.         输入：
  193.             - init_lr：初始学习率
  194.             - model：模型，model.params存储模型参数值
  195.             - beta1, beta2：移动平均的衰减率
  196.             - epsilon：保持数值稳定性而设置的常数
  197.         """
  198.         super(Adam, self).__init__(init_lr=init_lr, model=model)
  199.         self.beta1 = beta1
  200.         self.beta2 = beta2
  201.         self.epsilon = epsilon
  202.         self.M, self.G = {}, {}
  203.         for key in self.model.params.keys():
  204.             self.M[key] = 0
  205.             self.G[key] = 0
  206.         self.t = 1
  207.  
  208.     def adam(self, x, gradient_x, G, M, t, init_lr):
  209.         """
  210.         adam算法更新参数
  211.         输入：
  212.             - x：参数
  213.             - G：梯度平方的加权移动平均
  214.             - M：梯度的加权移动平均
  215.             - t：迭代次数
  216.             - init_lr：初始学习率
  217.         """
  218.         M = self.beta1 * M + (1 - self.beta1) * gradient_x
  219.         G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
  220.         M_hat = M / (1 - self.beta1 ** t)
  221.         G_hat = G / (1 - self.beta2 ** t)
  222.         t += 1
  223.         x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
  224.         return x, G, M, t
  225.  
  226.     def step(self):
  227.         """参数更新"""
  228.         for key in self.model.params.keys():
  229.             self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
  230.                                                                                  self.model.grads[key],
  231.                                                                                  self.G[key],
  232.                                                                                  self.M[key],
  233.                                                                                  self.t,
  234.                                                                                  self.init_lr)
  235.  
  236.  
  237. class OptimizedFunction3D(Op):
  238.     def __init__(self):
  239.         super(OptimizedFunction3D, self).__init__()
  240.         self.params = {'x': 0}
  241.         self.grads = {'x': 0}
  242.  
  243.     def forward(self, x):
  244.         self.params['x'] = x
  245.         return - x[0] * x[0] / 2 + x[1] * x[1] / 1  # x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  246.  
  247.     def backward(self):
  248.         x = self.params['x']
  249.         gradient1 = - 2 * x[0] / 2
  250.         gradient2 = 2 * x[1] / 1
  251.         grad1 = torch.Tensor([gradient1])
  252.         grad2 = torch.Tensor([gradient2])
  253.         self.grads['x'] = torch.cat([grad1, grad2])
  254.  
  255.  
  256. class Visualization3D(animation.FuncAnimation):
  257.     """    绘制动态图像，可视化参数更新轨迹    """
  258.  
  259.     def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=100, blit=True, **kwargs):
  260.         """
  261.         初始化3d可视化类
  262.         输入：
  263.             xy_values：三维中x,y维度的值
  264.             z_values：三维中z维度的值
  265.             labels：每个参数更新轨迹的标签
  266.             colors：每个轨迹的颜色
  267.             interval：帧之间的延迟（以毫秒为单位）
  268.             blit：是否优化绘图
  269.         """
  270.         self.fig = fig
  271.         self.ax = ax
  272.         self.xy_values = xy_values
  273.         self.z_values = z_values
  274.  
  275.         frames = max(xy_value.shape[0] for xy_value in xy_values)
  276.  
  277.         self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
  278.                       for _, label, color in zip_longest(xy_values, labels, colors)]
  279.         self.points = [ax.plot([], [], [], color=color, markeredgewidth=1, markeredgecolor='black', marker='o')[0]
  280.                        for _, color in zip_longest(xy_values, colors)]
  281.         # print(self.lines)
  282.         super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
  283.                                               interval=interval, blit=blit, **kwargs)
  284.  
  285.     def init_animation(self):
  286.         # 数值初始化
  287.         for line in self.lines:
  288.             line.set_data_3d([], [], [])
  289.         for point in self.points:
  290.             point.set_data_3d([], [], [])
  291.         return self.points + self.lines
  292.  
  293.     def animate(self, i):
  294.         # 将x,y,z三个数据传入，绘制三维图像
  295.         for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
  296.             line.set_data_3d(xy_value[:i, 0], xy_value[:i, 1], z_value[:i])
  297.         for point, xy_value, z_value in zip(self.points, self.xy_values, self.z_values):
  298.             point.set_data_3d(xy_value[i, 0], xy_value[i, 1], z_value[i])
  299.         return self.points + self.lines
  300.  
  301.  
  302. def train_f(model, optimizer, x_init, epoch):
  303.     x = x_init
  304.     all_x = []
  305.     losses = []
  306.     for i in range(epoch):
  307.         all_x.append(copy.deepcopy(x.numpy()))  # 浅拷贝 改为 深拷贝, 否则List的原值会被改变。 Edit by David 2022.12.4.
  308.         loss = model(x)
  309.         losses.append(loss)
  310.         model.backward()
  311.         optimizer.step()
  312.         x = model.params['x']
  313.     return torch.Tensor(np.array(all_x)), losses
  314.  
  315.  
  316. # 构建5个模型，分别配备不同的优化器
  317. model1 = OptimizedFunction3D()
  318. opt_gd = SimpleBatchGD(init_lr=0.05, model=model1)
  319.  
  320. model2 = OptimizedFunction3D()
  321. opt_adagrad = Adagrad(init_lr=0.05, model=model2, epsilon=1e-7)
  322.  
  323. model3 = OptimizedFunction3D()
  324. opt_rmsprop = RMSprop(init_lr=0.05, model=model3, beta=0.9, epsilon=1e-7)
  325.  
  326. model4 = OptimizedFunction3D()
  327. opt_momentum = Momentum(init_lr=0.05, model=model4, rho=0.9)
  328.  
  329. model5 = OptimizedFunction3D()
  330. opt_adam = Adam(init_lr=0.05, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  331.  
  332. model6 = OptimizedFunction3D()
  333. opt_Nesterov = Nesterov(init_lr=0.1, model=model6, rho=0.9)
  334.  
  335. models = [model1, model2, model3, model4, model5, model6]
  336. opts = [opt_gd, opt_adagrad, opt_rmsprop, opt_momentum, opt_adam, opt_Nesterov]
  337.  
  338. x_all_opts = []
  339. z_all_opts = []
  340.  
  341. # 使用不同优化器训练
  342.  
  343. for model, opt in zip(models, opts):
  344.     x_init = torch.FloatTensor([0.00001, 0.5])
  345.     x_one_opt, z_one_opt = train_f(model, opt, x_init, 100)  # epoch
  346.     # 保存参数值
  347.     x_all_opts.append(x_one_opt.numpy())
  348.     z_all_opts.append(np.squeeze(z_one_opt))
  349.  
  350. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  351. x1 = np.arange(-1, 2, 0.01)
  352. x2 = np.arange(-1, 1, 0.05)
  353. x1, x2 = np.meshgrid(x1, x2)
  354. init_x = torch.Tensor(np.array([x1, x2]))
  355.  
  356. model = OptimizedFunction3D()
  357.  
  358. # 绘制 f_3d函数 的 三维图像
  359. fig = plt.figure()
  360. ax = plt.axes(projection='3d')
  361. X = init_x[0].numpy()
  362. Y = init_x[1].numpy()
  363. Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
  364. surf = ax.plot_surface(X, Y, Z, edgecolor='grey', cmap=cm.coolwarm)
  365. # fig.colorbar(surf, shrink=0.5, aspect=1)
  366. ax.set_zlim(-3, 2)
  367. ax.set_xlabel('x1')
  368. ax.set_ylabel('x2')
  369. ax.set_zlabel('f(x1,x2)')
  370.  
  371. labels = ['SGD', 'AdaGrad', 'RMSprop', 'Momentum', 'Adam', 'Nesterov']
  372. colors = ['#8B0000', '#0000FF', '#000000', '#008B00', '#FF0000']
  373.  
  374.  
  375. animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
  376. ax.legend(loc='upper right')
  377.  
  378. plt.show()
  379. # animator.save('teaser' + '.gif', writer='imagemagick',fps=10) # 效果不好，估计被挡住了…… 有待进一步提高 Edit by David 2022.12.4
  380. # save不好用，不费劲了，安装个软件做gif https://pc.qq.com/detail/13/detail_23913.html

 图像如下

4.结合3D动画，用自己的语言，从轨迹、速度等多个角度讲解各个算法优缺点

SGD（随机梯度下降）

轨迹：

1.轨迹呈现"之"字型：在y方向上更新变化很大，而x轴方向上变化小，梯度的具有随机性，产生动荡现象。

缺点：

2.收敛速度较慢

3.在动画中可以看到SGD陷入了局部最小值。

4.需要调整学习率

AdaGrad

轨迹：

1.“之”字形的变动程度有所衰减：y轴方向梯度大->开始变动较大->按比例进行调整减小更新->y轴方向上的更新程度被减弱。函数的取值高效地向着最小值移动。

2.刚开始AdaGrad速度比RMSprop和SGD要快，有时甚至比Momentum和Nesterov还要快。但是时间越长，AdaGrad的速度会变成最慢【梯度衰减】

缺点：

到后期梯度衰减，速度变慢，会早停

优点：

1.自适应学习率

2.“之”字形的变动程度有所衰减

3.依旧需要手动添加一个全局学习率

RMSprop

轨迹

1.RMSprop在初始阶段比AdaGrad慢。

2.随着时间变化，AdaGrad变慢但RMSprop仍然保持稳定平缓。

3.RMSprop与AdaGrad在轨迹方向上基本一致。

优点：解决AdaGrad的梯度衰减问题，引入衰减率

缺点：要设置新的超参数

Momentum动量法

轨迹

1.Momentum在速度上明显快于其他几种算法，与Nesterov类似。

2.开始时Momentum会朝错误的方向震荡，然后再修正。

3.Momentum可以快速收敛到局部最小值，并解决鞍点问题。

优点：收敛速度、训练速度快

缺点：方向性差

Nesterov

轨迹：

同图中可以看到，在方向正确性高和速度上也快，比Momentum要好。

优点：Nesterov速度快，轨迹正确性高。 Nesterov是对Momentum的改进，它不仅速度快，同时轨迹更加平滑、具有方向性驶向最优点。

Adam

轨迹：

可以看到前期收敛幅度较大，后期逐渐平稳，朝着最优点不断移动。

优点：

它结合了RMSprop算法【调整学习率】和Momentum算法【梯度修正】，轨迹稳定且快速收敛。

参考：【23-24 秋学期】NNDL 作业12 优化算法2D可视化-CSDN博客 

【23-24 秋学期】NNDL 作业13 优化算法3D可视化-CSDN博客 

NNDL 作业13 优化算法3D可视化-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/599801
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号