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

NNDL 作业13 优化算法3D可视化

作者：opred | 2024-01-09 09:30:14

赞

踩

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. import torch
  2. import numpy as np
  3. from matplotlib import pyplot as plt
  4.  
  5.  
  6. class Op(object):
  7.     def __init__(self):
  8.         pass
  9.  
  10.     def __call__(self, inputs):
  11.         return self.forward(inputs)
  12.  
  13.     # 输入：张量inputs
  14.     # 输出：张量outputs
  15.     def forward(self, inputs):
  16.         # return outputs
  17.         raise NotImplementedError
  18.  
  19.     # 输入：最终输出对outputs的梯度outputs_grads
  20.     # 输出：最终输出对inputs的梯度inputs_grads
  21.     def backward(self, outputs_grads):
  22.         # return inputs_grads
  23.         raise NotImplementedError
  24.  
  25. class OptimizedFunction3D(Op):
  26.     def __init__(self):
  27.         super(OptimizedFunction3D, self).__init__()
  28.         self.params = {'x': 0}
  29.         self.grads = {'x': 0}
  30.  
  31.     def forward(self, x):
  32.         self.params['x'] = x
  33.         return x[0] * x[0] / 20 + x[1] * x[1] / 1  # x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  34.  
  35.     def backward(self):
  36.         x = self.params['x']
  37.         gradient1 = 2 * x[0] / 20
  38.         gradient2 = 2 * x[1] / 1
  39.         grad1 = torch.Tensor([gradient1])
  40.         grad2 = torch.Tensor([gradient2])
  41.         self.grads['x'] = torch.cat([grad1, grad2])
  42.  
  43.  
  44. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  45. x1 = np.arange(-3, 3, 0.1)
  46. x2 = np.arange(-3, 3, 0.1)
  47. x1, x2 = np.meshgrid(x1, x2)
  48. init_x = torch.Tensor(np.array([x1, x2]))
  49.  
  50. model = OptimizedFunction3D()
  51.  
  52. # 绘制 f_3d函数 的 三维图像
  53. fig = plt.figure()
  54. ax = plt.axes(projection='3d')
  55. X = init_x[0].numpy()
  56. Y = init_x[1].numpy()
  57. Z = model(init_x).numpy()
  58. ax.plot_surface(X, Y, Z, cmap='rainbow')
  59.  
  60. ax.set_xlabel('x1')
  61. ax.set_ylabel('x2')
  62. ax.set_zlabel('f(x1,x2)')
  63.  
  64. ax.legend(loc='upper left')
  65.  
  66. plt.show()

 两个函数代码的基本框架是一样的，只不过是函数不一样。只要将OptimizedFunction3D(Op)改为下面的就行

  1. class OptimizedFunction3D(Op):
  2.     def __init__(self):
  3.         super(OptimizedFunction3D, self).__init__()
  4.         self.params = {'x': 0}
  5.         self.grads = {'x': 0}
  6.  
  7.     def forward(self, x):
  8.         self.params['x'] = x
  9.         return x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  10.  
  11.     def backward(self):
  12.         x = self.params['x']
  13.         gradient1 = 2 * x[0] + x[1]
  14.         gradient2 = 2 * x[1] + 3 * x[1] ** 2 + x[0]
  15.         grad1 = torch.Tensor([gradient1])
  16.         grad2 = torch.Tensor([gradient2])
  17.         self.grads['x'] = torch.cat([grad1, grad2])

这段代码一开始参考学长学姐的代码跑不出开，然后根据老师给的加入优化算法的代码写出来的。

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

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

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

SimpleBatchGD算法

初始化 SimpleBatchGD(init_lr, model)

    调用 Optimizer，传入 init_lr 和 model 参数

 定义step() 方法：

    如果 model.params 是字典类型

        for  key in model.params :

             更新 model.params[key] = model.params[key] - init_lr * model.grads[key]

Adagrad算法

初始化 Adagrad(init_lr, model, epsilon)

    调用 Optimizer ，传入 init_lr 和 model 参数

    初始化 G 为空字典

     for  key in model.params :

        将 epsilon参数值赋给self. epsilon

adagrad(x, gradient_x, G, init_lr):

    更新 G[key] += gradient_x ** 2

    计算 x -= init_lr / torch.sqrt(G + epsilon) * gradient_x

    return x 和 G

定义step()方法

   for  key in model.params :

   调用 adagrad 方法并赋值给 model.params[key] 和 G[key]

