深度学习训练过程中的学习率衰减策略及pytorch实现

学习率是深度学习中的一个重要超参数,选择合适的学习率能够帮助模型更好地收敛。

本文主要介绍深度学习训练过程中的14种学习率衰减策略以及相应的Pytorch实现。

1. StepLR

  • 按固定的训练epoch数进行学习率衰减。
  • 举例说明:

# lr = 0.05 if epoch < 30

# lr = 0.005 if 30 <= epoch < 60

# lr = 0.0005 if 60 <= epoch < 90

在上述例子中,每30个epochs衰减十倍学习率。

  • 计算公式和pytorch计算代码如下:

def _get_closed_form_lr(self): return [base_lr * self.gamma ** (self.last_epoch // self.step_size) for base_lr in self.base_lrs]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=- 1, verbose=False)

optimizer:表示使用的优化器;
step_size:表示学习率调整步长;
gamma:表示学习率衰减乘法因子,默认:0.1;
last_epoch:表示上一个epoch数,默认:-1,此时学习率的值为初始学习率;
verbose:表示是否每次更新都输出一次学习率的值,默认:False。

  • 代码示例及结果展示:
lr_scheduler=torch.optim.lr_scheduler.StepLR(optimizer,step_size=3,gamma=0.1,last_epoch=-1)

设置10个epoch时,输出训练过程中的学习率如下:

  

2. MultiStepLR

  • 当epoch数达到固定数值进行学习率衰减。
  • 举例说明:

# milestones=[30,80]

# lr = 0.05 if epoch < 30

# lr = 0.005 if 30 <= epoch < 80

# lr = 0.0005 if epoch >= 80 

在上述例子中,当epoch达到milestones中的数值时进行学习率衰减。

  • 计算公式和pytorch计算代码如下:

 

其中bisect_right函数表示epoch数插入milestones中列表的位置,

例如:milstones=[2,5,8]

last_epoch==1→bisect_right(milestones,last_epoch)=0;

last_epoch==3→bisect_right(milestones,last_epoch)=1;

last_epoch==6→bisect_right(milestones,last_epoch)=2;

def _get_closed_form_lr(self): milestones = list(sorted(self.milestones.elements())) return [base_lr * self.gamma ** bisect_right(milestones, self.last_epoch) for base_lr in self.base_lrs]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=- 1, verbose=False)

milestones:一个关于epoch索引的列表,当epoch值达到列表中的数值时进行学习率衰减。

其他参数相同。

  • 代码示例及结果展示:
lr_scheduler=torch.optim.lr_scheduler.MultiStepLR(optimizer,milestones=[2,5,8],gamma=0.1,last_epoch=-1)

3. ExponentialLR

  • 根据当前epoch进行学习率衰减
  • 计算公式和pytorch计算代码如下:

def _get_closed_form_lr(self): return [base_lr * self.gamma ** self.last_epoch for base_lr in self.base_lrs]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=- 1, verbose=False) 

  • 代码示例及结果展示:
lr_scheduler=torch.optim.lr_scheduler.ExponentialLR(optimizer,gamma=0.1,last_epoch=-1)



4. linearLR

  • 在epoch数达到total_iters数值之前,使用线性改变乘法因子衰减学习率。
  • 计算公式和pytorch计算代码如下:

def _get_closed_form_lr(self): return [base_lr * (self.start_factor + (self.end_factor - self.start_factor) * min(self.total_iters, self.last_epoch) / self.total_iters) for base_lr in self.base_lrs]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.3333333333333333, end_factor=1.0, total_iters=5, last_epoch=- 1, verbose=False)

start_factor: 在第一个epoch中乘以base_lr的数值,默认1/3;
end_factor:在线性变化过程结束时乘以base_lr的数值,默认:1;
total_iters:乘法因子达到1的迭代次数,默认:5。
  • 举例说明:
