Pytorch中的gradient_accumulate_steps、warmup、lr_decay、optimizer和scheduler等问题的解答

（一）gradient_accumulate_steps

　　对于模型训练来说，batch_size越大，模型效果会越好。但是某些环境下，没有足够的GPU来支撑起大的batch_size，因此这时可以考虑使用gradient_accumulate_steps来达到类似的效果。

　　具体地，原来训练过程中每个batch_size都会进行梯度更新，这时我们可以采取每训练（叠加）gradient_accumulate_steps个batch_size再更新梯度（这个操作就相当于将batch_size扩大了gradient_accumulate_steps倍）。更新梯度使用optimizer.step()。

# 该函数的实现包括了warmup和lr_decay
def warmup_linear(x, warmup = 0.002):
    if x < warmup:
        return x/warmup
    return 1.0 - x

global_step_th = int(len(train_examples)/batch_size/gradient_accumulation_steps * start_epoch)

for epoch in range(start_epoch, total_train_epoch):
    train_loss = 0
    train_start = time.time()
    model.train()
    optimizer.zero_grad()
    for step, batch in enumerate(train_dataloader):
        create input and output for batch object_loss
        # loss regularization
        if gradient_accumulation_steps > 1:
            object_loss = object_loss / gradient_accumulation_steps

        # Implementation of backpropagation
        object_loss.backward()
        train_loss = train_loss + object_loss.item()
        if (step+1) % gradient_accumulation_steps == 0:
            # modifying and update the learning rate with warm up which bert uses.
            lr_this_step = learning_rate*warmup_linear(global_step_th/total_train_steps)
            # for the params in optimizer, we update the learning rate
            for param_group in optimizer.param_groups:
                param_group['lr'] = lr_this_step
            optimizer.step()
            optimizer.zero_grad()
            global_step_th = global_step_th + 1

参考文献：

https://blog.csdn.net/Princeicon/article/details/108058822　https://cowarder.site/2019/10/29/Gradient-Accumulation/

https://www.cnblogs.com/lart/p/11628696.html  

（二）调节学习率（学习率的预热与衰减）

（１）学习率的调节步骤一般是先预热，后衰减。

（２）学习率的调节方式包括手动调节和库函数调节。二者除了在引入方法上不一样之外，库函数调节不需要显式的更换模型中的学习率，而手动调节需要在optimizer.param_groups['lr']=updated_lr进行调节。

①　Warmup（学习率预热）

　　由于刚开始训练时,模型的权重(weights)是随机初始化的，此时若选择一个较大的学习率,可能带来模型的不稳定(振荡)，选择Warmup预热学习率的方式，可以使得开始训练的几个epoches或者一些steps内学习率较小,在预热的小学习率下，模型可以慢慢趋于稳定,等模型相对稳定后再选择预先设置的学习率进行训练,使得模型收敛速度变得更快，模型效果更佳。

参考文献：

https://blog.csdn.net/Xiao_CangTian/article/details/109269555　https://blog.csdn.net/sinat_36618660/article/details/99650804　https://blog.csdn.net/shanglianlm/article/details/85143614　

https://blog.csdn.net/Guo_Python/article/details/106019396　https://zhuanlan.zhihu.com/p/136183319 　

②　lr_decay（学习率衰减）

　　在预热结束后，学习率达到一定的需求。此时，如果一直在大的学习率上执行训练，可能使模型loss持续震荡。因此，随着训练的进行，我们逐步降低学习率。

参考文献：

https://cloud.tencent.com/developer/article/1539729  

https://blog.csdn.net/qq_40367479/article/details/82530324 

https://blog.csdn.net/dou3516/article/details/105329103　

综合参考：

https://zhuanlan.zhihu.com/p/392350994　https://www.cnblogs.com/wuliytTaotao/p/11101652.html　

手动调节学习率：（需要将改变后的学习率手动更新到模型中）
EXAMPLE.1(该样例的实现包含了gradient_accumulate)
# 该函数的实现包括了warmup和lr_decay
def warmup_linear(x, warmup = 0.002):
    if x < warmup:
        return x/warmup
    return 1.0 - x

