pytorch学习率下降策略

谁践踏了优雅 2023-01-10 01:26 505阅读 0赞

# 阶段离散下降调整策略： #

**首先“阶段离散”下降调整这个词不是个专有名词，它只是一个形容。**  
符合这种调整策略的方法，一般是step，step学习率下降策略是最为常用的一种，表现为，在初始学习率的基础上，每到一个阶段学习率将以gamma的指数倍下降，通常情况下gamma为0.1。显然随着训练迭代学习率会变的越来越小，但是不管怎么变，这个数都在趋近于0，永远不会到0.  
效果类似于：

# lr = 0.05     if epoch < 30        
    # lr = 0.005    if 30 <= epoch < 60        
    # lr = 0.0005   if 60 <= epoch < 90

pytorch中定义了两种方法做这件事，分别是[等间隔调整][Link 1]学习率(Step)，[按需调整][Link 2]学习率(MultiStep)，实际上它们的效果是一致的

## 等间隔下降调整策略 ##

等间隔的调整是在定义间隔是什么，即step\_size，当训练的epoch满足step\_size时，学习率就调整一次，last\_epoch对step\_size取整。

class StepLR(_LRScheduler):
        def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1, verbose=False):
            self.step_size = step_size
            self.gamma = gamma
            super(StepLR, self).__init__(optimizer, last_epoch, verbose)
    
        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) or (self.last_epoch % self.step_size != 0):
                return [group['lr'] for group in self.optimizer.param_groups]
            return [group['lr'] * self.gamma
                    for group in self.optimizer.param_groups]
    
        def _get_closed_form_lr(self):
            return [base_lr * self.gamma ** (self.last_epoch // self.step_size)
                    for base_lr in self.base_lrs]

## 按需下降调整策略 ##

按需调整学习率是在直接定义目标是什么，训练中，当前的epoch达到目标的时候，学习率调整，milestones就是定义的一系列目标，当last\_epoch不在milestones中时，学习率保持不变，相反的，则gamma的指数倍调整，当然gamma是个小数，所以学习率越来越小。

class MultiStepLR(_LRScheduler):
        def __init__(self, optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False):
            self.milestones = Counter(milestones)
            self.gamma = gamma
            super(MultiStepLR, self).__init__(optimizer, last_epoch, verbose)
    
        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 not in self.milestones:
                return [group['lr'] for group in self.optimizer.param_groups]
            return [group['lr'] * self.gamma ** self.milestones[self.last_epoch]
                    for group in self.optimizer.param_groups]
    
        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]

# 连续下降调整策略： #

**“连续”下降这个词不是个专有名词，它只是一个形容。**  
符合这种下降策略的方法有，线性下降策略，cos下降策略，指数衰减下降策略，前两种在Pytorch没有实现。它们的表现是，随着训练迭代，学习率的变化时逐步减少的，不会出现step方式的阶段下降，并且到迭代结束时，学习率为0，而不是一个非常小的值。

## 线性下降调整策略 ##

线性下降策略非常好理解，就是学习率与迭代周期是线性关系，初始学习率和周期确定了，下降的斜率也就确定了。

lr = args.lr * (1 - (current_iter - warmup_iter) / (max_iter - warmup_iter))

## cos下降调整策略 ##

cos下降策略到最后一步迭代的最后时，系数刚好为cos(pi/2)，即为0，开始迭代时系数为为cos(0)，即为1，中间遵循余弦曲线的方式下降。

lr = args.lr * (1 + cos(pi * (current_iter - warmup_iter) / (max_iter - warmup_iter))) / 2

## 指数衰减调整策略 ##

指数衰减调整策略的计算方式和step是一样的，都是当前的epoch作为指数， gamma作为底数，即gamma\*\*epoch。不同之处在于，指数衰减下降策略是每个epoch都会做的，可以看做在epoch间连续，其次，更为重要的是，选择指数衰减下降策略时gamma不能选择为0.1，否则几个epoch过去，学习率就非常趋近于0了，所以一般是0.9。

