HBU-NNDL 实验八 网络优化与正则化（3）不同优化算法比较

 

目录

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

7.3.1 优化算法的实验设定

7.3.1.1 2D可视化实验

7.3.1.2 简单拟合实验

7.3.1.3 与Torch API对比，验证正确性

7.3.2 学习率调整 

7.3.2.1 AdaGrad算法

7.3.2.2 RMSprop算法

7.3.3 梯度估计修正

7.3.3.1 动量法

7.3.3.2 Adam算法 

7.3.4 不同优化器的3D可视化对比 

7.3.4.1 构建一个三维空间中的被优化函数

心得体会

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

除了批大小对模型收敛速度的影响外，学习率和梯度估计也是影响神经网络优化的重要因素。神经网络优化中常用的优化方法也主要是如下两方面的改进，包括：

  • 学习率调整：主要通过自适应地调整学习率使得优化更稳定。这类算法主要有AdaGrad、RMSprop、AdaDelta算法等。
  • 梯度估计修正：主要通过修正每次迭代时估计的梯度方向来加快收敛速度。这类算法主要有动量法、Nesterov加速梯度方法等。

除上述方法外，本节还会介绍综合学习率调整和梯度估计修正的优化算法，如Adam算法。

7.3.1 优化算法的实验设定

7.3.1.1 2D可视化实验

为了更好地展示不同优化算法的能力对比，我们选择一个二维空间中的凸函数，然后用不同的优化算法来寻找最优解，并可视化梯度下降过程的轨迹。

将被优化函数实现为OptimizedFunction算子，其forward方法是Sphere函数的前向计算，backward方法则计算被优化函数对x的偏导。代码实现如下：

  1. class OptimizedFunction(Op):
  2.     def __init__(self, w):
  3.         super(OptimizedFunction, self).__init__()
  4.         self.w = torch.as_tensor(w,dtype=torch.float32)
  5.         self.params = {'x': torch.as_tensor(0,dtype=torch.float32)}
  6.         self.grads = {'x': torch.as_tensor(0,dtype=torch.float32)}
  7.  
  8.     def forward(self, x):
  9.         self.params['x'] = x
  10.         return torch.matmul(self.w.T, torch.square(self.params['x']))
  11.  
  12.     def backward(self):
  13.         self.grads['x'] = 2 * torch.multiply(self.w.T, self.params['x'])

训练函数 定义一个简易的训练函数，记录梯度下降过程中每轮的参数x和损失。代码实现如下：

  1. def train_f(model, optimizer, x_init, epoch):
  2.     x = x_init
  3.     all_x = []
  4.     losses = []
  5.     for i in range(epoch):
  6.         all_x.append(copy.copy(x.numpy()))
  7.         loss = model(x)
  8.         losses.append(loss)
  9.         model.backward()
  10.         optimizer.step()
  11.         x = model.params['x']
  12.     return torch.as_tensor(all_x), losses

 可视化函数 定义一个Visualization类，用于绘制x的更新轨迹。代码实现如下：

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. class Visualization(object):
  4.     def __init__(self):
  5.         x1 = np.arange(-5, 5, 0.1)
  6.         x2 = np.arange(-5, 5, 0.1)
  7.         x1, x2 = np.meshgrid(x1, x2)
  8.         self.init_x = torch.as_tensor([x1, x2])
  9.  
  10.     def plot_2d(self, model, x, fig_name):
  11.         fig, ax = plt.subplots(figsize=(10, 6))
  12.         cp = ax.contourf(self.init_x[0], self.init_x[1], model(self.init_x.transpose(1,0)), colors=['#e4007f', '#f19ec2', '#e86096', '#eb7aaa', '#f6c8dc', '#f5f5f5', '#000000'])
  13.         c = ax.contour(self.init_x[0], self.init_x[1], model(self.init_x.transpose(1,0)), colors='black')
  14.         cbar = fig.colorbar(cp)
  15.         ax.plot(x[:, 0], x[:, 1], '-o', color='#000000')
  16.         ax.plot(0, 'r*', markersize=18, color='#fefefe')
  17.  
  18.         ax.set_xlabel('$x1$')
  19.         ax.set_ylabel('$x2$')
  20.  
  21.         ax.set_xlim((-2, 5))
  22.         ax.set_ylim((-2, 5))
  23.         plt.savefig(fig_name)