for epoch in range(start_epoch, total_train_epoch):
    train_loss = 0
    train_start = time.time()
    model.train()
    optimizer.zero_grad()
    for step, batch in enumerate(train_dataloader):
        create input and output for batch object_loss
        # loss regularization
        if gradient_accumulation_steps > 1:
            object_loss = object_loss / gradient_accumulation_steps

        # Implementation of backpropagation
        object_loss.backward()
        train_loss = train_loss + object_loss.item()
        if (step+1) % gradient_accumulation_steps == 0:
            # modifying and update the learning rate with warm up which bert uses.
            lr_this_step = learning_rate*warmup_linear(global_step_th/total_train_steps)
            # for the params in optimizer, we update the learning rate
            for param_group in optimizer.param_groups:
                param_group['lr'] = lr_this_step
            optimizer.step()
            optimizer.zero_grad()
            global_step_th = global_step_th + 1


EXAMPLE.2 Facebook提出的gradual warmup
import numpy as np
warmup_steps = 2500
init_lr = 0.1  
# 模拟训练15000步
max_steps = 15000
for train_steps in range(max_steps):
    # 实现warmup
　　　　if warmup_steps and train_steps < warmup_steps:
        warmup_percent_done = train_steps / warmup_steps
        warmup_learning_rate = init_lr * warmup_percent_done  #gradual warmup_lr
        learning_rate = warmup_learning_rate
    # 实现lr_decay
    else:
        #learning_rate = np.sin(learning_rate)  #预热学习率结束后,学习率呈sin衰减
        learning_rate = learning_rate**1.0001 #预热学习率结束后,学习率呈指数衰减(近似模拟指数衰减)

库函数调节：
常见的学习率调节库函数：
torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)
torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)
torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)
torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)
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)
torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)


EXAMPLE.1(该代码仅实现了lr_decay)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1) # 学习率初值0.1
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5) # 每十次迭代，学习率减半
for i in range(1,100):
    scheduler.step() # 学习率迭代次数+1
    arr.append(optimizer.state_dict()['param_groups'][0]['lr'])
    #arr.append(scheduler.get_lr())  # 与前一句功能相同，都是为了获取学习率的数值


EXAMPLE.2(该代码仅实现了lr_decay)
lambdaf = lambda epoch: 0.05 + (epoch) / 100
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lambdaf)
for i in range(1,100):
    scheduler.step()# 学习率迭代次数+1,同时将迭代次数作为参数传给lambdaf


EXAMPLE.3(该代码仅实现了warmup)
def warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor):
    def f(x): # x是step次数
        if x >= warmup_iters:
            return 1
        alpha = float(x) / warmup_iters # 当前进度 0-1
        return warmup_factor * (1 - alpha) + alpha
    return torch.optim.lr_scheduler.LambdaLR(optimizer, f)

if warmup:
    warmup_factor = 1. / 1000
    warmup_iters = min(1000, len(train_loader) - 1)
    lr_scheduler = warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor)
for i in range(1,100):
    lr_scheduler.step() #将学习率迭代次数+1传给f


EXAMPLE.4(该代码实现warmup和lr_decay)
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9, weight_decay=5e-4)
warmup_epoch = 5
scheduler = CosineAnnealingLR(optimizer, 100 - warmup_epoch)
warmup_scheduler = WarmUpLR(optimizer, iter_per_epoch * warmup_epoch)
for epoch in range(1, max_epoch+1):
        # lr_decay过程
        if epoch >= warmup_epoch:
            scheduler.step()
            learn_rate = scheduler.get_lr()[0]
            print("Learn_rate:%s" % learn_rate)
	# warmup过程
　　　　　　　　else:
            warmup_scheduler.step()
            warm_lr = warmup_scheduler.get_lr()
            print("warm_lr:%s" % warm_lr)


EXAMPLE.5(transformers.get_linear_schedule_with_warmup(),实现学习率预热和学习率下降)
total_steps = len(train_dataloader) * num_epoch
optimizer = AdamW(optimizer_grouped_parameters, lr=3e-5, eps=1e-8)
lr_scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps= warmup_rate* total_steps, num_training_steps = total_steps)
for __ in trange(num_epoch, desc = 'Epoch'):
    model.train()
    total_loss = 0
    for batch_iter, batch_dataloader in enumerate(train_dataloader):
        ......
        loss = outputs.loss
        loss.backward()
        total_loss = total_loss + loss.cpu().item() # item() return the value of tensor
        # update the parameters
        optimizer.step()
        # update the learning rate
        lr_scheduler.step()

