DeepLearning - 余弦退火热重启学习率 CosineAnnealingWarmRestartsLR

这篇具有很好参考价值的文章主要介绍了DeepLearning - 余弦退火热重启学习率 CosineAnnealingWarmRestartsLR。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

欢迎关注我的CSDN:https://spike.blog.csdn.net/
本文地址:https://spike.blog.csdn.net/article/details/134249925

CosineAnnealingWarmRestartsLR,即 余弦退火热重启学习率,周期性修改学习率的下降和上升,间隔幅度逐渐增大,避免模型的性能抖动。其中核心参数:

  • optimizer 的参数,lr 学习率,默认学习率是 lr * GPU 数量,例如 lr 设置成 0.00001,32卡实际是 0.00032。
  • T_0,衰减的 global step 数,即单卡的运行次数,根据运行时间确定,例如 step 是 28.5 秒一次,(28.5 * 2000) / 3600 = 15.8 小时。
  • T_mult,周期间隔,逐渐加大,例如 T_mult 是 2,则表示,第n次是 T 0 ∗ T m u l t n T_0*T_{mult}^{n} T0Tmultn 步。
  • eta_min,从 LR 衰减的最小步数,可以设置成0。

源码:

optimizer = deepspeed.ops.adam.FusedAdam(self.model.parameters(), lr=learning_rate, eps=eps)
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=lr_t_0, T_mult=2, eta_min=0, last_epoch=-1)

LR 曲线如下:

cosineannealingwarmrestarts参数怎么设置,大模型(LLM&AIGC),学习率,LearningRate,CosineAnnealing

源码:CosineAnnealingWarmRestarts

class CosineAnnealingWarmRestarts(LRScheduler):
    r"""Set the learning rate of each parameter group using a cosine annealing
    schedule, where :math:`\eta_{max}` is set to the initial lr, :math:`T_{cur}`
    is the number of epochs since the last restart and :math:`T_{i}` is the number
    of epochs between two warm restarts in SGDR:

    .. math::
        \eta_t = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1 +
        \cos\left(\frac{T_{cur}}{T_{i}}\pi\right)\right)

    When :math:`T_{cur}=T_{i}`, set :math:`\eta_t = \eta_{min}`.
    When :math:`T_{cur}=0` after restart, set :math:`\eta_t=\eta_{max}`.

    It has been proposed in
    `SGDR: Stochastic Gradient Descent with Warm Restarts`_.

    Args:
        optimizer (Optimizer): Wrapped optimizer.
        T_0 (int): Number of iterations for the first restart.
        T_mult (int, optional): A factor increases :math:`T_{i}` after a restart. Default: 1.
        eta_min (float, optional): Minimum learning rate. Default: 0.
        last_epoch (int, optional): The index of last epoch. Default: -1.
        verbose (bool): If ``True``, prints a message to stdout for
            each update. Default: ``False``.

    .. _SGDR\: Stochastic Gradient Descent with Warm Restarts:
        https://arxiv.org/abs/1608.03983
    """

    def __init__(self, optimizer, T_0, T_mult=1, eta_min=0, last_epoch=-1, verbose=False):
        if T_0 <= 0 or not isinstance(T_0, int):
            raise ValueError(f"Expected positive integer T_0, but got {T_0}")
        if T_mult < 1 or not isinstance(T_mult, int):
            raise ValueError(f"Expected integer T_mult >= 1, but got {T_mult}")
        if not isinstance(eta_min, (float, int)):
            raise ValueError(f"Expected float or int eta_min, but got {eta_min} of type {type(eta_min)}")
        self.T_0 = T_0
        self.T_i = T_0
        self.T_mult = T_mult
        self.eta_min = eta_min
        self.T_cur = last_epoch
        super().__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)

        return [self.eta_min + (base_lr - self.eta_min) * (1 + math.cos(math.pi * self.T_cur / self.T_i)) / 2
                for base_lr in self.base_lrs]

[docs]    def step(self, epoch=None):
        """Step could be called after every batch update

        Example:
            >>> # xdoctest: +SKIP("Undefined vars")
            >>> 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)

        This function can be called in an interleaved way.

        Example:
            >>> # xdoctest: +SKIP("Undefined vars")
            >>> scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult)
            >>> for epoch in range(20):
            >>>     scheduler.step()
            >>> scheduler.step(26)
            >>> scheduler.step() # scheduler.step(27), instead of scheduler(20)
        """

        if epoch is None and self.last_epoch < 0:
            epoch = 0

        if epoch is None:
            epoch = self.last_epoch + 1
            self.T_cur = self.T_cur + 1
            if self.T_cur >= self.T_i:
                self.T_cur = self.T_cur - self.T_i
                self.T_i = self.T_i * self.T_mult
        else:
            if epoch < 0:
                raise ValueError(f"Expected non-negative epoch, but got {epoch}")
            if epoch >= self.T_0:
                if self.T_mult == 1:
                    self.T_cur = epoch % self.T_0
                else:
                    n = int(math.log((epoch / self.T_0 * (self.T_mult - 1) + 1), self.T_mult))
                    self.T_cur = epoch - self.T_0 * (self.T_mult ** n - 1) / (self.T_mult - 1)
                    self.T_i = self.T_0 * self.T_mult ** (n)
            else:
                self.T_i = self.T_0
                self.T_cur = epoch
        self.last_epoch = math.floor(epoch)

        class _enable_get_lr_call:

            def __init__(self, o):
                self.o = o

            def __enter__(self):
                self.o._get_lr_called_within_step = True
                return self

            def __exit__(self, type, value, traceback):
                self.o._get_lr_called_within_step = False
                return self

        with _enable_get_lr_call(self):
            for i, data in enumerate(zip(self.optimizer.param_groups, self.get_lr())):
                param_group, lr = data
                param_group['lr'] = lr
                self.print_lr(self.verbose, i, lr, epoch)

        self._last_lr = [group['lr'] for group in self.optimizer.param_groups]