RMSprop算法

初始化 RMSprop(init_lr, model, beta, epsilon)

   调用 Optimizer ，传入 init_lr 和 model 参数

   初始化 G 为空字典

   for  key in model.params :

      将 beta参数值赋给self. beta

      将 epsilon参数值赋给self. epsilon

rmsprop(x, gradient_x, G, init_lr):

   更新 G = beta * G + (1 - beta) * gradient_x ** 2

   计算 x -= init_lr / torch.sqrt(G + epsilon) * gradient_x

   return x 和 G

定义step()方法

   for  key in model.params :

   调用 rmsprop 方法并赋值给 model.params[key] 和 G[key]

Momentum算法

初始化 Momentum(init_lr, model, rho)  

   调用 Optimizer ，传入 init_lr 和 model 参数

   初始化 delta_x 

   for  key in model.params :

      将rho参数值赋给self. rho

momentum(x, gradient_x, delta_x, init_lr) ：

   更新 delta_x = rho * delta_x - init_lr * gradient_x

   计算  x += delta_x

   return x 和  delta_x

定义step()方法

   for  key in model.params :

   调用momentum 方法并赋值给 model.params[key] 和delta_x[key]

Adam算法

初始化 Adam(init_lr, model, beta1, beta2, epsilon)  

   调用 Optimizer ，传入 init_lr 和 model 参数

   将beta1,beta2,epsilon参数值赋给self. beta1,self.beta2,self.epsilon

   初始化 M, G 为空字典

adam(x, gradient_x, G, M, t, init_lr) ：

   计算 M = beta1 * M + (1 - beta1) * gradient_x

   计算 G = beta2 * G + (1 - beta2) * gradient_x ** 2

   计算 M_hat = M / (1 - beta1 ** t)

   计算 G_hat = G / (1 - beta2 ** t)

   计算 x -= init_lr / torch.sqrt(G_hat + epsilon) * M_hat

   return  x, G, M 和 t