定义train_and_plot_f函数，调用train_f和Visualization，训练模型并可视化参数更新轨迹。代码实现如下：

  1. def train_and_plot_f(model, optimizer, epoch, fig_name):
  2.     x_init = torch.as_tensor([3, 4], dtype=torch.float32)
  3.     print('x1 initiate: {}, x2 initiate: {}'.format(x_init[0].numpy(), x_init[1].numpy()))
  4.     x, losses = train_f(model, optimizer, x_init, epoch)
  5.     losses = np.array(losses)
  6.  
  7.     # 展示x1、x2的更新轨迹
  8.     vis = Visualization()
  9.     vis.plot_2d(model, x, fig_name)

模型训练与可视化 指定Sphere函数中w的值，实例化被优化函数，通过小批量梯度下降法更新参数，并可视化x的更新轨迹。

  1. from op import SimpleBatchGD
  2. # 固定随机种子
  3. torch.seed()
  4. w = torch.as_tensor([0.2, 2])
  5. model = OptimizedFunction(w)
  6. opt = SimpleBatchGD(init_lr=0.2, model=model)
  7. train_and_plot_f(model, opt, epoch=20, fig_name='opti-vis-para.pdf')

 输出图中不同颜色代表f(x1,x2)的值，具体数值可以参考图右侧的对应表，比如深粉色区域代表f(x1,x2)在0～8之间，不同颜色间黑色的曲线是等值线，代表落在该线上的点对应的f(x1,x2)的值都相同。

7.3.1.2 简单拟合实验

除了2D可视化实验外，我们还设计一个简单的拟合任务，然后对比不同的优化算法。

这里我们随机生成一组数据作为数据样本，再构建一个简单的单层前馈神经网络，用于前向计算。

数据集构建：

  1. # 固定随机种子
  2. torch.seed()
  3. # 随机生成shape为（1000，2）的训练数据
  4. X = torch.randn([1000, 2])
  5. w = torch.as_tensor([0.5, 0.8])
  6. w = torch.unsqueeze(w, dim=1)
  7. noise = 0.01 * torch.rand([1000])
  8. noise = torch.unsqueeze(noise, dim=1)
  9. # 计算y
  10. y = torch.matmul(X, w) + noise
  11. # 打印X, y样本
  12. print('X: ', X[0].numpy())
  13. print('y: ', y[0].numpy())
  14.  
  15. # X，y组成训练样本数据
  16. data = torch.cat((X, y), dim=1)
  17. print('input data shape: ', data.shape)
  18. print('data: ', data[0].numpy())

X:  [1.6101003 1.71508  ]
y:  [2.177391]
input data shape:  torch.Size([1000, 3])
data:  [1.6101003 1.71508   2.177391 ]

定义Linear算子，实现一个线性层的前向和反向计算。代码实现如下：

  1. class Linear(Op):
  2.     def __init__(self, input_size,  weight_init=np.random.standard_normal, bias_init=torch.zeros):
  3.         self.params = {}
  4.         self.params['W'] = weight_init([input_size, 1])
  5.         self.params['W'] = torch.as_tensor(self.params['W'],dtype=torch.float32)
  6.         self.params['b'] = bias_init([1])
  7.  
  8.         self.inputs = None
  9.         self.grads = {}
  10.  
  11.     def forward(self, inputs):
  12.         self.inputs = inputs
  13.         self.outputs = torch.matmul(self.inputs, self.params['W']) + self.params['b']
  14.         return self.outputs
  15.  
  16.     def backward(self, labels):
  17.         K = self.inputs.shape[0]
  18.         self.grads['W'] = 1./ K*torch.matmul(self.inputs.T, (self.outputs - labels))
  19.         self.grads['b'] = 1./K* torch.sum(self.outputs-labels, dim=0)

这里backward函数中实现的梯度并不是forward函数对应的梯度，而是最终损失关于参数的梯度．由于这里的梯度是手动计算的，所以直接给出了最终的梯度。

训练函数 在准备好样本数据和网络以后，复用优化器SimpleBatchGD类，使用小批量梯度下降来进行简单的拟合实验。

这里我们重新定义模型训练train函数。主要以下两点原因：

  • 在一般的随机梯度下降中要在每回合迭代开始之前随机打乱训练数据的顺序，再按批大小进行分组。这里为了保证每次运行结果一致以便更好地对比不同的优化算法，这里不再随机打乱数据。
  • 与RunnerV2中的训练函数相比，这里使用小批量梯度下降。而与RunnerV3中的训练函数相比，又通过继承优化器基类Optimizer实现不同的优化器。