class ExponentialLR(_LRScheduler):
        def __init__(self, optimizer, gamma, last_epoch=-1, verbose=False):
            self.gamma = gamma
            super(ExponentialLR, self).__init__(optimizer, last_epoch, verbose)
    
        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 self.base_lrs
            return [group['lr'] * self.gamma
                    for group in self.optimizer.param_groups]
    
        def _get_closed_form_lr(self):
            return [base_lr * self.gamma ** self.last_epoch
                    for base_lr in self.base_lrs]

# 周期性调整策略： #

周期性调整的特点是不再从始至终单调的下降，而是会出现上升的情况。

## 余弦退火调整策略 ##

以余弦函数为周期，并在每个周期最大值时重新设置学习率。以初始学习率为最大学习率，以 2∗Tmax 为周期，在一个周期内先下降，后上升。

class CosineAnnealingLR(_LRScheduler):
    	def __init__(self, optimizer, T_max, eta_min=0, last_epoch=-1, verbose=False):
            self.T_max = T_max
            self.eta_min = eta_min
            super(CosineAnnealingLR, self).__init__(optimizer, last_epoch, verbose)
    
        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 self.base_lrs
            elif (self.last_epoch - 1 - self.T_max) % (2 * self.T_max) == 0:
                return [group['lr'] + (base_lr - self.eta_min) *
                        (1 - math.cos(math.pi / self.T_max)) / 2
                        for base_lr, group in
                        zip(self.base_lrs, self.optimizer.param_groups)]
            return [(1 + math.cos(math.pi * self.last_epoch / self.T_max)) /
                    (1 + math.cos(math.pi * (self.last_epoch - 1) / self.T_max)) *
                    (group['lr'] - self.eta_min) + self.eta_min
                    for group in self.optimizer.param_groups]
    
        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]

## 循环调整策略 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoYWlwcDA2MDc_size_16_color_FFFFFF_t_70]  
循环调整顾名思义，就是以一个周期和一个上下界反复调整学习率，这个方法出自《Cyclical Learning Rates for Training Neural Networks》，这么做的理由是要避免模型进入局部最优的状态，也就是鞍点(saddle points)。而循环学习率方法使得一个范围（base\_lr ~ max\_lr）里的学习率在训练中都能得到运用，也就是说，在下边界和上边界中，那个最佳的学习率将会在训练中有机会运用到训练中。

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)

# 自适应调整策略： #

顾名思义，之前的调整策略都是在出初始学习率和训练周期固定好之后就确定下来的规则，不会根据训练状态的变化而变化，自适应的调整则不同，依训练状况伺机调整，该法通过监测某一指标的变化情况，当该指标不再怎么变化的时候，就是调整学习率的时机。

## ReduceLROnPlateau ##

ReduceLROnPlateau的名字很直观，就是在持续平稳的状态时下降学习率，当某指标不再变化（下降或升高），则调整学习率，这是非常实用的学习率调整策略。例如，当验证集的 loss 不再下降时，进行学习率调整；或者监测验证集的 accuracy，当accuracy 不再上升时，则调整学习率。

