更细粒度的参数优化设置

在 网络的训练和测试 中网络使用如下优化器进行训练：

  1. import megengine.optimizer as optim
  2. optimizer = optim.SGD(
  3.     le_net.parameters(), # 参数列表，将指定参数与优化器绑定
  4.     lr=0.05,  # 学习速率
  5. )

这个优化器对所有参数都使用同一学习速率进行优化，而在本章中我们将介绍如何做到对不同的参数采用不同的学习速率。

本章我们沿用 网络搭建 中创建的 LeNet ，下述的优化器相关代码可以用于取代 网络的训练和测试 中对应的代码。

不同参数使用不同的学习速率

Optimizer 支持将网络的参数进行分组，不同的参数组可以采用不同的学习速率进行训练。 一个参数组由一个字典表示，这个字典中必然有键值对： 'params': param_list ，用来指定参数组包含的参数。该字典还可以包含 'lr':learning_rate 来指定此参数组的学习速率。此键值对有时可省略，省略后参数组的学习速率由优化器指定。所有待优化参数组的字典会组成一个列表作为 Optimizer 实例化时的第一个参数传入。

为了更好的说明参数组，我们首先使用 Module 提供的 named_parameters() 函数来对网络参数进行分组。这个函数返回一个包含网络所有参数并且以参数名字为键、参数变量为值的字典：

  1. for (name, param) in le_net.named_parameters():
  2.     print(name, param.shape) # 打印参数的名字和对应张量的形状
  1. classifer.bias (10,)
  2. classifer.weight (10, 84)
  3. conv1.bias (1, 6, 1, 1)
  4. conv1.weight (6, 1, 5, 5)
  5. conv2.bias (1, 16, 1, 1)
  6. conv2.weight (16, 6, 5, 5)
  7. fc1.bias (120,)
  8. fc1.weight (120, 400)
  9. fc2.bias (84,)
  10. fc2.weight (84, 120)

根据参数的名字我们可以将 LeNet 中所有卷积的参数分为一组，所有全连接层的参数分为另一组：

  1. conv_param_list = []
  2. fc_param_list = []
  3. for (name, param) in le_net.named_parameters():
  4.     # 所有卷积的参数为一组，所有全连接层的参数为另一组
  5.     if 'conv' in name:
  6.         conv_param_list.append(param)
  7.     else:
  8.         fc_param_list.append(param)

分组后即可根据下述代码对不同参数组设置不同的学习速率：

  1. import megengine.optimizer as optim
  2.  
  3. optimizer = optim.SGD(
  4.     # 参数组列表即param_groups，每个参数组都可以自定义学习速率，也可不自定义，统一使用优化器设置的学习速率
  5.     [
  6.         {'params': conv_param_list},  # 卷积参数所属的参数组，未自定义学习速率
  7.         {'params': fc_param_list, 'lr': 0.01} # 全连接层参数所属的参数组，自定义学习速率为0.01
  8.     ],
  9.     lr=0.05,  # 参数组例表中未指定学习速率的参数组服从此设置，如所有卷积参数
  10. )

优化器中设置的参数组列表对应于 param_groups 属性。我们可以通过其获取不同参数组的学习速率。

  1. # 打印每个参数组所含参数的数量和对应的学习速率
  2. print(len(optimizer.param_groups[0]['params']), optimizer.param_groups[0]['lr'])
  3. print(len(optimizer.param_groups[1]['params']), optimizer.param_groups[1]['lr'])
  1. 4 0.05
  2. 6 0.01

训练中对学习速率的更改