模型训练train函数的代码实现如下：

  1. def train(data, num_epochs, batch_size, model, calculate_loss, optimizer, verbose=False):
  2.  
  3.     # 记录每个回合损失的变化
  4.     epoch_loss = []
  5.     # 记录每次迭代损失的变化
  6.     iter_loss = []
  7.     N = len(data)
  8.     for epoch_id in range(num_epochs):
  9.         # np.random.shuffle(data) #不再随机打乱数据
  10.         # 将训练数据进行拆分，每个mini_batch包含batch_size条的数据
  11.         mini_batches = [data[i:i+batch_size] for i in range(0, N, batch_size)]
  12.         for iter_id, mini_batch in enumerate(mini_batches):
  13.             # data中前两个分量为X
  14.             inputs = mini_batch[:, :-1]
  15.             # data中最后一个分量为y
  16.             labels = mini_batch[:, -1:]
  17.             # 前向计算
  18.             outputs = model(inputs)
  19.             # 计算损失
  20.             loss = calculate_loss(outputs, labels).numpy()
  21.             # 计算梯度
  22.             model.backward(labels)
  23.             # 梯度更新
  24.             optimizer.step()
  25.             iter_loss.append(loss)
  26.         # verbose = True 则打印当前回合的损失
  27.         if verbose:
  28.             print('Epoch {:3d}, loss = {:.4f}'.format(epoch_id, np.mean(iter_loss)))
  29.         epoch_loss.append(np.mean(iter_loss))
  30.     return iter_loss, epoch_loss

优化过程可视化 定义plot_loss函数，用于绘制损失函数变化趋势。代码实现如下：

  1. def plot_loss(iter_loss, epoch_loss, fig_name):
  2.     """
  3.     可视化损失函数的变化趋势
  4.     """
  5.     plt.figure(figsize=(10, 4))
  6.     ax1 = plt.subplot(121)
  7.     ax1.plot(iter_loss, color='#e4007f')
  8.     plt.title('iteration loss')
  9.     ax2 = plt.subplot(122)
  10.     ax2.plot(epoch_loss, color='#f19ec2')
  11.     plt.title('epoch loss')
  12.     plt.savefig(fig_name)
  13.     plt.show()

对于使用不同优化器的模型训练，保存每一个回合损失的更新情况，并绘制出损失函数的变化趋势，以此验证模型是否收敛。定义train_and_plot函数，调用train和plot_loss函数，训练并展示每个回合和每次迭代(Iteration)的损失变化情况。在模型训练时，使用paddle.nn.MSELoss()计算均方误差。代码实现如下：

  1. import torch.nn as nn
  2. def train_and_plot(optimizer, fig_name):
  3.     """
  4.     训练网络并画出损失函数的变化趋势
  5.     输入：
  6.         - optimizer：优化器
  7.     """
  8.     # 定义均方差损失
  9.     mse = nn.MSELoss()
  10.     iter_loss, epoch_loss = train(data, num_epochs=30, batch_size=64, model=model, calculate_loss=mse, optimizer=optimizer)
  11.     plot_loss(iter_loss, epoch_loss, fig_name)

训练网络并可视化损失函数的变化趋势。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3. # 定义网络结构
  4. model = Linear(2)
  5. # 定义优化器
  6. opt = SimpleBatchGD(init_lr=0.01, model=model)
  7. train_and_plot(opt, 'opti-loss.pdf')

 从输出结果看，loss在不断减小，模型逐渐收敛。

7.3.1.3 与Torch API对比，验证正确性

  1. # 固定随机种子
  2. torch.seed()
  3. # 定义网络结构
  4. model = Linear(2)
  5. # 定义优化器
  6. opt = SimpleBatchGD(init_lr=0.01, model=model)
  7.  
  8. x = data[0, :-1].unsqueeze(0)
  9. y = data[0, -1].unsqueeze(0)
  10.  
  11. model1 = Linear(2)
  12. print('model1 parameter W: ', model1.params['W'].numpy())
  13. opt1 = SimpleBatchGD(init_lr=0.01, model=model1)
  14. output1 = model1(x)
  15.  
  16. model2 = nn.Linear(2, 1)
  17. model2.weight = torch.nn.Parameter(model1.params['W'])
  18. print('model2 parameter W: ', model2.state_dict()['weight'].numpy())
  19. output2 = model2(x.T)
  20.  
  21. model1.backward(y)
  22. opt1.step()
  23. print('model1 parameter W after train step: ', model1.params['W'].numpy())
  24.  
  25. opt2 = torch.optim.SGD(lr=0.01, params=model2.parameters())
  26. loss = torch.nn.functional.mse_loss(output2, y) / 2
  27. loss.backward()
  28. opt2.step()
  29. opt2.zero_grad()
  30. print('model2 parameter W after train step: ', model2.state_dict()['weight'].numpy())