lr_scheduler = LinearLR(optimizer, start_factor=0.5, total_iters=4)
base_lr=0.05
# epoch == 0→lr = base_lr * start_factor = 0.05 * 0.5=0.025;
# epoch == 1→lr = 0.05 * (0.5 + 0.5 * 0.25) = 0.3125;
......
# epoch ≥ 4→lr = base_lr * end_factor = 0.05(当epoch数等于total_iters时,
min(self.total_iters, self.last_epoch) / self.total_iters = 1)

5. ConstantLR

  • 在epoch数达到total_iters数值之前,使用常数因子衰减学习率。
  • 计算公式和pytorch计算代码如下:

    def _get_closed_form_lr(self): return [base_lr * (self.factor + (self.last_epoch >= self.total_iters) * (1 - self.factor)) for base_lr in self.base_lrs]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.ConstantLR(optimizer, factor=0.3333333333333333, total_iters=5, last_epoch=- 1, verbose=False)

 factor:在epoch达到total_iters之前,学习率乘以的常数因子,默认1/3;

 total_iters:衰减学习率的步数。

  • 举例说明:

lr_scheduler = ConstantLR(self.opt, factor=0.5, total_iters=4)

base_lr = 0.05

# epoch == 0 → lr = base_lr * (factor + 0 * (1-factor)) = 0.05 *  0.5 = 0.025

……

# epoch == 4 → lr = base_lr * (factor + 1 – factor) = 0.05 

6. LambdaLR

  • 使用lambda定义的函数衰减学习率。
  • 计算公式和pytorch计算代码如下:

 

    def get_lr(self): if not self._get_lr_called_within_step: warnings.warn("To get the last learning rate computed by the scheduler, "
                          "please use `get_last_lr()`.") return [base_lr * lmbda(self.last_epoch) for lmbda, base_lr in zip(self.lr_lambdas, self.base_lrs)]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=- 1, verbose=False)

lr_lambda:当给定epoch数,计算乘法因子的函数(可以自己定义)

  • 代码示例及结果展示:
lr_scheduler=torch.optim.lr_scheduler.LambdaLR(optimizer,lr_lambda=lambda epoch:epoch/30 )

 

 

7. MultiplicativeLR

  • 同样是使用了与epoch有关的lambda函数,与LambdaLR不同的地方在于,它是对old_lr更新。
  • 计算公式和pytorch计算代码如下:

def get_lr(self): if not self._get_lr_called_within_step: warnings.warn("To get the last learning rate computed by the scheduler, "
                          "please use `get_last_lr()`.", UserWarning) if self.last_epoch > 0: return [group['lr'] * lmbda(self.last_epoch) for lmbda, group in zip(self.lr_lambdas, self.optimizer.param_groups)] else: return [group['lr'] for group in self.optimizer.param_groups]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.MultiplicativeLR(optimizer, lr_lambda, last_epoch=- 1, verbose=False)

 

8. CosineAnnealingLR

  • 模拟余弦退火曲线调整学习率
  • 计算公式和pytorch计算代码如下:

 

def _get_closed_form_lr(self): return [self.eta_min + (base_lr - self.eta_min) * (1 + math.cos(math.pi * self.last_epoch / self.T_max)) / 2
                for base_lr in self.base_lrs]

  • pytorch调用及相关参数:
torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=- 1, verbose=False)

T_max:最大迭代次数,一次学习率周期的迭代次数。

eta_min:最小学习率,默认:0。

  • 代码示例及结果展示:
lr_scheduler=torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,T_max=3,eta_min=0)

base_lr=0.01

当epoch是T_max的奇数倍时,学习率会下降到最小值eta_min。

 

9. ChainedScheduler

  • 可以调用其他学习率调整策略。
  • pytorch调用及相关参数:
torch.optim.lr_scheduler.ChainedScheduler(schedulers)

schedules:设置的其他学习率调整策略,可以是一个包含多个学习率调整策略的列表

  • 代码示例及结果:
