精华内容
下载资源
问答
  • keras学习率余弦退火CosineAnnealing1.引言2.余弦退火的原理3.keras实现 1.引言 当我们使用梯度下降算法来优化目标函数的时候,当越来越接近Loss值的全局最小值时,学习率应该变得更小来使得模型不会超调且尽可能...
  • 学习率会在刚开始的时候上升,加快模型的收敛速度,寻找最优点...下面为cifar-10数据集,学习采用余弦退火衰减 实现方式如下,利用Callback实现,与普通的ReduceLROnPlateau调用方式类似: import numpy as np import.

    在这里插入图片描述

    学习率会在刚开始的时候上升,加快模型的收敛速度,寻找最优点位置,到达一定step后,学习率下降,此时我们可以认为这是一个模型在微调的过程。上升采用线性上升,下降采用cos函数下降。

    step = (训练样本数 * 训练epoch )/batch_size
    0.001是自己设置的learning_base点。

    下面为cifar-10数据集,学习采用余弦退火衰减
    实现方式如下,利用Callback实现,与普通的ReduceLROnPlateau调用方式类似:
    import numpy as np
    import matplotlib.pyplot as plt
    import keras
    from keras import backend as K
    from keras.layers import Flatten,Conv2D,Dropout,Input,Dense,MaxPooling2D
    from keras.models import Model
    
    def exponent(global_epoch,
                learning_rate_base,
                decay_rate,
                min_learn_rate=0,
                ):
    
        learning_rate = learning_rate_base * pow(decay_rate, global_epoch)
        learning_rate = max(learning_rate,min_learn_rate)
        return learning_rate
    
    
    class ExponentDecayScheduler(keras.callbacks.Callback):
        """
        继承Callback,实现对学习率的调度
        """
        def __init__(self,
                     learning_rate_base,
                     decay_rate,
                     global_epoch_init=0,
                     min_learn_rate=0,
                     verbose=0):
            super(ExponentDecayScheduler, self).__init__()
            # 基础的学习率
            self.learning_rate_base = learning_rate_base
            # 全局初始化epoch
            self.global_epoch = global_epoch_init
    
            self.decay_rate = decay_rate
            # 参数显示  
            self.verbose = verbose
            # learning_rates用于记录每次更新后的学习率,方便图形化观察
            self.min_learn_rate = min_learn_rate
            self.learning_rates = []
    
        def on_epoch_end(self, epochs ,logs=None):
            self.global_epoch = self.global_epoch + 1
            lr = K.get_value(self.model.optimizer.lr)
            self.learning_rates.append(lr)
    	#更新学习率
        def on_epoch_begin(self, batch, logs=None):
            lr = exponent(global_epoch=self.global_epoch,
                        learning_rate_base=self.learning_rate_base,
                        decay_rate = self.decay_rate,
                        min_learn_rate = self.min_learn_rate)
            K.set_value(self.model.optimizer.lr, lr)
            if self.verbose > 0:
                print('\nBatch %05d: setting learning '
                      'rate to %s.' % (self.global_epoch + 1, lr))
    
    # 载入Mnist手写数据集
    cifar10= keras.datasets.cifar10
    (x_train, y_train), (x_test, y_test) = cifar10.load_data()
    x_train, x_test = x_train / 255.0, x_test / 255.0
    
    #-----------------------------#
    #   创建模型
    #-----------------------------#
    inputs = Input([28,28,1])
    x = Conv2D(32, kernel_size= 5,padding = 'same',activation="relu")(inputs)
    x = MaxPooling2D(pool_size = 2, strides = 2, padding = 'same',)(x)
    x = Conv2D(64, kernel_size= 5,padding = 'same',activation="relu")(x)
    x = MaxPooling2D(pool_size = 2, strides = 2, padding = 'same',)(x)
    x = Flatten()(x)
    x = Dense(1024)(x)
    x = Dense(256)(x)
    out = Dense(10, activation='softmax')(x)
    model = Model(inputs,out)
    
    # 设定优化器,loss,计算准确率
    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    
    # 设置训练参数
    epochs = 10
    
    init_epoch = 0
    # 每一次训练使用多少个Batch
    batch_size = 256
    # 最大学习率
    learning_rate_base = 1e-3
    
    sample_count = len(x_train)
    
    # 学习率
    exponent_lr = ExponentDecayScheduler(learning_rate_base = learning_rate_base,
                                        global_epoch_init = init_epoch,
                                        decay_rate = 0.9,
                                        min_learn_rate = 1e-6
                                        )
    
    # 利用fit进行训练
    model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size,
                verbose=1, callbacks=[exponent_lr])
                
    plt.plot(exponent_lr.learning_rates)
    plt.xlabel('Step', fontsize=20)
    plt.ylabel('lr', fontsize=20)
    plt.axis([0, epochs, 0, learning_rate_base*1.1])
    plt.xticks(np.arange(0, epochs, 1))
    plt.grid()
    plt.title('lr decay with exponent', fontsize=20)
    plt.show()
    
    展开全文
  • 除了在训练过程中进行学习率衰减以防止求得的最优解不断震荡之外,余弦退火衰减策略规定,学习率每次衰减到0之后,会迅速回升至初始值,这样可以避免陷入局部最优解。关于余弦退火学习率衰减策略的详细介绍可以参考...

    项目说明

    余弦退火学习率衰减的学习率曲线如下图所示:
    在这里插入图片描述
    除了在训练过程中进行学习率衰减以防止求得的最优解不断震荡之外,余弦退火衰减策略规定,学习率每次衰减到0之后,会迅速回升至初始值,这样可以避免陷入局部最优解。关于余弦退火学习率衰减策略的详细介绍可以参考文章:学习率衰减之余弦退火(CosineAnnealing)

    代码实现

    在 Tensorflow2.0 中自定义学习率衰减策略其实很简单,可以参考文章:Tensorflow2.0学习率衰减详细汇总

    import tensorflow as tf
    
    展开全文
  • 学习率衰减余弦退火(CosineAnnealing)

    万次阅读 多人点赞 2020-09-09 21:11:25
    当我们使用梯度下降算法来优化目标函数的时候,当越来越接近Loss值的全局最小值时,学习率应该变得更小来使得模型尽可能接近这一点,而余弦退火(Cosine annealing)可以通过余弦函数来降低学习率。余弦函数中随着x...

    1 引言

    当我们使用梯度下降算法来优化目标函数的时候,当越来越接近Loss值的全局最小值时,学习率应该变得更小来使得模型尽可能接近这一点,而余弦退火(Cosine annealing)可以通过余弦函数来降低学习率。余弦函数中随着x的增加余弦值首先缓慢下降,然后加速下降,再次缓慢下降。这种下降模式能和学习率配合,以一种十分有效的计算方式来产生很好的效果。
    在这里插入图片描述
    在论文Stochastic Gradient Descent with Warm Restarts中介绍主要介绍了带重启的随机梯度下降算法(SGDR),其中就引入了余弦退火的学习率下降方式。
    本文主要介绍余弦退火的原理以及实现。并且因为我们的目标优化函数可能是多峰的(如下图所示),除了全局最优解之外还有多个局部最优解,在训练时梯度下降算法可能陷入局部最小值,此时可以通过突然提高学习率,来“跳出”局部最小值并找到通向全局最小值的路径。这种方式称为带重启的随机梯度下降方法
    在这里插入图片描述

    2 余弦退火的原理

    论文介绍最简单的热重启的方法。当执行完   T i \ T_i  Ti 个epoch之后就会开始热重启(warm restart),而下标 i i i就是指的第几次restart,其中重启并不是重头开始,而是通过增加学习率来模拟,并且重启之后使用旧的   x t \ x_t  xt ​作为初始解,这里的   x t \ x_t  xt 就是通过梯度下降求解loss函数的解,也就是神经网络中的权重,因为重启就是为了通过增大学习率来跳过局部最优,所以需要将   x t \ x_t  xt置为旧值。
    本文并不涉及重启部分的内容,所以只考虑在每一次run(包含重启就是restart)中,学习率是如何减小的。余弦退火( cosine annealing )的原理如下:
    在这里插入图片描述
    表达式中的字符含义:

    •   i \ i  i就是第几次run(索引值);
    •   n m a x i \ n_{max}^i  nmaxi   n m i n i \ n_{min}^i  nmini​ 分别表示学习率的最大值和最小值,定义了学习率的范围。论文中提到在每次restart之后,减少   n m a x i \ n_{max}^i  nmaxi   n m i n i \ n_{min}^i  nmini的值,但是为了简单,论文中也保持   n m a x i \ n_{max}^i  nmaxi   n m i n i \ n_{min}^i  nmini在每次restart之后仍然保持不变。
    •   T c u r \ T_{cur}  Tcur则表示当前执行了多少个epoch,但是   T c u r \ T_{cur}  Tcur是在每个batch运行之后就会更新,而此时一个epoch还没有执行完,所以   T c u r \ T_{cur}  Tcur 的值可以为小数。例如总样本为80,每个batch的大小是16,那么在一个epoch中就会循环5次读入batch,那么在第一个epoch中执行完第一个batch后,   T c u r \ T_{cur}  Tcur 的值就更新为1/5=0.2,以此类推
    •   T i \ T_{i}  Ti表示第i次run中总的epoch数。当涉及到重启时,论文中提到为了提高性能表现,开始会初始化一个比较小的   T i \ T_{i}  Ti ,在每次restart后,   T i \ T_{i}  Ti 会以乘以一个   T m u l t \ T_{mult}  Tmult 的方式增加,但是本文不涉及重启也就不需要考虑,即把   T i \ T_{i}  Ti 固定为我们训练模型的epoch数。

    3 keras实现

      T i \ T_{i}  Ti
      T c u r \ T_{cur}  Tcur
    为了简单,这里稍微修改一下   T c u r \ T_{cur}  Tcur   T i \ T_{i}  Ti的定义,原本表示的是epoch的数量,但是因为   T c u r \ T_{cur}  Tcur是在每个batch之后都会更新,所以将T   T i \ T_{i}  Ti 定义为总的batch需要执行的步数,而   T c u r \ T_{cur}  Tcur 定义为当前对当前已经执行的batch的计数,即每执行一个batch,   T c u r \ T_{cur}  Tcur 就加一。举个例子,样本总数为80,每个batch的大小为16,那么一共有5个batch,再令训练模型总的epoch为30,假设当前执行到第二个epoch的第二个batch结束,那么此时   T c u r \ T_{cur}  Tcur /   T i \ T_{i}  Ti= ( 1 ∗ 5 + 2 ) / ( 30 ∗ 5 ) 按照之前的定义   T c u r \ T_{cur}  Tcur /   T i \ T_{i}  Ti = ( 1 + 2 / 5 ) / 30 两者是等价的,但是因为之前的定义存在小数,如果1除以batch的总数除不尽,就会存在精度损失的情况。

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

    keras通过继承Callback实现余弦退火。通过继承Callback,当我们训练的时候输入我们的该函数,就可以哎每个batch开始训练前以及结束后回调我们重写的on_batch_end和on_batch_begin函数。
    完整代码(源自github)

    import numpy as np
    from tensorflow import keras
    from keras import backend as K
    
    
    def cosine_decay_with_warmup(global_step,
                                 learning_rate_base,
                                 total_steps,
                                 warmup_learning_rate=0.0,
                                 warmup_steps=0,
                                 hold_base_rate_steps=0):
       """
       参数:
       		global_step: 上面定义的Tcur,记录当前执行的步数。
       		learning_rate_base:预先设置的学习率,当warm_up阶段学习率增加到learning_rate_base,就开始学习率下降。
       		total_steps: 是总的训练的步数,等于epoch*sample_count/batch_size,(sample_count是样本总数,epoch是总的循环次数)
       		warmup_learning_rate: 这是warm up阶段线性增长的初始值
       		warmup_steps: warm_up总的需要持续的步数
       		hold_base_rate_steps: 这是可选的参数,即当warm up阶段结束后保持学习率不变,知道hold_base_rate_steps结束后才开始学习率下降
       """
        if total_steps < warmup_steps:
            raise ValueError('total_steps must be larger or equal to '
                             'warmup_steps.')
        #这里实现了余弦退火的原理,设置学习率的最小值为0,所以简化了表达式
        learning_rate = 0.5 * learning_rate_base * (1 + np.cos(np.pi *
            (global_step - warmup_steps - hold_base_rate_steps) / float(total_steps - warmup_steps - hold_base_rate_steps)))
        #如果hold_base_rate_steps大于0,表明在warm up结束后学习率在一定步数内保持不变
        if hold_base_rate_steps > 0:
            learning_rate = np.where(global_step > warmup_steps + hold_base_rate_steps,
                                     learning_rate, learning_rate_base)
        if warmup_steps > 0:
            if learning_rate_base < warmup_learning_rate:
                raise ValueError('learning_rate_base must be larger or equal to '
                                 'warmup_learning_rate.')
            #线性增长的实现
            slope = (learning_rate_base - warmup_learning_rate) / warmup_steps
            warmup_rate = slope * global_step + warmup_learning_rate
            #只有当global_step 仍然处于warm up阶段才会使用线性增长的学习率warmup_rate,否则使用余弦退火的学习率learning_rate
            learning_rate = np.where(global_step < warmup_steps, warmup_rate,
                                     learning_rate)
        return np.where(global_step > total_steps, 0.0, learning_rate)
    
    
    class WarmUpCosineDecayScheduler(keras.callbacks.Callback):
        """
        继承Callback,实现对学习率的调度
        """
        def __init__(self,
                     learning_rate_base,
                     total_steps,
                     global_step_init=0,
                     warmup_learning_rate=0.0,
                     warmup_steps=0,
                     hold_base_rate_steps=0,
                     verbose=0):
            super(WarmUpCosineDecayScheduler, self).__init__()
            self.learning_rate_base = learning_rate_base
            self.total_steps = total_steps
            self.global_step = global_step_init
            self.warmup_learning_rate = warmup_learning_rate
            self.warmup_steps = warmup_steps
            self.hold_base_rate_steps = hold_base_rate_steps
            self.verbose = verbose
            #learning_rates用于记录每次更新后的学习率,方便图形化观察
            self.learning_rates = []
    	#更新global_step,并记录当前学习率
        def on_batch_end(self, batch, logs=None):
            self.global_step = self.global_step + 1
            lr = K.get_value(self.model.optimizer.lr)
            self.learning_rates.append(lr)
    	#更新学习率
        def on_batch_begin(self, batch, logs=None):
            lr = cosine_decay_with_warmup(global_step=self.global_step,
                                          learning_rate_base=self.learning_rate_base,
                                          total_steps=self.total_steps,
                                          warmup_learning_rate=self.warmup_learning_rate,
                                          warmup_steps=self.warmup_steps,
                                          hold_base_rate_steps=self.hold_base_rate_steps)
            K.set_value(self.model.optimizer.lr, lr)
            if self.verbose > 0:
                print('\nBatch %05d: setting learning '
                      'rate to %s.' % (self.global_step + 1, lr))
                      
    

    下面的代码构建了一个简单的模型,并使用warm up和余弦退火的方式来规划学习率。

    from keras.models import Sequential
    from keras.layers import Dense
    # Create a model.
    model = Sequential()
    model.add(Dense(32, activation='relu', input_dim=100))
    model.add(Dense(10, activation='softmax'))
    model.compile(optimizer='rmsprop',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
    
    #样本总数
    sample_count = 12608
    # Total epochs to train.
    epochs = 50
    # Number of warmup epochs.
    warmup_epoch = 10
    # Training batch size, set small value here for demonstration purpose.
    batch_size = 16
    # Base learning rate after warmup.
    learning_rate_base = 0.0001
    
    total_steps = int(epochs * sample_count / batch_size)
    
    # Compute the number of warmup batches.
    warmup_steps = int(warmup_epoch * sample_count / batch_size)
    
    # Generate dummy data.
    data = np.random.random((sample_count, 100))
    labels = np.random.randint(10, size=(sample_count, 1))
    
    # Convert labels to categorical one-hot encoding.
    one_hot_labels = keras.utils.to_categorical(labels, num_classes=10)
    
    # Compute the number of warmup batches.
    warmup_batches = warmup_epoch * sample_count / batch_size
    
    # Create the Learning rate scheduler.
    warm_up_lr = WarmUpCosineDecayScheduler(learning_rate_base=learning_rate_base,
                                                total_steps=total_steps,
                                                warmup_learning_rate=4e-06,
                                                warmup_steps=warmup_steps,
                                                hold_base_rate_steps=5,
                                                )
    
    # Train the model, iterating on the data in batches of 32 samples
    model.fit(data, one_hot_labels, epochs=epochs, batch_size=batch_size,
                verbose=0, callbacks=[warm_up_lr])
    
    import matplotlib.pyplot as plt
    plt.plot(warm_up_lr.learning_rates)
    plt.xlabel('Step', fontsize=20)
    plt.ylabel('lr', fontsize=20)
    plt.axis([0, total_steps, 0, learning_rate_base*1.1])
    plt.xticks(np.arange(0, epochs, 1))
    plt.grid()
    plt.title('Cosine decay with warmup', fontsize=20)
    plt.show()
    
    

    运行结果
    在这里插入图片描述

    展开全文
  • 学习率余弦退火衰减之后的loss

    千次阅读 2021-11-14 10:57:53
    使用余弦退火之后,loss也就一蹦一蹦啦

     使用余弦退火之后,loss也就一蹦一蹦啦

    展开全文
  • import tensorflow as tf import math import matplotlib.pyplot as plt class CosineWarmup(tf.keras.optimizers.schedules.LearningRateSchedule): def __init__(self, warmup_slope, warmup_steps, cosine_...
  • tensorflow2实现Mnist余弦退火+热重启+ 每个step的学习率输出+可视化.py
  • 余弦退火衰减函数

    2021-10-19 21:09:23
    当我们使用梯度下降算法来优化目标函数的时候,当越来越接近Loss值的全局最小值时,学习率应该变得更小来使得模型尽可能接近这一点,而余弦退火(cosine annealing)可以通过余弦函数来降低学习率。余弦函数中随着x...
  • 1. 概述 在论文《SGDR: Stochastic Gradient Descent with Warm Restarts》中主要介绍了带重启的随机梯度下降算法(SGDR),其中就引入了余弦退火学习率下降方式。 当我们使用梯度下降算法来优化目标函数的时候,...
  • pytorch的余弦退火学习率

    千次阅读 2020-11-08 14:29:12
    点击上方“机器学习与生成对抗网络”,关注"星标"获取有趣、好玩的前沿干货!作者:limzero地址:https://www.zhihu.com/people/lim0-3...
  • 使用warmup的余弦退火学习率

    千次阅读 2020-04-12 17:12:34
    训练过程中还有可能对超参数进行微调,比如最常见的一个需求是根据epoch来调整学习率,这可以简单地通过LearningRateScheduler来实现,它也属于回调器之一。 from keras.callbacks import LearningRateScheduler ...
  • (一)keras学习率余弦退火CosineAnnealing https://blog.csdn.net/CarryLvan/article/details/104394960 keras学习率余弦退火CosineAnnealing 1.引言 2.余弦退火的原理 3.keras实现 1.引言 当我们使用梯度下降...
  • 摘要:文献【1】中除了权重衰减还利用了余弦退火(Cosine Annealing)以及Warm Restart,本文介绍这两种方法的原理及numpy和Keras的实现方法,其中Keras实现中继承回调函数Callbacks。
  • 人工智能AI:Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战(不定时更新) EfficientNet中的每个模型要求的输入形状大小 每个网络要求的输入形状大小: EfficientNetB0 - (224, 224, 3) ...
  • 记录余弦退火 1. 正文 1.1 Cosine Annealing Warm Restarts 1.1.1 官方解释 先放官网截图 1.1.2 测试 1. 第一次测试 1. 代码 import torch import torch.nn as nn from torch.optim.lr_scheduler import ...
  • pyTorch中的学习率衰减

    千次阅读 2020-10-30 13:59:18
    经过多年的发展,也出现了多种学习率衰减算法,比如线性衰减、指数衰减、cosine衰减等,下面将pyTorch中提供的学习率衰减算法进行整理。 2 PyTorch中的学习率衰减 pyTorch官方介绍:...
  • 余弦退火衰减5. 上述4种学习率动态更新策略的说明 梯度下降算法需要我们指定一个学习率作为权重更新步幅的控制因子,常用的学习率有0.01、0.001以及0.0001等,学习率越大则权重更新。一般来说,我们希望在训练初期...
  • 有序调整:等间隔调整(Step),按需调整学习率(MultiStep),指数衰减调整(Exponential)和 余弦退火CosineAnnealing。 b. 自适应调整:自适应调整学习率 ReduceLROnPlateau。 c. 自定义调整:自定义调整学习率 ...
  • 学习率退火

    千次阅读 2018-02-21 00:02:47
    在训练神经网络时,一般情况下学习率...目前,比较常见的学习率退火方式有如下三种: 随步数衰减 比较常见的随步数衰减方式是每经过5个epoch学习率减小为一半,或者每经过20个epoch学习率减小为原来的十分之一。...
  • pytorch优化器,学习率衰减学习笔记

    千次阅读 2018-09-04 22:23:23
    目录 LAMB优化器 AdaBelief 优化器 Adam和SGD的结合体 lookahead Ranger RAdam和LookAhead合二为一 余弦退火学习率衰减
  • Tensorflow实现各种学习率衰减

    万次阅读 多人点赞 2018-02-18 12:45:35
    Tensorflow实现学习率衰减 觉得有用的话,欢迎一起讨论相互学习~Follow Me 参考文献 Deeplearning AI Andrew Ng Tensorflow1.2 API 学习率衰减(learning rate decay) 加快学习算法的一个办法就是随...
  • YOLOV4改进的部分: ...4、训练用到的小技巧:Mosaic数据增强、Label Smoothing平滑、CIOU、学习率余弦退火衰减 5、激活函数:使用Mish激活函数 以上并非全部的改进部分,还存在一些其它的改进。。。。 ...
  • PyTorch学习之学习率调整策略 ... 有序调整:等间隔调整(Step),按需调整学习率(MultiStep),指数衰减调整(Exponential)和 余弦退火CosineAnnealing。 b. 自适应调整:自适应调整学习率 ReduceLR...
  • 有序调整:等间隔调整(Step),多间隔调整(MultiStep),指数衰减(Exponential),余弦退火(CosineAnnealing); 自适应调整:依训练状况伺机而变,通过监测某个指标的变化情况(loss、accuracy),当该指标不怎么变化时,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 555
精华内容 222
关键字:

学习率余弦退火衰减