model1 parameter W:  [[ 2.3466473 ]
 [-0.12763953]]
model2 parameter W:  [[ 2.3466473 ]
 [-0.12763953]]
model1 parameter W after train step:  [[ 2.3137321 ]
 [-0.12602793]]
model2 parameter W after train step:  [[ 2.3390648]
 [-0.1244641]]

从输出结果看，在一次梯度更新后，两个模型的参数值基本保持一致，证明优化器实现正确。 

7.3.2 学习率调整 

学习率是神经网络优化时的重要超参数。在梯度下降法中，学习率αα的取值非常关键，如果取值过大就不会收敛，如果过小则收敛速度太慢。

常用的学习率调整方法包括如下几种方法：

  • 学习率衰减：如分段常数衰减（Piecewise Constant Decay）、余弦衰减（Cosine Decay）等；
  • 学习率预热：如逐渐预热(Gradual Warmup) 等；
  • 周期性学习率调整：如循环学习率等；
  • 自适应调整学习率的方法：如AdaGrad、RMSprop、AdaDelta等。自适应学习率方法可以针对每个参数设置不同的学习率。

下面我们来详细介绍AdaGrad和RMSprop算法。

7.3.2.1 AdaGrad算法

构建优化器 定义Adagrad类，继承Optimizer类。定义step函数调用adagrad进行参数更新。代码实现如下：

  1. class Adagrad(Optimizer):
  2.     def __init__(self, init_lr, model, epsilon):
  3.         super(Adagrad, self).__init__(init_lr=init_lr, model=model)
  4.         self.G = {}
  5.         for key in self.model.params.keys():
  6.             self.G[key] = 0
  7.         self.epsilon = epsilon
  8.  
  9.     def adagrad(self, x, gradient_x, G, init_lr):
  10.         G += gradient_x ** 2
  11.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  12.         return x, G
  13.  
  14.     def step(self):
  15.         for key in self.model.params.keys():
  16.             self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
  17.                                                                self.model.grads[key],
  18.                                                                self.G[key],
  19.                                                                self.init_lr)

2D可视化实验 使用被优化函数展示Adagrad算法的参数更新轨迹。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3. w = torch.as_tensor([0.2, 2])
  4. model2 = OptimizedFunction(w)
  5. opt2 = Adagrad(init_lr=0.5, model=model2, epsilon=1e-7)
  6. train_and_plot_f(model2, opt2, epoch=50, fig_name='opti-vis-para2.pdf')

x1 initiate: 3.0, x2 initiate: 4.0 

从输出结果看，AdaGrad算法在前几个回合更新时参数更新幅度较大，随着回合数增加，学习率逐渐缩小，参数更新幅度逐渐缩小。在AdaGrad算法中，如果某个参数的偏导数累积比较大，其学习率相对较小。相反，如果其偏导数累积较小，其学习率相对较大。但整体随着迭代次数的增加，学习率逐渐缩小。该算法的缺点是在经过一定次数的迭代依然没有找到最优点时，由于这时的学习率已经非常小，很难再继续找到最优点。

简单拟合实验 训练单层线性网络，验证损失是否收敛。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3. # 定义网络结构
  4. model = Linear(2)
  5. # 定义优化器
  6. opt = Adagrad(init_lr=0.1, model=model, epsilon=1e-7)
  7. train_and_plot(opt, 'opti-loss2.pdf')

 

7.3.2.2 RMSprop算法

RMSprop算法是一种自适应学习率的方法，可以在有些情况下避免AdaGrad算法中学习率不断单调下降以至于过早衰减的缺点。