定义step()方法

   for  key in model.params :

   调用adam 方法并赋值给 model.params[key] 和delta_x[key]

  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

  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.  
  156. class Adam(Optimizer):
  157.     def __init__(self, init_lr, model, beta1, beta2, epsilon):
  158.         """
  159.         Adam优化器初始化
  160.         输入：
  161.             - init_lr：初始学习率
  162.             - model：模型，model.params存储模型参数值
  163.             - beta1, beta2：移动平均的衰减率
  164.             - epsilon：保持数值稳定性而设置的常数
  165.         """
  166.         super(Adam, self).__init__(init_lr=init_lr, model=model)
  167.         self.beta1 = beta1
  168.         self.beta2 = beta2
  169.         self.epsilon = epsilon
  170.         self.M, self.G = {}, {}
  171.         for key in self.model.params.keys():
  172.             self.M[key] = 0
  173.             self.G[key] = 0
  174.         self.t = 1
  175.  
  176.     def adam(self, x, gradient_x, G, M, t, init_lr):
  177.         """
  178.         adam算法更新参数
  179.         输入：
  180.             - x：参数
  181.             - G：梯度平方的加权移动平均
  182.             - M：梯度的加权移动平均
  183.             - t：迭代次数
  184.             - init_lr：初始学习率
  185.         """
  186.         M = self.beta1 * M + (1 - self.beta1) * gradient_x
  187.         G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
  188.         M_hat = M / (1 - self.beta1 ** t)
  189.         G_hat = G / (1 - self.beta2 ** t)
  190.         t += 1
  191.         x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
  192.         return x, G, M, t
  193.  
  194.     def step(self):
  195.         """参数更新"""
  196.         for key in self.model.params.keys():
  197.             self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
  198.                                                                                  self.model.grads[key],
  199.                                                                                  self.G[key],
  200.                                                                                  self.M[key],
  201.                                                                                  self.t,
  202.                                                                                  self.init_lr)
  203.  
  204.  
  205. class OptimizedFunction3D(Op):
  206.     def __init__(self):
  207.         super(OptimizedFunction3D, self).__init__()
  208.         self.params = {'x': 0}
  209.         self.grads = {'x': 0}
  210.  
  211.     def forward(self, x):
  212.         self.params['x'] = x
  213.         return x[0] * x[0] / 20 + x[1] * x[1] / 1  # x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  214.  
  215.     def backward(self):
  216.         x = self.params['x']
  217.         gradient1 = 2 * x[0] / 20
  218.         gradient2 = 2 * x[1] / 1
  219.         grad1 = torch.Tensor([gradient1])
  220.         grad2 = torch.Tensor([gradient2])
  221.         self.grads['x'] = torch.cat([grad1, grad2])
  222.  
  223.  
  224. class Visualization3D(animation.FuncAnimation):
  225.     """    绘制动态图像，可视化参数更新轨迹    """
  226.  
  227.     def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=100, blit=True, **kwargs):
  228.         """
  229.         初始化3d可视化类
  230.         输入：
  231.             xy_values：三维中x,y维度的值
  232.             z_values：三维中z维度的值
  233.             labels：每个参数更新轨迹的标签
  234.             colors：每个轨迹的颜色
  235.             interval：帧之间的延迟（以毫秒为单位）
  236.             blit：是否优化绘图
  237.         """
  238.         self.fig = fig
  239.         self.ax = ax
  240.         self.xy_values = xy_values
  241.         self.z_values = z_values
  242.  
  243.         frames = max(xy_value.shape[0] for xy_value in xy_values)
  244.  
  245.         self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
  246.                       for _, label, color in zip_longest(xy_values, labels, colors)]
  247.         self.points = [ax.plot([], [], [], color=color, markeredgewidth=1, markeredgecolor='black', marker='o')[0]
  248.                        for _, color in zip_longest(xy_values, colors)]
  249.         # print(self.lines)
  250.         super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
  251.                                               interval=interval, blit=blit, **kwargs)
  252.  
  253.     def init_animation(self):
  254.         # 数值初始化
  255.         for line in self.lines:
  256.             line.set_data_3d([], [], [])
  257.         for point in self.points:
  258.             point.set_data_3d([], [], [])
  259.         return self.points + self.lines
  260.  
  261.     def animate(self, i):
  262.         # 将x,y,z三个数据传入，绘制三维图像
  263.         for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
  264.             line.set_data_3d(xy_value[:i, 0], xy_value[:i, 1], z_value[:i])
  265.         for point, xy_value, z_value in zip(self.points, self.xy_values, self.z_values):
  266.             point.set_data_3d(xy_value[i, 0], xy_value[i, 1], z_value[i])
  267.         return self.points + self.lines
  268.  
  269.  
  270. def train_f(model, optimizer, x_init, epoch):
  271.     x = x_init
  272.     all_x = []
  273.     losses = []
  274.     for i in range(epoch):
  275.         all_x.append(copy.deepcopy(x.numpy()))  # 浅拷贝 改为 深拷贝, 否则List的原值会被改变。 Edit by David 2022.12.4.
  276.         loss = model(x)
  277.         losses.append(loss)
  278.         model.backward()
  279.         optimizer.step()
  280.         x = model.params['x']
  281.     return torch.Tensor(np.array(all_x)), losses
  282.  
  283.  
  284. # 构建5个模型，分别配备不同的优化器
  285. model1 = OptimizedFunction3D()
  286. opt_gd = SimpleBatchGD(init_lr=0.95, model=model1)
  287.  
  288. model2 = OptimizedFunction3D()
  289. opt_adagrad = Adagrad(init_lr=1.5, model=model2, epsilon=1e-7)
  290.  
  291. model3 = OptimizedFunction3D()
  292. opt_rmsprop = RMSprop(init_lr=0.05, model=model3, beta=0.9, epsilon=1e-7)
  293.  
  294. model4 = OptimizedFunction3D()
  295. opt_momentum = Momentum(init_lr=0.1, model=model4, rho=0.9)
  296.  
  297. model5 = OptimizedFunction3D()
  298. opt_adam = Adam(init_lr=0.3, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  299.  
  300. models = [model1, model2, model3, model4, model5]
  301. opts = [opt_gd, opt_adagrad, opt_rmsprop, opt_momentum, opt_adam]
  302.  
  303. x_all_opts = []
  304. z_all_opts = []
  305.  
  306. # 使用不同优化器训练
  307.  
  308. for model, opt in zip(models, opts):
  309.     x_init = torch.FloatTensor([-7, 2])
  310.     x_one_opt, z_one_opt = train_f(model, opt, x_init, 100)  # epoch
  311.     # 保存参数值
  312.     x_all_opts.append(x_one_opt.numpy())
  313.     z_all_opts.append(np.squeeze(z_one_opt))
  314.  
  315. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  316. x1 = np.arange(-10, 10, 0.01)
  317. x2 = np.arange(-5, 5, 0.01)
  318. x1, x2 = np.meshgrid(x1, x2)
  319. init_x = torch.Tensor(np.array([x1, x2]))
  320.  
  321. model = OptimizedFunction3D()
  322.  
  323. # 绘制 f_3d函数 的 三维图像
  324. fig = plt.figure()
  325. ax = plt.axes(projection='3d')
  326. X = init_x[0].numpy()
  327. Y = init_x[1].numpy()
  328. Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
  329. surf = ax.plot_surface(X, Y, Z, edgecolor='grey', cmap=cm.coolwarm)
  330. # fig.colorbar(surf, shrink=0.5, aspect=1)
  331. # ax.set_zlim(-3, 2)
  332. ax.set_xlabel('x1')
  333. ax.set_ylabel('x2')
  334. ax.set_zlabel('f(x1,x2)')
  335.  
  336. labels = ['SGD', 'AdaGrad', 'RMSprop', 'Momentum', 'Adam']
  337. colors = ['#8B0000', '#0000FF', '#000000', '#008B00', '#FF0000']
  338.  
  339. animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
  340. ax.legend(loc='upper right')
  341.  
  342. plt.show()
  343. # animator.save('teaser' + '.gif', writer='imagemagick',fps=10) # 效果不好，估计被挡住了…… 有待进一步提高 Edit by David 2022.12.4
  344. # save不好用，不费劲了，安装个软件做gif https://pc.qq.com/detail/13/detail_23913.html

 这段代码研究了好久也没有弄明白为什么没有轨迹，尝试了很多方法，没成功，最终只能放弃了。只能将这个问题遗留下来，等考试完再解决了。下面借用老师的图看看效果。

3.复现CS231经典动画

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

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. 

（右图：优化景观中鞍点的可视化，其中不同维度的曲率具有不同的符号(一个维度向上弯曲，另一个维度向下弯曲)。请注意，SGD很难打破对称性，并卡在顶部。相反，像RMSprop这样的算法将在鞍方向上看到非常低的梯度。由于RMSprop更新中的分母项，这将增加沿着这个方向的有效学习速率，帮助RMSProp继续。）

  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.  
  156. class Adam(Optimizer):
  157.     def __init__(self, init_lr, model, beta1, beta2, epsilon):
  158.         """
  159.         Adam优化器初始化
  160.         输入：
  161.             - init_lr：初始学习率
  162.             - model：模型，model.params存储模型参数值
  163.             - beta1, beta2：移动平均的衰减率
  164.             - epsilon：保持数值稳定性而设置的常数
  165.         """
  166.         super(Adam, self).__init__(init_lr=init_lr, model=model)
  167.         self.beta1 = beta1
  168.         self.beta2 = beta2
  169.         self.epsilon = epsilon
  170.         self.M, self.G = {}, {}
  171.         for key in self.model.params.keys():
  172.             self.M[key] = 0
  173.             self.G[key] = 0
  174.         self.t = 1
  175.  
  176.     def adam(self, x, gradient_x, G, M, t, init_lr):
  177.         """
  178.         adam算法更新参数
  179.         输入：
  180.             - x：参数
  181.             - G：梯度平方的加权移动平均
  182.             - M：梯度的加权移动平均
  183.             - t：迭代次数
  184.             - init_lr：初始学习率
  185.         """
  186.         M = self.beta1 * M + (1 - self.beta1) * gradient_x
  187.         G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
  188.         M_hat = M / (1 - self.beta1 ** t)
  189.         G_hat = G / (1 - self.beta2 ** t)
  190.         t += 1
  191.         x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
  192.         return x, G, M, t
  193.  
  194.     def step(self):
  195.         """参数更新"""
  196.         for key in self.model.params.keys():
  197.             self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
  198.                                                                                  self.model.grads[key],
  199.                                                                                  self.G[key],
  200.                                                                                  self.M[key],
  201.                                                                                  self.t,
  202.                                                                                  self.init_lr)
  203.  
  204.  
  205. class OptimizedFunction3D(Op):
  206.     def __init__(self):
  207.         super(OptimizedFunction3D, self).__init__()
  208.         self.params = {'x': 0}
  209.         self.grads = {'x': 0}
  210.  
  211.     def forward(self, x):
  212.         self.params['x'] = x
  213.         return - x[0] * x[0] / 2 + x[1] * x[1] / 1  # x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
  214.  
  215.     def backward(self):
  216.         x = self.params['x']
  217.         gradient1 = - 2 * x[0] / 2
  218.         gradient2 = 2 * x[1] / 1
  219.         grad1 = torch.Tensor([gradient1])
  220.         grad2 = torch.Tensor([gradient2])
  221.         self.grads['x'] = torch.cat([grad1, grad2])
  222.  
  223.  
  224. class Visualization3D(animation.FuncAnimation):
  225.     """    绘制动态图像，可视化参数更新轨迹    """
  226.  
  227.     def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=100, blit=True, **kwargs):
  228.         """
  229.         初始化3d可视化类
  230.         输入：
  231.             xy_values：三维中x,y维度的值
  232.             z_values：三维中z维度的值
  233.             labels：每个参数更新轨迹的标签
  234.             colors：每个轨迹的颜色
  235.             interval：帧之间的延迟（以毫秒为单位）
  236.             blit：是否优化绘图
  237.         """
  238.         self.fig = fig
  239.         self.ax = ax
  240.         self.xy_values = xy_values
  241.         self.z_values = z_values
  242.  
  243.         frames = max(xy_value.shape[0] for xy_value in xy_values)
  244.  
  245.         self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
  246.                       for _, label, color in zip_longest(xy_values, labels, colors)]
  247.         self.points = [ax.plot([], [], [], color=color, markeredgewidth=1, markeredgecolor='black', marker='o')[0]
  248.                        for _, color in zip_longest(xy_values, colors)]
  249.         # print(self.lines)
  250.         super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
  251.                                               interval=interval, blit=blit, **kwargs)
  252.  
  253.     def init_animation(self):
  254.         # 数值初始化
  255.         for line in self.lines:
  256.             line.set_data_3d([], [], [])
  257.         for point in self.points:
  258.             point.set_data_3d([], [], [])
  259.         return self.points + self.lines
  260.  
  261.     def animate(self, i):
  262.         # 将x,y,z三个数据传入，绘制三维图像
  263.         for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
  264.             line.set_data_3d(xy_value[:i, 0], xy_value[:i, 1], z_value[:i])
  265.         for point, xy_value, z_value in zip(self.points, self.xy_values, self.z_values):
  266.             point.set_data_3d(xy_value[i, 0], xy_value[i, 1], z_value[i])
  267.         return self.points + self.lines
  268.  
  269.  
  270. def train_f(model, optimizer, x_init, epoch):
  271.     x = x_init
  272.     all_x = []
  273.     losses = []
  274.     for i in range(epoch):
  275.         all_x.append(copy.deepcopy(x.numpy()))  # 浅拷贝 改为 深拷贝, 否则List的原值会被改变。 Edit by David 2022.12.4.
  276.         loss = model(x)
  277.         losses.append(loss)
  278.         model.backward()
  279.         optimizer.step()
  280.         x = model.params['x']
  281.     return torch.Tensor(np.array(all_x)), losses
  282.  
  283.  
  284. # 构建5个模型，分别配备不同的优化器
  285. model1 = OptimizedFunction3D()
  286. opt_gd = SimpleBatchGD(init_lr=0.05, model=model1)
  287.  
  288. model2 = OptimizedFunction3D()
  289. opt_adagrad = Adagrad(init_lr=0.05, model=model2, epsilon=1e-7)
  290.  
  291. model3 = OptimizedFunction3D()
  292. opt_rmsprop = RMSprop(init_lr=0.05, model=model3, beta=0.9, epsilon=1e-7)
  293.  
  294. model4 = OptimizedFunction3D()
  295. opt_momentum = Momentum(init_lr=0.05, model=model4, rho=0.9)
  296.  
  297. model5 = OptimizedFunction3D()
  298. opt_adam = Adam(init_lr=0.05, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  299.  
  300. models = [model5, model2, model3, model4, model1]
  301. opts = [opt_adam, opt_adagrad, opt_rmsprop, opt_momentum, opt_gd]
  302.  
  303. x_all_opts = []
  304. z_all_opts = []
  305.  
  306. # 使用不同优化器训练
  307.  
  308. for model, opt in zip(models, opts):
  309.     x_init = torch.FloatTensor([0.00001, 0.5])
  310.     x_one_opt, z_one_opt = train_f(model, opt, x_init, 100)  # epoch
  311.     # 保存参数值
  312.     x_all_opts.append(x_one_opt.numpy())
  313.     z_all_opts.append(np.squeeze(z_one_opt))
  314.  
  315. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  316. x1 = np.arange(-1, 2, 0.01)
  317. x2 = np.arange(-1, 1, 0.05)
  318. x1, x2 = np.meshgrid(x1, x2)
  319. init_x = torch.Tensor(np.array([x1, x2]))
  320.  
  321. model = OptimizedFunction3D()
  322.  
  323. # 绘制 f_3d函数 的 三维图像
  324. fig = plt.figure()
  325. ax = plt.axes(projection='3d')
  326. X = init_x[0].numpy()
  327. Y = init_x[1].numpy()
  328. Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
  329. surf = ax.plot_surface(X, Y, Z, edgecolor='grey', cmap=cm.coolwarm)
  330. # fig.colorbar(surf, shrink=0.5, aspect=1)
  331. ax.set_zlim(-3, 2)
  332. ax.set_xlabel('x1')
  333. ax.set_ylabel('x2')
  334. ax.set_zlabel('f(x1,x2)')
  335.  
  336. labels = ['Adam', 'AdaGrad', 'RMSprop', 'Momentum', 'SGD']
  337. colors = ['#8B0000', '#0000FF', '#000000', '#008B00', '#FF0000']
  338.  
  339. animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
  340. ax.legend(loc='upper right')
  341.  
  342. plt.show()

下面是我跑出来的结果，还是没有轨迹， 然后开始找原因，发现在别被打脸学长的文章中也发现了相同的问题。学长说这是深拷贝和浅拷贝的问题，我根据学长给出的线索改了改我的代码，但是没有成功。

 既然提到了深拷贝和浅拷贝顺便就查了一下资料：

浅拷贝：

        浅拷贝是会将对象的每个属性进行依次复制，但是当对象的属性值是引用类型时，实质复制的是其引用，当引用指向的值改变时也会跟着变化。
        可以使用 for in、 Object.assign、 扩展运算符 ... 、Array.prototype.slice()、Array.prototype.concat() 等

深拷贝：

        深拷贝和浅拷贝是针对复杂数据类型（对象及数组）来说的，浅拷贝只拷贝一层，而深拷贝是层层拷贝。

        深拷贝复制变量值，对于非基本类型的变量，则递归至基本类型变量后，再复制。 深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。

浅拷贝使用copy.copy()函数

深拷贝使用copy.deepcopy()函数

 只能先放一张老师的图分析各个算法的优缺点：

 

 由不同的指南针来对比不同的优化算法：

SGD：SGD就像拿着一个指南针在森林里走，每次只朝一个方向走一小步，但方向是随机的。因为每次都要看指南针，所以走得比较慢。

Adagrad：Adagrad就像有一个能快速调整方向的指南针。起初，可能会走得很快，但随着时间推移，方向调整得越来越小，走得也就慢了。因为指南针调整方向很快，所以走得比SGD快。

RMSprop：RMSprop就像有一个能记住之前方向的指南针。这样，你就不会突然大幅度改变方向，可以保持一个相对稳定的步伐。和Adagrad差不多，但更稳定。

Momentum：Momentum就像有一个可以预判的指南针。这个指南针不仅看当前的方向，还会历史方向预判下一个方向，这样就可以少做很多不必要的调整。虽然还是要看指南针，但因为预判的关系，走得比SGD和Adagrad/RMSprop都快。

Nesterov：Nesterov就像有一个超级聪明的指南针，它不仅预判方向，还会考虑到未来的方向。这样就可以少走弯路。比Momentum更快，因为它更聪明。

Adam：Adam就像你有一个超级智能的指南针，它不仅预判方向，还会记住之前的方向和步幅。这样就可以走得更稳、更快。所以走得最快。

 啊啊啊啊啊啊！！为什么我的小球出不来！！！！！

参考链接：

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

NNDL实验 优化算法3D轨迹 复现cs231经典动画_深度学习 优化算法 动画展示-CSDN博客

理解深拷贝和浅拷贝-CSDN博客

NNDL 实验八 网络优化与正则化（3）不同优化算法比较_逐元素平方的公式表示-CSDN博客

NNDL 作业12 优化算法2D可视化-CSDN博客

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

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

  

闽ICP备14008679号