scheduler1 = ConstantLR(self.opt, factor=0.1, total_iters=2) scheduler2 = ExponentialLR(self.opt, gamma=0.9) lr_scheduler = ChainedScheduler([scheduler1, scheduler2])

schedules里的学习率调整策略同时使用

base_lr = 1

# lr = 0.09 if epoch == 0 (先使用scheduler2策略得到lr = 0.9;再使用scheduler1策略得到最终new_lr = 0.09)

# lr = 0.081 if epoch == 1

# lr = 0.729 if epoch == 2

# lr = 0.6561 if epoch == 3

# lr = 0.59049 if epoch >= 4

10.SequentialLR

  • 与ChainedScheduler在每一个epoch中同时调用schedules中的学习率策略不同的是,SequentialLR针对epoch按顺序调用schedules中的学习率策略。
  • pytorch调用及相关参数:
torch.optim.lr_scheduler.SequentialLR(optimizer, schedulers, milestones, last_epoch=- 1, verbose=False)

  • 代码示例及结果:
scheduler1 = ConstantLR(self.opt, factor=0.1, total_iters=2) scheduler2 = ExponentialLR(self.opt, gamma=0.9) lr_scheduler = SequentialLR(optimizer, schedulers=[scheduler1, scheduler2], milestones=[2])

base_lr = 1

# lr = 0.1 if epoch == 0

# lr = 0.1 if epoch == 1

# lr = 0.9 if epoch == 2

# lr = 0.81 if epoch == 3

# lr = 0.729 if epoch == 4

epoch<milestones,调用scheduler1学习率调整策略,epoch≥milestones,调用scheduler2学习率调整策略。

 

11.ReduceLROnPlateau

  • 当训练指标不再改进时,调整学习率。
  • pytorch调用及相关参数:
torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08, verbose=False)

mode:有min、max两种模式,在 min 模式下,当指标的数量停止减少时(如loss),学习率将减少; 在max模式下,当指标的数量停止增加时(如accuracy),学习率将减少,默认值:min;

factor:学习率减少的倍数,new_lr = old_lr * factor,默认:0.1;

patience:指标没有提升的epoch数,之后降低学习率。例如,patience = 2,会忽略前 2 个没有改善的 epoch,并且只有在第 3 个 epoch 之后指标仍然没有改善的情况下降低 学习率。 默认值:10。

threshold:衡量新的最佳阈值,只关注重大变化。 默认值:1e-4。

threshold_mode:有rel、abs两种模式,

cooldown:在 学习率减少后恢复正常操作之前要等待的 epoch 数。 默认值:0。

min_lr:标量或标量列表。学习率的下限。 默认值:0。

eps:应用于 学习率的最小衰减。 如果新旧 学习率之间的差异小于 eps,则忽略更新。 默认值:1e-8。

  • 代码示例及结果:
lr_scheduler=torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,mode='min',patience=2,cooldown=2)

 

第一个epoch是初始学习率;

设置patience = 2,即指标在经历3个epoch后仍然没有提升,衰减学习率,new_lr = old_lr * factor(0.1),如图中第4个epoch时开始衰减学习率;

设置cooldown = 2,即衰减学习率后有2个epoch的cooldown时期(5、6epoch),在cooldown时期不进行patience阶段的epoch计数;

cooldown时期结束恢复patience阶段epoch计数(图中从第7个epoch开始计数,在第10个epoch学习率衰减)。

 

12.CyclicLR

  • 根据循环学习策略设置学习率。(每训练一个batch,更新一次学习率)
  • 在《 Cyclical Learning Rates for Training Neural Networks》这篇文章中有详细描述。
  • pytorch调用及相关参数:
torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=2000, step_size_down=None, mode='triangular', gamma=1.0, scale_fn=None, scale_mode='cycle', cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=- 1, verbose=False)

base_lr:初始学习率,循环中的学习率下边界;

max_lr:每个参数组在循环中的上层学习率边界。从功能上讲,它定义了周期幅度 (max_lr – base_lr)。任何周期的 lr 是 base_lr 和一些幅度缩放的总和;因此 max_lr 实际上可能无法达到,具体取决于缩放函数。