构建优化器 定义RMSprop类，继承Optimizer类。定义step函数调用rmsprop更新参数。代码实现如下：

  1. class RMSprop(Optimizer):
  2.     def __init__(self, init_lr, model, beta, epsilon):
  3.         super(RMSprop, self).__init__(init_lr=init_lr, model=model)
  4.         self.G = {}
  5.         for key in self.model.params.keys():
  6.             self.G[key] = 0
  7.         self.beta = beta
  8.         self.epsilon = epsilon
  9.  
  10.     def rmsprop(self, x, gradient_x, G, init_lr):
  11.         """
  12.         rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
  13.         """
  14.         G = self.beta * G + (1 - self.beta) * gradient_x ** 2
  15.         x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
  16.         return x, G
  17.  
  18.     def step(self):
  19.         """参数更新"""
  20.         for key in self.model.params.keys():
  21.             self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key],
  22.                                                                self.model.grads[key],
  23.                                                                self.G[key],
  24.                                                                self.init_lr)

2D可视化实验 使用被优化函数展示RMSprop算法的参数更新轨迹。代码实现如下：

  1. torch.seed()
  2. w = torch.as_tensor([0.2, 2])
  3. model3 = OptimizedFunction(w)
  4. opt3 = RMSprop(init_lr=0.1, model=model3, beta=0.9, epsilon=1e-7)
  5. train_and_plot_f(model3, opt3, epoch=50, fig_name='opti-vis-para3.pdf')
  6.

x1 initiate: 3.0, x2 initiate: 4.0

 

 简单拟合实验 训练单层线性网络，进行简单的拟合实验。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3. # 定义网络结构
  4. model = Linear(2)
  5. # 定义优化器
  6. opt3 = RMSprop(init_lr=0.1, model=model, beta=0.9, epsilon=1e-7)
  7. train_and_plot(opt3, 'opti-loss3.pdf')

 

7.3.3 梯度估计修正

除了调整学习率之外，还可以进行梯度估计修正。在小批量梯度下降法中，由于每次迭代的样本具有一定的随机性，因此每次迭代的梯度估计和整个训练集上的最优梯度并不一致。如果每次选取样本数量比较小，损失会呈振荡的方式下降。
一种有效地缓解梯度估计随机性的方式是通过使用最近一段时间内的平均梯度来代替当前时刻的随机梯度来作为参数更新的方向，从而提高优化速度。


7.3.3.1 动量法

动量法（Momentum Method）是用之前积累动量来替代真正的梯度。每次迭代的梯度可以看作加速度。

构建优化器 定义Momentum类，继承Optimizer类。定义step函数调用momentum进行参数更新。代码实现如下：

  1.  
  2. class Momentum(Optimizer):
  3.     def __init__(self, init_lr, model, rho):
  4.         super(Momentum, self).__init__(init_lr=init_lr, model=model)
  5.         self.delta_x = {}
  6.         for key in self.model.params.keys():
  7.             self.delta_x[key] = 0
  8.         self.rho = rho
  9.  
  10.     def momentum(self, x, gradient_x, delta_x, init_lr):
  11.         """
  12.         momentum算法更新参数，delta_x为梯度的加权移动平均
  13.         """
  14.         delta_x = self.rho * delta_x - init_lr * gradient_x
  15.         x += delta_x
  16.         return x, delta_x
  17.  
  18.     def step(self):
  19.         """参数更新"""
  20.         for key in self.model.params.keys():
  21.             self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key],
  22.                                                                       self.model.grads[key],
  23.                                                                       self.delta_x[key],
  24.                                                                       self.init_lr)

2D可视化实验 使用被优化函数展示Momentum算法的参数更新轨迹。

  1. # 固定随机种子
  2. torch.seed()
  3. w = torch.as_tensor([0.2, 2])
  4. model4 = OptimizedFunction(w)
  5. opt4 = Momentum(init_lr=0.01, model=model4, rho=0.9)
  6. train_and_plot_f(model4, opt4, epoch=50, fig_name='opti-vis-para4.pdf')

 

从输出结果看，在模型训练初期，梯度方向比较一致，参数更新幅度逐渐增大，起加速作用；在迭代后期，参数更新幅度减小，在收敛值附近振荡。

简单拟合实验 训练单层线性网络，进行简单的拟合实验。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3.  
  4. # 定义网络结构
  5. model = Linear(2)
  6. # 定义优化器
  7. opt = Momentum(init_lr=0.01, model=model, rho=0.9)
  8. train_and_plot(opt, 'opti-loss4.pdf')

