PyTorch优化器与正则化

发表于 | 分类于 ， ，

优化器就是需要根据网络反向传播的梯度信息来更新网络的参数，以起到降低loss函数计算值的作用，Pytorch 提供了十多种优化器算法，它们的基类都是torch.optim.Optimizer，具有如下的基本属性与基本方法：

  • 基本属性
    default： 优化器的超参数
    state： 参数的缓存
    params_groups： 管理的参数组，list 类型，每一个元素是一个字典 {‘params’: ‘values’}
    _step_count： 记录更新的次数

  • 基本方法
    zero_grad( )： 清空所有管理参数的梯度，PyTorch不会自动清零，在求梯度之前手动清零
    step( )： 执行一步更新，一般在 loss.backward() 语句下面使用
    add_param_group( )： 添加参数组到优化器中，对不同的参数组，可以有不同的权值、学习率
    state_dict( )： 获取优化器当前状态信息字典
    load_state_dict( )： 加载状态信息字典（已保存的文件）

另外，优化器算法中还涉及到如下两个概念：学习率和动量。一般的梯度更新参数如下：

其中的 $\alpha$ 就是学习率。如果我们对更新参数的公式做如下调整：

由于增加了一个 $z$ 变量，表征了上一次更新的方向和大小（可以理解更新的速度，这也正是动量一词的由来），所以整个式子相当于综合考虑了梯度下降的方向 $\triangledown f(\omega_k)$ 以及上一次更新的速度，相当于物理上的惯性， $\beta$ 系数用来控制惯性的大小。

理解了优化器的共性后，我们重点介绍四种常用的优化器算法，这些函数的共有参数定义如下：

  • params：需要优化器进行更新的模型参数（net.parameters()）
  • lr：初始的学习率
  • momentum：动量系数 $\beta$
  • weight_decay：权值衰减系数，也就是L2正则项的系数（后面解释）

optim.SGD

随机梯度下降，每次迭代随机选取一个样本来对参数进行更新，这是一种最简单、最直接的优化方法，速度慢，容易陷入局部最优。

torch.optim.SGD(params, lr, momentum=0, dampening=0, weight_decay=0, nesterov=False)

另外两个参数并不常用，dampening 是动量的抑制因子，nesterov 表示是否使用 nesterov动量。

optim.Adagrad

Adagrad是一种自适应优化方法，是自适应的为各个参数分配不同的学习率。这个学习率的变化，会受到梯度的大小和迭代次数的影响。梯度越大，学习率越小；梯度越小，学习率越大。

class torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0, initial_accumulator_value=0)

lr_decay 是学习率的衰减因子，该算法的缺点是这种单调的学习率到了训练后期会变得很小（因为 Adagrad 累加之前所有的梯度平方作为分母），以至于过早停止学习。

optim.RMSprop

RMS 是均方根（Root Meam Square）的意思。RMSprop 是对 Adagrad 的一种改进。RMSprop 采用均方根作为分母，可缓解 Adagrad 学习率下降较快的问题。并且引入均方根，可以减少摆动（原理同自适应，抑制大的，增长小的）。

torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)

其中 alpha 是累加梯度平方时的一个平滑系数，eps 是用到分母上避免为零的极小值，centered 为True 则表示计算中心化的 RMSProp，并且用它的方差预测值对梯度进行归一化。

optim.Adam

Adam 是一种自适应学习率的优化方法，Adam 利用梯度的一阶矩估计和二阶矩估计动态的调整学习率。Adam 结合了 Momentum 和 RMSprop，并进行了偏差修正。

torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)

beats 是算法中用于计算梯度以及梯度平方的加权平均值的系数，eps 是用到分母上避免为零的极小值， amsgrad 表示是否采用AMSGrad优化方法（针对Adam的一种改进）。

最后我们通过一段实验代码，来对比一下上述几种优化器的效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import torch
import torch.utils.data as Data
from matplotlib import pyplot as plt
torch.manual_seed(1)

