• 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

  • 相关阅读:
    什么软件可以识别图片上的文字？分享三个实用的识别软件
    二叉树【Java】
    RocketMQ笔记3
    mysql函数获取全路径
    transition和animation的区别？
    信道复用技术
    从此再也不用怕崩溃闪退了
    axios+跨域-笔记
    APP自动化之Poco框架
    Lua04 实例列举 ESB2CP的报文转换流程
  • 原文地址：https://blog.csdn.net/qq_38975453/article/details/128179041