7.3.3.2 Adam算法 

Adam算法（Adaptive Moment Estimation Algorithm，自适应矩估计算法）可以看作动量法和RMSprop算法的结合，不但使用动量作为参数更新方向，而且可以自适应调整学习率。

构建优化器 定义Adam类，继承Optimizer类。定义step函数调用adam函数更新参数。代码实现如下：

  1.  
  2. class Adam(Optimizer):
  3.     def __init__(self, init_lr, model, beta1, beta2, epsilon):
  4.         super(Adam, self).__init__(init_lr=init_lr, model=model)
  5.         self.beta1 = beta1
  6.         self.beta2 = beta2
  7.         self.epsilon = epsilon
  8.         self.M, self.G = {}, {}
  9.         for key in self.model.params.keys():
  10.             self.M[key] = 0
  11.             self.G[key] = 0
  12.         self.t = 1
  13.  
  14.     def adam(self, x, gradient_x, G, M, t, init_lr):
  15.         M = self.beta1 * M + (1 - self.beta1) * gradient_x
  16.         G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
  17.         M_hat = M / (1 - self.beta1 ** t)
  18.         G_hat = G / (1 - self.beta2 ** t)
  19.         t += 1
  20.         x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
  21.         return x, G, M, t
  22.  
  23.     def step(self):
  24.         """参数更新"""
  25.         for key in self.model.params.keys():
  26.             self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
  27.                                                                                  self.model.grads[key],
  28.                                                                                  self.G[key],
  29.                                                                                  self.M[key],
  30.                                                                                  self.t,
  31.                                                                                  self.init_lr)

2D可视化实验 使用被优化函数展示Adam算法的参数更新轨迹。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3. w = torch.as_tensor([0.2, 2])
  4. model5 = OptimizedFunction(w)
  5. opt5 = Adam(init_lr=0.2, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  6. train_and_plot_f(model5, opt5, epoch=20, fig_name='opti-vis-para5.pdf')
  7.

 

从输出结果看，Adam算法可以自适应调整学习率，参数更新更加平稳。

简单拟合实验 训练单层线性网络，进行简单的拟合实验。代码实现如下：

  1. # 固定随机种子
  2. torch.seed()
  3. # 定义网络结构
  4. model = Linear(2)
  5. # 定义优化器
  6. opt5 = Adam(init_lr=0.1, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  7. train_and_plot(opt5, 'opti-loss5.pdf')

 

7.3.4 不同优化器的3D可视化对比 

7.3.4.1 构建一个三维空间中的被优化函数

定义OptimizedFunction3D算子，表示被优化函数f(x)=x[0]2+x[1]2+x[1]3+x[0]∗x[1]，其中x[0], x[1]代表两个参数。该函数在(0,0)处存在鞍点，即一个既不是极大值点也不是极小值点的临界点。希望训练过程中，优化算法可以使参数离开鞍点，向模型最优解收敛。代码实现如下：

  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])

