NNDL实验 优化算法3D轨迹 pytorch版

3D轨迹有助于直观理解，掌握这样一个工具还是有必要的。

换模型、调参数，可以更加深入的了解算法。

程序改编自《神经网络与深度学习：案例与实践》（Paddle版）

7.3 不同优化算法的比较分析

神经网络与深度学习 (nndl.github.io)

最终效果：

动画：

plt.show()看动画没问题。

导出的gif动画轨迹被曲面挡住了。不知道什么原因，有待进一步研究。

​​​​​​​ 

 

 

源代码：

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

注：本文转载自blog.csdn.net的HBU_David的文章"https://blog.csdn.net/qq_38975453/article/details/128179041"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！