# 超参数
learning_rate = 0.01
batch_size = 32
epochs =16

# 伪造数据：围绕抛物线 y=x^2 两侧分散
x = torch.unsqueeze(torch.linspace(-1,1,1000),dim=1)
y = x.pow(2)+0.1*torch.normal(torch.zeros(x.size()[0], 1), torch.ones(x.size()[0], 1))

# 加载数据
torch_dataset = Data.TensorDataset(x,y)
loader = Data.DataLoader(dataset=torch_dataset,batch_size=batch_size,shuffle=True)

# 为每一种优化器创建一个神经网络
class Net(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = torch.nn.Linear(1,20)
        self.predict = torch.nn.Linear(20,1)

    def forward(self,x):
        x = torch.relu(self.hidden(x))
        x = self.predict(x)
        return x

net_SGD = Net()
net_Momentum = Net()
net_RMSprop = Net()
net_Adam = Net()
net_Adagrad = Net()

nets = [net_SGD,net_Momentum,net_RMSprop,net_Adam,net_Adagrad]

# 创建不同的优化器用来训练不同的网络
opt_SGD = torch.optim.SGD(net_SGD.parameters(),lr=learning_rate)
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(),lr=learning_rate,momentum=0.8,nesterov=True)
opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(),lr=learning_rate,alpha=0.9)
opt_Adam = torch.optim.Adam(net_Adam.parameters(),lr=learning_rate,betas=(0.9,0.99))
opt_Adagrad = torch.optim.Adagrad(net_Adagrad.parameters(),lr=learning_rate)

optimizers = [opt_SGD,opt_Momentum,opt_RMSprop,opt_Adam,opt_Adagrad]

criterion = torch.nn.MSELoss()
losses_his = [[],[],[],[],[]]  # 记录 training 时不同优化算法对应的 loss
for epoch in range(epochs):
    for step, (b_x, b_y) in enumerate(loader):
        for net,opt,l_his in zip(nets,optimizers,losses_his):
            output = net(b_x)
            loss=criterion(output,b_y)
            opt.zero_grad()
            loss.backward()
            opt.step()
            l_his.append(loss.data.numpy())

# 绘制不同优化算法下loss的变化图像
labels = ['SGD', 'Momentum', 'RMSprop', 'Adam','Adagrad']
for i, l_his in enumerate(losses_his):
    plt.plot(l_his, label=labels[i])