对于相同的被优化函数，分别使用不同的优化器进行参数更新，并保存不同优化器下参数更新的值，用于可视化。代码实现如下：

  1. # 构建5个模型，分别配备不同的优化器
  2. model1 = OptimizedFunction3D()
  3. opt_gd = SimpleBatchGD(init_lr=0.01, model=model1)
  4.  
  5. model2 = OptimizedFunction3D()
  6. opt_adagrad = Adagrad(init_lr=0.5, model=model2, epsilon=1e-7)
  7.  
  8. model3 = OptimizedFunction3D()
  9. opt_rmsprop = RMSprop(init_lr=0.1, model=model3, beta=0.9, epsilon=1e-7)
  10.  
  11. model4 = OptimizedFunction3D()
  12. opt_momentum = Momentum(init_lr=0.01, model=model4, rho=0.9)
  13.  
  14. model5 = OptimizedFunction3D()
  15. opt_adam = Adam(init_lr=0.1, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
  16.  
  17. models = [model1, model2, model3, model4, model5]
  18. opts = [opt_gd, opt_adagrad, opt_rmsprop, opt_momentum, opt_adam]
  19.  
  20. x_all_opts = []
  21. z_all_opts = []
  22.  
  23. # 使用不同优化器训练
  24.  
  25. for model, opt in zip(models, opts):
  26.     x_init = torch.FloatTensor([2, 3])
  27.     x_one_opt, z_one_opt = train_f(model, opt, x_init, 150)  # epoch
  28.     # 保存参数值
  29.     x_all_opts.append(x_one_opt.numpy())
  30.     z_all_opts.append(np.squeeze(z_one_opt))

定义Visualization3D函数，用于可视化三维的参数更新轨迹。

  1. class Visualization3D(animation.FuncAnimation):
  2.     """    绘制动态图像，可视化参数更新轨迹    """
  3.  
  4.     def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=600, blit=True, **kwargs):
  5.         """
  6.         初始化3d可视化类
  7.         输入：
  8.             xy_values：三维中x,y维度的值
  9.             z_values：三维中z维度的值
  10.             labels：每个参数更新轨迹的标签
  11.             colors：每个轨迹的颜色
  12.             interval：帧之间的延迟（以毫秒为单位）
  13.             blit：是否优化绘图
  14.         """
  15.         self.fig = fig
  16.         self.ax = ax
  17.         self.xy_values = xy_values
  18.         self.z_values = z_values
  19.  
  20.         frames = max(xy_value.shape[0] for xy_value in xy_values)
  21.         self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
  22.                       for _, label, color in zip_longest(xy_values, labels, colors)]
  23.         super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
  24.                                               interval=interval, blit=blit, **kwargs)
  25.  
  26.     def init_animation(self):
  27.         # 数值初始化
  28.         for line in self.lines:
  29.             line.set_data([], [])
  30.             # line.set_3d_properties(np.asarray([]))  # 源程序中有这一行，加上会报错。 Edit by David 2022.12.4
  31.         return self.lines
  32.  
  33.     def animate(self, i):
  34.         # 将x,y,z三个数据传入，绘制三维图像
  35.         for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
  36.             line.set_data(xy_value[:i, 0], xy_value[:i, 1])
  37.             line.set_3d_properties(z_value[:i])
  38.         return self.lines

绘制出被优化函数的三维图像。代码实现如下：

  1. # 使用numpy.meshgrid生成x1,x2矩阵，矩阵的每一行为[-3, 3]，以0.1为间隔的数值
  2. x1 = np.arange(-3, 3, 0.1)
  3. x2 = np.arange(-3, 3, 0.1)
  4. x1, x2 = np.meshgrid(x1, x2)
  5. init_x = torch.Tensor(np.array([x1, x2]))
  6.  
  7. model = OptimizedFunction3D()
  8.  
  9. # 绘制 f_3d函数 的 三维图像
  10. fig = plt.figure()
  11. ax = plt.axes(projection='3d')
  12. X = init_x[0].numpy()
  13. Y = init_x[1].numpy()
  14. Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
  15. ax.plot_surface(X, Y, Z, cmap='rainbow')
  16.  
  17. ax.set_xlabel('x1')
  18. ax.set_ylabel('x2')
  19. ax.set_zlabel('f(x1,x2)')
  20.  
  21. labels = ['SGD', 'AdaGrad', 'RMSprop', 'Momentum', 'Adam']
  22. colors = ['#f6373c', '#f6f237', '#45f637', '#37f0f6', '#000000']
  23.  
  24. animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
  25. ax.legend(loc='upper left')
  26.  
  27. plt.show()

从输出结果看，对于我们构建的函数，有些优化器如Momentum在参数更新时成功逃离鞍点，其他优化器在本次实验中收敛到鞍点处没有成功逃离。但这并不证明Momentum优化器是最好的优化器，在模型训练时使用哪种优化器，还要结合具体的场景和数据具体分析。

 

心得体会

这次实验和上次的作业内容类似，这里写一下通过这次实验我认为的优化方法选择：

如果数据是稀疏的，就用自适用方法，即 Adagrad, Adadelta, RMSprop, Adam。

RMSprop, Adadelta, Adam 在很多情况下的效果是相似的。

Adam 就是在 RMSprop 的基础上加了 bias-correction 和 momentum，

随着梯度变的稀疏，Adam 比 RMSprop 效果会好。

整体来讲，Adam 是最好的选择。

很多论文里都会用 SGD，没有 momentum 等。SGD 虽然能达到极小值，但是比其它算法用的时间长，而且可能会被困在鞍点。

如果需要更快的收敛，或者是训练更深更复杂的神经网络，需要用一种自适应的算法。

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

评论记录：

未查询到任何数据！