step_size_up:在一个周期增加的一半中训练迭代的次数。默认值:2000;

step_size_down:循环减半中的训练迭代次数。如果 step_size_down 为 None,则设置为 step_size_up。默认值:None;

mode:包含三种{triangular, triangular2, exp_range} ,如果 scale_fn 不是 None,则忽略此参数。默认值:“triangular”;

gamma:‘exp_range’ 缩放函数中的常数:gamma**(cycle iterations)默认值:1.0;

scale_fn:由单个参数 lambda 函数定义的自定义缩放策略,其中 0 <= scale_fn(x) <= 1 for all x >= 0。如果指定,则忽略“mode”。默认值:None;

scale_mode:{‘cycle’, ‘iterations’}。定义是否在cycle number或cycle iterations (training iterations since start of cycle)上评估 scale_fn。默认值:cycle;

cycle_momentum:如果为真,则动量与“base_momentum”和“max_momentum”之间的学习率成反比。默认值:True;

base_momentum: 循环中的动量下边界,默认值:0.8;

max_monmentum:循环中的动量上边界,默认值:0.9;

  • 官方代码及示例:
 optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.01, max_lr=0.1) data_loader = torch.utils.data.DataLoader(...)  for epoch in range(10):     for batch in data_loader:  train_batch(...)          scheduler.step()

 

13.OneCycleLR

  • 根据循环学习策略设置学习率。(每训练一个batch,更新一次学习率)
  • 相关文章《Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates》
  • pytorch调用及相关参数:
torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr, total_steps=None, epochs=None, steps_per_epoch=None, pct_start=0.3, anneal_strategy='cos', cycle_momentum=True, base_momentum=0.85, max_momentum=0.95, div_factor=25.0, final_div_factor=10000.0, three_phase=False, last_epoch=- 1, verbose=False)

max_lr:在循环中的上层学习率边界;

total_steps:循环总步数。如果此处未提供值,则必须通过提供 epochs 和 steps_per_epoch 的值来推断。默认值:None;

epochs:训练的epochs;

steps_per_epoch:每个 epoch 训练的步数;

pct_start:提高学习率所花费的周期百分比(in number of steps)。默认值:0.3;

anneal_strategy:{‘cos’, ‘linear’} 指定退火策略:“cos”表示余弦退火,“linear”表示线性退火。默认值:’cos’;

div_factor:通过 initial_lr = max_lr/div_factor 确定初始学习率 默认值:25;

final_div_factor:通过 min_lr = initial_lr/final_div_factor 确定最小学习率 默认值:1e4;

three_phase:如果为 True,则使用计划的第三阶段根据“final_div_factor”消除学习率,而不是修改第二阶段(前两个阶段将关于“pct_start”指示的步骤对称)。

  • 官方代码及示例:
 data_loader = torch.utils.data.DataLoader(...) optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.01, steps_per_epoch=len(data_loader), epochs=10) for epoch in range(10): for batch in data_loader: train_batch(...) scheduler.step() 

 

14.CosineAnnealingWarmRestarts

  • 和余弦退火类似,多了warmrestart操作。
  • pytorch调用及相关参数:
torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0, T_mult=1, eta_min=0, last_epoch=- 1, verbose=False)

T_0:第一次restart的迭代次数;

T_mult:在一次restar后,因子增加:math:`T_{i};

eta_min:最小学习率,默认值:0。

  • 官方代码及示例
 scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult) iters = len(dataloader) for epoch in range(20): for i, sample in enumerate(dataloader): inputs, labels = sample['inputs'], sample['labels'] optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() scheduler.step(epoch + i / iters)

 

参考及引用:

1.https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate

2.https://zhuanlan.zhihu.com/p/352744991

3.https://blog.csdn.net/qyhaill/article/details/103043637

 

页面下部广告