MegEngine 也支持在训练过程中对学习速率进行修改，比如部分参数训练到一定程度后就不再需要优化，此时将对应参数组的学习速率设为零即可。我们修改 网络的训练和测试 中的训练代码进行示例说明。修改后的训练代码总共训练四个epoch，我们会在第二个epoch结束时将所有全连接层参数的学习速率置零，并在每个epoch当中输出 LeNet 中全连接层的部分参数值以显示是否被更新。

  1. import megengine as mge
  2.  
  3. data = mge.tensor()
  4. label = mge.tensor(dtype="int32") # 交叉熵损失函数的标签数据需要是整型类型
  5.  
  6. # 输出参数的初始值
  7. print("original parameter: {}".format(optimizer.param_groups[1]['params'][0]))
  8. for epoch in range(4):
  9.     for step, (batch_data, batch_label) in enumerate(dataloader):
  10.         data.set_value(batch_data)
  11.         label.set_value(batch_label)
  12.         optimizer.zero_grad() # 将参数的梯度置零
  13.         logits = le_net(data)
  14.         loss = F.cross_entropy_with_softmax(logits, label)
  15.         optimizer.backward(loss) # 反传计算梯度
  16.         optimizer.step()  # 根据梯度更新参数值
  17.  
  18.     # 输出 LeNet 中全连接层的部分参数值
  19.     print("epoch: {}, parameter: {}".format(epoch, optimizer.param_groups[1]['params'][0]))
  20.  
  21.     if epoch == 1:
  22.         # 将所有全连接层参数的学习速率改为0.0
  23.         optimizer.param_groups[1]['lr'] = 0.0
  24.         print("\nset lr zero\n")
  1. original parameter: Tensor([0. 0. 0. 0. 0. 0. 0. 0. 0. 0.])
  2. epoch: 0, parameter: Tensor([-0.0037  0.0245 -0.0075 -0.0002 -0.0063  0.007   0.0036  0.0009 -0.0128 -0.0053])
  3. epoch: 1, parameter: Tensor([-0.0028  0.0246 -0.0083 -0.0007 -0.0068  0.007   0.0033  0.0001 -0.0116 -0.0047])
  4.  
  5. set lr zero
  6.  
  7. epoch: 2, parameter: Tensor([-0.0028  0.0246 -0.0083 -0.0007 -0.0068  0.007   0.0033  0.0001 -0.0116 -0.0047])
  8. epoch: 3, parameter: Tensor([-0.0028  0.0246 -0.0083 -0.0007 -0.0068  0.007   0.0033  0.0001 -0.0116 -0.0047])

从输出可以看到在学习速率设为0之前参数值是在不断更新的，但是在设为0之后参数值就不再变化。

同时多数网络在训练当中会不断减小学习速率，如下代码展示了 MegEnging 是如何在训练过程中线性减小学习速率的：

  1. total_epochs = 10
  2. learning_rate = 0.05 # 初始学习速率
  3. for epoch in range(total_epochs):
  4.     # 设置当前epoch的学习速率
  5.     for param_group in optimizer.param_groups: # param_groups中包含所有需要此优化器更新的参数
  6.         # 学习速率线性递减，每个epoch调整一次
  7.         param_group["lr"] = learning_rate * (1-float(epoch)/total_epochs)

固定部分参数不优化

除了将不训练的参数分为一组并将学习速率设为零外，MegEngine 还提供了其他途径来固定参数不进行优化：仅将需要优化的参数与优化器绑定即可。如下代码所示，我们仅对 LeNet 中的卷积参数进行优化：

  1. import megengine.optimizer as optim
  2.  
  3. le_net = LeNet()
  4. param_list = []
  5. for (name, param) in le_net.named_parameters():
  6.     if 'conv' in name: # 仅训练LeNet中的卷积参数
  7.         param_list.append(param)
  8.  
  9. optimizer = optim.SGD(
  10.     param_list, # 参数
  11.     lr=0.05,  # 学习速率
  12. )

下述代码将上面的设置加入到了具体训练当中，能够更加直观的看到各个参数的梯度差异：

  1. learning_rate = 0.05
  2. data = mge.tensor()
  3. label = mge.tensor(dtype="int32") # 交叉熵损失函数的标签数据需要是整型类型
  4. total_epochs = 1 # 为例减少输出，本次训练仅训练一个epoch
  5. for epoch in range(total_epochs):
  6.     # 设置当前epoch的学习速率
  7.     for param_group in optimizer.param_groups:
  8.         param_group["lr"] = learning_rate * (1-float(epoch)/total_epochs)
  9.  
  10.     total_loss = 0
  11.     for step, (batch_data, batch_label) in enumerate(dataloader):
  12.         data.set_value(batch_data)
  13.         label.set_value(batch_label)
  14.         optimizer.zero_grad() # 将参数的梯度置零
  15.         logits = le_net(data)
  16.         loss = F.cross_entropy_with_softmax(logits, label)
  17.         optimizer.backward(loss) # 反传计算梯度
  18.         optimizer.step()  # 根据梯度更新参数值
  19.         total_loss += loss.numpy().item()
  20.  
  21.     # 输出每个参数的梯度
  22.     for (name, param) in le_net.named_parameters():
  23.         if param.grad is None:
  24.             print(name, param.grad)
  25.         else:
  26.             print(name, param.grad.sum())
  1. classifer.bias None
  2. classifer.weight None
  3. conv1.bias Tensor([0.1187])
  4. conv1.weight Tensor([-0.8661])
  5. conv2.bias Tensor([-0.0737])
  6. conv2.weight Tensor([-27.0589])
  7. fc1.bias None
  8. fc1.weight None
  9. fc2.bias None
  10. fc2.weight None

从输出可以看到除了卷积参数有梯度外其余参数均没有梯度也就不会更新。