plt.legend(loc='best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim((0, 0.2))
plt.xlim((0, 200))
plt.show()

从上面的代码中可以看出，优化器的使用基本步骤是：

设置初始化优化器 opt -> 模型输出预测值 -> 与真实值计算损失 -> 清空参数的梯度 opt.zero_grad( ) -> 损失反向传播 -> 执行更新 opt.step( )

参数组

Optimizer 通过 param_group 来管理参数组 .param_groups 中保存了参数组及其对应的学习率,动量等设置。所以我们可以通过配置参数组来实现对不同参数采用不同的学习配置。

1
2
3
4
5
# 模型中的分类器参数将使用 1e-3 的学习率
optim.SGD([
                {'params': model.base.parameters()},
                {'params': model.classifier.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

调整学习率

优化器的学习率是大有文章可做的，学习率设置得过小，会使得收敛太慢，但是却可以收敛到极小值点；学习率过大，会使得目标函数甚至越来越大，或者始终在极小值点旁边徘徊，无法收敛到极小值点。所以，训练刚开始设置一个大一点的学习率，随后慢慢减小是一个很不错的策略。PyTorch 提供了学习率调整策略的接口 torch.optim.lr_scheduler，调整策略大致可以分为三大类：

  • 有序调整：等间隔调整（Step），按需调整学习率（MultiStep），指数衰减调整（Exponential）和 余弦退火（CosineAnnealing）
  • 自适应调整：根据指标调整学习率（ReduceLROnPlateau）
  • 自定义调整：自定义调整学习率（LambdaLR）

我们重点介绍两种调整学习率的方法，一种是 epoch 到达一定次数时调整，一种是参考某种指标的变化进行调整：

torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False)

参数 milestones 是一个值递增整型 list，每一个元素代表何时调整学习率；gamma 为学习率调整的倍数，默认为 0.1 倍，即下降 10 倍。

1
2
3
4
5
6
7
8
9
# Assuming optimizer uses lr = 0.05 for all groups
# lr = 0.05     if epoch < 30
# lr = 0.005    if 30 <= epoch < 80
# lr = 0.0005   if epoch >= 80
scheduler = lr_scheduler.MultiStepLR(optimizer, [30, 80], 0.1)

for epoch in range(100):
    scheduler.step()
    y.append(scheduler.get_lr()[0])

当某指标不再变化（下降或升高），调整学习率，这是非常实用的学习率调整策略。 例如，当验证集的 loss 不再下降时，进行学习率调整；或者监测验证集的 accuracy，当accuracy 不再上升时，则调整学习率：

torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode=’min’, factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode=’rel’, cooldown=0, min_lr=0, eps=1e-08)

mode 是模式选择，有 min 和 max 两种模式， min 表示当指标不再降低（如 loss）， max 表示当指标不再升高（如 accuracy）；factor 是学习率调整系数；patience 表示忍受该指标多少个 step 不变化；threshold_mode 为选择判断指标是否达最优的模式，有两种模式， rel（相对值） 和 abs（绝对值）；threshold 配合 threshold_mode 使用；cooldown 是“冷却时间”，当调整学习率之后，让模型先训练一段时间，再重启监测模式；min_lr 是学习率下限，可为单个浮点数，或者是参数组 list；eps 为学习率衰减的最小值，当学习率变化小于 eps 时，则不再调整学习率。

1
2
3
4
5
6
7
8
optimizer = torch.optim.SGD(model.parameters(), 0.006, momentum=0.8)

scheduler = ReducelROnPlateau(optimizer, 'min')
for epoch in range(100):
    train(train_loader , model, criterion, optimizer, epoch )
    result_avg, loss_val = validate(val_loader, model, criterion, epoch)
    # Note that step should be called after validate()
    scheduler.step(loss_val)

自定义调整学习率也是一个常用的策略，尤其是在 fine-tune 中十分有用，可以为不同的层设定不同的学习率调整策略：

torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)

我们只需要将学习率的调整策略写成 lambda 函数作为参数传个 lr_lambda 就可以了，需要注意的是，该 lambda 函数的参数是 step。

正则化

正则化旨在解决学习过程中的过拟合问题，学习算法找到的最优参数可以简单地理解为特征的权重，一个模型之所以会过拟合，就是因为在训练数据学习过程中过分放大了某些特征的权重，所以我们在损失函数中加上一个正则项（L1/L2 —— 由参数计算的范数），再去求最小值，相当于加入了惩罚项，这样就能迫使一些参数逼近0，从而避免过拟合。

PyTorch 的各种优化器内部只封装了 L2 正则项，通过设置 weight_delay 参数（即 L2 正则项前面的系数 $\lambda$）就可实现正则化：

1
optimizer = torch.optim.SGD(model.parameters(),lr=0.01,weight_decay=0.001)

对于 L1 正则化，我们只能自己动手实现：

1
2
3
4
5
6
7
8
9
10
regularization_loss = 0
for param in model.parameters():
    regularization_loss += torch.sum(abs(param))

calssify_loss = criterion(pred, target)
loss = classify_loss + lamda * regularization_loss

optimizer.zero_grad()
loss.backward()
optimizer.step()

当然，神经网络中还有另一种解决过拟合的方法，那就是 Dropout，在前面的内容中已经介绍过了如何引入 Dropout 层。