---

  适合的学习率能够更好地训练模型，为此衍生出多种学习率调整策略。一般来说，在训练初期希望学习率大一些，使得网络收敛迅速，在训练后期希望学习率小一些，使得网络更好的收敛到最优解。在torch.optim.lr_scheduler包下提供了大量的学习率调整模块，如StepLR、MultiStepLR、ExponentialLR、CosineAnnealingLR。对学习率的更新由学习率更新对象执行step()完整，多数情况下，每一个epoch后都会进行学习率的更新，框架如下：

scheduler = ...
for epoch in range(100):
	train(...)
	validate(...)
	scheduler.step()

前置代码如下，学习率设为0.1：

import torch
import numpy as np
from torch.optim import SGD
from torch.optim import lr_scheduler
from torch.nn.parameter import Parameter

model = [Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, lr=0.1)

1.StepLR

  StepLR（固定步长衰减）策略，每过step_size轮，将学习率乘以gamma。

lr_scheduler.StepLR(optimizer,step_size,gamma,last_epoch=-1)

【例子】

scheduler=lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)

2.MultiStepLR

  MultiStepLR（多步长衰减）策略，StepLR（固定步长衰减）策略只能按照固定的区间步长更新学习率，而MultiStepLR（多步长衰减）策略可定义动态区间以更新学习率。

lr_scheduler.MultiStepLR(optimizer,milestones,gamma,last_epoch=-1)

【例子】

scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[30,80], gamma=0.5)

• milestones=[30,80]：在30、80轮时更新学习率（乘以gamma），其他轮次不更新。

3.ExponentialLR

  ExponentialLR（指数衰减）策略，每一轮都会将学习率乘以gamma，等价于：
$$lr=lr\ast gamm{a}^{epoch}$$

lr_scheduler.ExponentialLR(optimizer,milestones,gamma,last_epoch=-1)

【例子】

scheduler=lr_scheduler.ExponentialLR(optimizer, gamma=0.95) 

4.LinearLR

  LinearLR（线性衰减）策略，给定学习率的初始值、最终值（最终值需指定最后更新时的轮次），LinearLR策略会在中间阶段做线性插值，自动选择更新轮次进行更新。

scheduler=lr_scheduler.LinearLR(optimizer,start_factor=1,end_factor=0.1,total_iters=80)

5.PloyLR

  PloyLR策略是自定义的学习率调整策略，计算方式如下：

有如下优点：

• 1.更好的泛化能力：Poly学习率调整策略可以在训练后期逐渐降低学习率，避免过拟合，提高模型的泛化能力。
• 2.对超参数不敏感：Poly学习率调整策略的性能不太受超参数的影响，相对比较稳定。
• 3.计算量较小：Poly学习率调整策略的计算量相对较小，不会影响训练速度。

缺点包括：

• 1.收敛速度较慢：Poly学习率调整策略在训练初期学习率较低，收敛速度较慢。
• 2.不适用于所有模型：Poly学习率调整策略可能不适用于所有类型的模型，需要根据具体情况进行选择。

from torch.optim.lr_scheduler import _LRScheduler, StepLR

class PolyLR(_LRScheduler):
    def __init__(self, optimizer, max_iters, power=0.9, last_epoch=-1, min_lr=1e-6):
        self.power = power
        self.max_iters = max_iters  # avoid zero lr
        self.min_lr = min_lr
        super(PolyLR, self).__init__(optimizer, last_epoch)
    
    def get_lr(self):
        return [ max( base_lr * ( 1 - self.last_epoch/self.max_iters )**self.power, self.min_lr)
                for base_lr in self.base_lrs]

【例子】

LR = 0.1        
iteration = 50
max_epoch = 1000 
weights = torch.randn((1), requires_grad=True)
target = torch.zeros((1))
optimizer = SGD([weights], lr=LR, momentum=0.9)

# flag = 0
flag = 1
if flag:
    scheduler_lr = PolyLR(optimizer, 1000, power=0.9) 
    lr_list, epoch_list = list(), list()
    for epoch in range(max_epoch):
        lr_list.append(scheduler_lr.get_lr())
        epoch_list.append(epoch)
        for i in range(iteration):
            loss = torch.pow((weights - target), 2)
            loss.backward()
            optimizer.step()
            optimizer.zero_grad()
        scheduler_lr.step()

    plt.plot(epoch_list, lr_list, label="Poly LR Scheduler")
    plt.xlabel("Epoch")
    plt.ylabel("Learning rate")
    plt.legend()
    plt.show()