class ReduceLROnPlateau(object):
        def __init__(self, optimizer, mode='min', factor=0.1, patience=10,
                     threshold=1e-4, threshold_mode='rel', cooldown=0,
                     min_lr=0, eps=1e-8, verbose=False):
    
            if factor >= 1.0:
                raise ValueError('Factor should be < 1.0.')
            self.factor = factor
    
            # Attach optimizer
            if not isinstance(optimizer, Optimizer):
                raise TypeError('{} is not an Optimizer'.format(
                    type(optimizer).__name__))
            self.optimizer = optimizer
    
            if isinstance(min_lr, list) or isinstance(min_lr, tuple):
                if len(min_lr) != len(optimizer.param_groups):
                    raise ValueError("expected {} min_lrs, got {}".format(
                        len(optimizer.param_groups), len(min_lr)))
                self.min_lrs = list(min_lr)
            else:
                self.min_lrs = [min_lr] * len(optimizer.param_groups)
    
            self.patience = patience
            self.verbose = verbose
            self.cooldown = cooldown
            self.cooldown_counter = 0
            self.mode = mode
            self.threshold = threshold
            self.threshold_mode = threshold_mode
            self.best = None
            self.num_bad_epochs = None
            self.mode_worse = None  # the worse value for the chosen mode
            self.eps = eps
            self.last_epoch = 0
            self._init_is_better(mode=mode, threshold=threshold,
                                 threshold_mode=threshold_mode)
            self._reset()
    
        def _reset(self):
            """Resets num_bad_epochs counter and cooldown counter."""
            self.best = self.mode_worse
            self.cooldown_counter = 0
            self.num_bad_epochs = 0
    
        def step(self, metrics, epoch=None):
            # convert `metrics` to float, in case it's a zero-dim Tensor
            current = float(metrics)
            if epoch is None:
                epoch = self.last_epoch + 1
            else:
                warnings.warn(EPOCH_DEPRECATION_WARNING, UserWarning)
            self.last_epoch = epoch
    
            if self.is_better(current, self.best):
                self.best = current
                self.num_bad_epochs = 0
            else:
                self.num_bad_epochs += 1
    
            if self.in_cooldown:
                self.cooldown_counter -= 1
                self.num_bad_epochs = 0  # ignore any bad epochs in cooldown
    
            if self.num_bad_epochs > self.patience:
                self._reduce_lr(epoch)
                self.cooldown_counter = self.cooldown
                self.num_bad_epochs = 0
    
            self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
    
        def _reduce_lr(self, epoch):
            for i, param_group in enumerate(self.optimizer.param_groups):
                old_lr = float(param_group['lr'])
                new_lr = max(old_lr * self.factor, self.min_lrs[i])
                if old_lr - new_lr > self.eps:
                    param_group['lr'] = new_lr
                    if self.verbose:
                        print('Epoch {:5d}: reducing learning rate'
                              ' of group {} to {:.4e}.'.format(epoch, i, new_lr))
    
        @property
        def in_cooldown(self):
            return self.cooldown_counter > 0
    
        def is_better(self, a, best):
            if self.mode == 'min' and self.threshold_mode == 'rel':
                rel_epsilon = 1. - self.threshold
                return a < best * rel_epsilon
    
            elif self.mode == 'min' and self.threshold_mode == 'abs':
                return a < best - self.threshold
    
            elif self.mode == 'max' and self.threshold_mode == 'rel':
                rel_epsilon = self.threshold + 1.
                return a > best * rel_epsilon
    
            else:  # mode == 'max' and epsilon_mode == 'abs':
                return a > best + self.threshold
    
        def _init_is_better(self, mode, threshold, threshold_mode):
            if mode not in {
        'min', 'max'}:
                raise ValueError('mode ' + mode + ' is unknown!')
            if threshold_mode not in {
        'rel', 'abs'}:
                raise ValueError('threshold mode ' + threshold_mode + ' is unknown!')
    
            if mode == 'min':
                self.mode_worse = inf
            else:  # mode == 'max':
                self.mode_worse = -inf
    
            self.mode = mode
            self.threshold = threshold
            self.threshold_mode = threshold_mode
    
        def state_dict(self):
            return {
        key: value for key, value in self.__dict__.items() if key != 'optimizer'}
    
        def load_state_dict(self, state_dict):
            self.__dict__.update(state_dict)
            self._init_is_better(mode=self.mode, threshold=self.threshold, threshold_mode=self.threshold_mode)

# 自定义调整策略： #

## LambdaLR ##

LambdaLR可以为不同参数组设定不同学习率调整策略。

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

与其他调整规则的区别在于，optimizer和lr\_lambda可以是list，对应之后，相应的参数就会根据对应规则调整

[Link 1]: https://github.com/pytorch/pytorch/blob/e6779d4357ae94cc9f9fedb83a87eb6126016769/torch/optim/lr_scheduler.py#L334
[Link 2]: https://github.com/pytorch/pytorch/blob/e6779d4357ae94cc9f9fedb83a87eb6126016769/torch/optim/lr_scheduler.py#L382
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoYWlwcDA2MDc_size_16_color_FFFFFF_t_70]: /images/20221119/a1549205da4f4840b7922858261f0ee7.png