注：我们最常用到的学习率衰减库函数：

lr_decay = torch.optim.lr_scheduler.ReduceLROnPlateau()　（学习率衰减方法之一）

解释：这是个类class，初始化函数包含了诸多参数。这里我们只对重点参数进行介绍：

　　　factor是学习率变换时乘的因子；

　　　patience是指，当连续patience个epoch而指标(loss或accuracy)没有变换时，我们对学习率进行更改；

　　　threshold指，当性能变化小于该值时，即认为没有性能变化；

　　　min_lr模型所允许的最小学习率，即学习率不能小于该值；

　　　eps，学习率变化的最小值。当学习率变化小于该值时，忽略掉；

　　　lr_decay.step(val_loss/accuracy)，学习率更新的指标依据。当某指标loss(或accuracy)在最近几个epoch中都没有变化下降（或升高）超过给定阈值时，调整学习率。如当验证集的loss不再下降时，调整学习率；或监测验证集的accuracy不再升高时，调整学习率。

参考文献：

https://blog.csdn.net/weixin_40100431/article/details/84311430　https://zhuanlan.zhihu.com/p/69411064

https://www.jianshu.com/p/26a7dbc15246 

https://www.cnblogs.com/xym4869/p/11654611.html　　https://blog.csdn.net/qyhaill/article/details/103043637　https://blog.csdn.net/emperinter/article/details/108917935　

https://www.emperinter.info/2020/08/05/change-leaning-rate-by-reducelronplateau-in-pytorch/　

（三）optimizer.zero_grad()

　　当网络参量进行反馈时，梯度是累积计算而不是被替换，但在处理每一个batch时并不需要与其他batch的梯度混合起来累积计算，因此需要对每个batch调用一遍optimizer.zero_grad()将优化器中的参数梯度置0。之后执行loss.backward()来反向传播计算梯度，最后使用optimizer.step()来更新优化器选中的参数梯度。

# 将参数(权值)梯度全部置为０
optimizer.zero_grad()
# 通过输入，计算模型的输出
outputs = net(inputs)
# 计算损失
loss = criterion(outputs, labels)
# 通过损失，反向传播计算权值梯度
loss.backward()
# 更新权值
optimizer.step()

参考文献：

https://www.lagou.com/lgeduarticle/74225.html　

http://www.manongjc.com/detail/24-qbflaryxurlerde.html　https://blog.csdn.net/PanYHHH/article/details/107361827　

（四）optimizer和scheduler

　　optimizer的作用在于根据选用的优化器以及设置相应的lr、momentum等(超参数)对模型参数(优化器中的参数)进行更新，更新的方法是optimizer.step()。

　　scheduler的作用在于对optimizer中的学习率进行更新、调整，更新的方法是scheduler.step()。

　　通常而言，在一个batch_size内先进行optimizer.step()完成权重参数的更新过程，然后再进行scheduler.step()完成对学习率参数的更新过程。

　　注：scheduler.step()函数用来完成optimizer实例中学习率的更新，如果没有scheduler中的step方法，也就无法对optimizer中的学习率进行调整 。

参考文献：

https://zhuanlan.zhihu.com/p/367999849　https://blog.csdn.net/qq_40178291/article/details/99963586　https://www.jianshu.com/p/1db8581edd4f　

这里有个resume optimizer学习率的样例不错：https://zhuanlan.zhihu.com/p/136902153　

（五）梯度下降和反向传播：

　　梯度下降是一种比较泛化的优化方法，中心思想是沿着目标函数梯度（导数）的反方向更新和寻找参数值（权值和偏置）以使得目标函数最大或者最小。梯度下降法是深度学习网络最常见的优化方法，除了深度学习，其还有很多的应用场景。

　　在神经网络中，对深度网络目标函数计算梯度的时候，需要用到反向传播的方式由深到浅地（从输出层开始将误差逐层反向传播到输入端神经元）计算及更新参数（链式法则）。因此，反向传播是梯度下降方法在深度网络上的具体实现形式。

　　总的来说，梯度下降是寻找目标函数最优值的方法，反向传播是链式求解梯度的方法。

参考文献：

https://blog.csdn.net/crxk_/article/details/97137789　

https://www.zhihu.com/question/311616761　

https://zhuanlan.zhihu.com/p/248091369　

https://www.jianshu.com/p/77858847d6f7