WandB 测试效果:

cosineannealingwarmrestarts参数怎么设置,大模型(LLM&amp;AIGC),学习率,LearningRate,CosineAnnealing
验证集效果也是周期更新:

cosineannealingwarmrestarts参数怎么设置,大模型(LLM&amp;AIGC),学习率,LearningRate,CosineAnnealing

参考:文章来源地址https://www.toymoban.com/news/detail-827665.html

  • 知乎 - PyTorch中学习率调度器可视化介绍

到了这里,关于DeepLearning - 余弦退火热重启学习率 CosineAnnealingWarmRestartsLR的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 数学建模学习(9):模拟退火算法

    模拟退火算法(Simulated Annealing, SA)的思想借 鉴于固体的退火原理,当固体的温度很高的时候,内能比 较大,固体的内部粒子处于快速无序运动,当温度慢慢降 低的过程中,固体的内能减小,粒子的慢慢趋于有序,最 终,当固体处于常温时,内能达到最小,此时,粒子最为 稳

    2024年02月14日
    浏览(36)
  • 【数学建模学习(9):模拟退火算法】

    模拟退火算法(Simulated Annealing, SA)的思想借 鉴于固体的退火原理,当固体的温度很高的时候,内能比 较大,固体的内部粒子处于快速无序运动,当温度慢慢降 低的过程中,固体的内能减小,粒子的慢慢趋于有序,最 终,当固体处于常温时,内能达到最小,此时,粒子最为 稳

    2024年02月14日
    浏览(40)
  • 智能优化算法学习笔记(2)–模拟退火算法(SA)

    模拟退火算法( Simulated Annealing ,简称 SA )的思想最早是由 Metropolis 等提出的。其出发点是基于物理中固体物质的退火过程与一般的组合优化问题之间的相似性。模拟退火算法是一种通用的优化算法,其物理退火过程由以下三部分组成: 加温过程 。其目的是增强粒子的热运

    2024年02月05日
    浏览(43)
  • 机器学习中的数学——距离定义(八):余弦距离(Cosine Distance)

    分类目录:《机器学习中的数学》总目录 相关文章: · 距离定义:基础知识 · 距离定义(一):欧几里得距离(Euclidean Distance) · 距离定义(二):曼哈顿距离(Manhattan Distance) · 距离定义(三):闵可夫斯基距离(Minkowski Distance) · 距离定义(四):切比雪夫距离(

    2023年04月08日
    浏览(37)
  • 机器学习笔记 - 使用 ResNet-50 和余弦相似度的基于图像的推荐系统

    一、简述         这里的代码主要是基于图像的推荐系统,该系统利用 ResNet-50 深度学习模型作为特征提取器,并采用余弦相似度来查找给定输入图像的最相似嵌入。         该系统旨在根据所提供图像的视觉内容为用户提供个性化推荐。 二、所需环境 Python 3.x tenso

    2024年02月12日
    浏览(36)
  • 基于Pandas+余弦相似度+大数据智能护肤品推荐系统——机器学习算法应用(含Python工程源码)+数据集

    本项目结合了Pandas数据处理工具和机器学习技术,旨在构建一个智能的护肤品推荐系统。该系统不仅会考虑用户的肤质特征,还会考虑过敏反应等因素,并筛选出相互禁忌的产品,以便为不确定如何选择护肤品的用户提供个性化的推荐。 首先,项目会收集用户的肤质信息,包

    2024年02月07日
    浏览(34)
  • deeplearning with pytorch(二)

     

    2024年03月09日
    浏览(30)
  • 回归预测 | MATLAB实现SA-ELM模拟退火算法优化极限学习机多输入单输出回归预测(多指标,多图)

    效果一览 基本介绍 回归预测 | MATLAB实现SA-ELM模拟退火算法优化极限学习机多输入单输出回归预测(多指标,多图),输入多个特征,输出单个变量,多输入单输出回归预测; 多指标评价,代码质量极高;excel数据,方便替换,运行环境2018及以上。 程序设计 完整源码和数据

    2024年02月11日
    浏览(60)
  • Openai+Deeplearning.AI: ChatGPT Prompt Engineering(六)

    想和大家分享一下最近学习的Deeplearning.AI和openai联合打造ChatGPT Prompt Engineering在线课程.以下是我写的关于该课程的前五篇博客: ChatGPT Prompt Engineering(一) ChatGPT Prompt Engineering(二) ChatGPT Prompt Engineering(三) ChatGPT Prompt Engineering(四) ChatGPT Prompt Engineering(五) 今天我们来学习第五部分

    2024年02月07日
    浏览(34)
  • ChatGPT Prompt Engineering for Developers from DeepLearning.AI

    链接:https://learn.deeplearning.ai/chatgpt-prompt-eng/lesson/1/introduction In this course, there are some example codes that you can already run in Jupyter Notebook. Below, I will write down the core knowledge points, such as how to build a prompt and how the prompt looks like in each application. Therefore, this blog contains more notes than tutorials.

    2024年02月08日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包