精华内容
下载资源
问答
  • Keras自动调整学习率

    2020-05-20 22:40:13
    自动调整学习率 ''' from keras.callbacks import Callback import keras.backend as K class LinearDecayLR(Callback): ''' 每个batch之后衰减一次学习率(lr) # Arguments min_lr: The lower bound (final ...
    '''
    自动调整学习率
    '''
    from keras.callbacks import Callback
    import keras.backend as K
    class LinearDecayLR(Callback):
        '''
        每个batch之后衰减一次学习率(lr)
        # Arguments
            min_lr: The lower bound (final value) of the learning rate.
            max_lr: The upper bound (initial value) of the learning rate.
            steps_per_epoch: 一个epoch所包含的batch数
            epochs: Number of epochs to run training.
        # Usage
            lr_decay = LinearDecayLR(min_lr=1e-5, max_lr=0.01,
                                     steps_per_epoch=step_size_train,
                                     epochs=20, verbose=1)
            model.fit(X_train, Y_train, callbacks=[lr_decay])
        '''
        def __init__(self, min_lr=1e-5, max_lr=1e-2, steps_per_epoch=None, epochs=None, verbose=0):
            super().__init__()
    
            self.min_lr = min_lr
            self.max_lr = max_lr
            self.total_iterations = steps_per_epoch * epochs  # 每个epoch包含的batch数 * 总epoch数 = 总batch数
            self.iteration = 0
            self.verbose = verbose
    
        def linear_decay(self):  # 一个epoch之后, 计算一次学习率
            '''Calculate the learning rate.'''
            r = self.iteration / self.total_iterations
            return self.max_lr - (self.max_lr - self.min_lr) * r
    
        def on_train_begin(self, logs=None):  # 整个训练的开始,给学习率赋最大值
            '''Initialize the learning rate to the initial value at the start of training.'''
            logs = logs or {}
            K.set_value(self.model.optimizer.lr, self.max_lr)
    
        def on_batch_end(self, epoch, logs=None):  # 每个batch结束, 计算一下学习率,
            '''Update the learning rate after each batch update'''
            logs = logs or {}
            self.iteration += 1
            K.set_value(self.model.optimizer.lr, self.linear_decay())
    
        def on_epoch_begin(self, epoch, logs=None):
            if self.verbose > 0:
                print('\nEpoch %05d: LearningRateScheduler setting learning '
                      'rate to %s.' % (epoch + 1, K.get_value(self.model.optimizer.lr)))
    
        def on_epoch_end(self, epoch, logs=None):
            logs = logs or {}
            logs['lr'] = K.get_value(self.model.optimizer.lr)
    
    展开全文
  • keras自动调整学习率

    千次阅读 2020-02-10 17:32:11
    ReduceLROnPlateau keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', epsilon=0.0001, cooldown=0, min_...当学习停滞时,减少2倍或10倍的学习率常常能获...

    ReduceLROnPlateau

    keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0)
    

    当评价指标不在提升时,减少学习率

    当学习停滞时,减少2倍或10倍的学习率常常能获得较好的效果。该回调函数检测指标的情况,如果在patience个epoch中看不到模型性能提升,则减少学习率

    **参数
    monitor:被监测的量
    factor:每次减少学习率的因子,学习率将以lr = lr*factor的形式被减少
    patience:当patience个epoch过去而模型性能不提升时,学习率减少的动作会被触发
    mode:‘auto’,‘min’,‘max’之一,在min模式下,如果检测值触发学习率减少。在max模式下,当检测值不再上升则触发学习率减少。
    epsilon:阈值,用来确定是否进入检测值的“平原区”
    cooldown:学习率减少后,会经过cooldown个epoch才重新进行正常操作
    min_lr:学习率的下限

    from keras.callbacks import ReduceLROnPlateau
    reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=10, mode='auto')
    epochs = 500
    history = model.fit_generator(train_generator,
                                  steps_per_epoch = train_num // batch_size,
                                  epochs = epochs,
                                  validation_data = valid_generator,
                                  validation_steps = valid_num // batch_size
                                  ,callbacks=[reduce_lr]
                            )
    
    展开全文
  • 0 为什么引入学习率衰减? 我们都知道几乎所有的神经网络采取的是梯度下降法来对模型进行最优化,其中标准的权重更新公式: W+=α∗ gradient  W+=\alpha * \text { gradient } W+=α∗ gradient&...

    0 为什么引入学习率衰减?

    我们都知道几乎所有的神经网络采取的是梯度下降法来对模型进行最优化,其中标准的权重更新公式:
    W + = α ∗  gradient  W+=\alpha * \text { gradient } W+=α gradient 

    • 学习率 α \alpha α 控制着梯度更新的步长(step), α \alpha α 越大,意味着下降的越快,到达最优点的速度也越快,如果为 0 0 0,则网络就会停止更新
    • 学习率过大,在算法优化的前期会加速学习,使得模型更容易接近局部或全局最优解。但是在后期会有较大波动,甚至出现损失函数的值围绕最小值徘徊,波动很大,始终难以达到最优。

    所以引入学习率衰减的概念,直白点说,就是在模型训练初期,会使用较大的学习率进行模型优化,随着迭代次数增加,学习率会逐渐进行减小,保证模型在训练后期不会有太大的波动,从而更加接近最优解。

    本文所有的实验代码可在如下链接下载并测试
    lr_scheduler_test.py-深度学习文档类资源-CSDN下载

    1 查看学习率

    print("Lr:{}".format(optimizer.state_dict()['param_groups'][0]['lr']))
    

    之后我会用类似于如下的代码进行学习率的测试输出

    def train():   
    	traindataset = TrainDataset()
        traindataloader = DataLoader(dataset = traindataset,batch_size=100,shuffle=False)
        net = Net().cuda()
        myloss = nn.MSELoss().cuda()
        optimizer = optim.SGD(net.parameters(), lr=0.001 )
        for epoch in range(100):
            print("Epoch:{}  Lr:{:.2E}".format(epoch,optimizer.state_dict()['param_groups'][0]['lr']))
            for data,label in traindataloader :
                data = data.cuda()
                label = label.cuda()
                output = testnet(data)
                loss = myloss(output,label)
                optimizer.zero_grad()
                loss.backward()
            	optimizer.step()
            scheduler.step()
    

    2 最常用的针对全局的学习率设置

    需要根据你选择的优化器的种类把具体你想要的lr作为可选参数的一部分传入到新建的优化器类初始化中

    image-20210823163949577

    optimizer = optim.SGD(net.parameters(), lr=0.001 )
    

    image-20210823163111055

    3 针对不同层设置不一样的学习率

    当我们在使用预训练的模型时,需要对分类层进行单独修改并进行初始化,其他层的参数采用预训练的模型参数进行初始化,这个时候我们希望在进行训练过程中,除分类层以外的层只进行微调,不需要过多改变参数,因此需要设置较小的学习率。而改正后的分类层则需要以较大的步子去收敛,学习率往往要设置大一点

    以一个简单的网络为例

    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.net1 = nn.Linear(2,10)
            self.net2 = nn.Linear(10,1)
        def forward(self, x):
            x = self.net1(x)
            x = self.net2(x)
            return x
    net = Net()
    optimizer = optim.SGD([
            {"params":model.net1.parameters()},
            {"params":model.net2.parameters(),"lr":1e-5},],
            lr=1e-2, #默认参数
        )
    for epoch in range(100):
            print("Epoch:{}  Lr:{:.2E}".format(epoch,optimizer.state_dict()['param_groups'][0]['lr']))
            print("Epoch:{}  Lr:{:.2E}".format(epoch,optimizer.state_dict()['param_groups'][1]['lr']))
            optimizer.step()
    

    image-20210823171514596

    resnet101为例,分层设置学习率。

    model = torchvision.models.resnet101(pretrained=True)
    large_lr_layers = list(map(id,model.fc.parameters()))
    small_lr_layers = filter(lambda p:id(p) not in large_lr_layers,model.parameters())
    optimizer = torch.optim.SGD([
                {"params":large_lr_layers},
                {"params":small_lr_layers,"lr":1e-4}
                ],lr = 1e-2,momenum=0.9)
    

    注:large_lr_layers学习率为 1e-2small_lr_layers学习率为 1e-4,两部分参数共用一个momenum

    4 手动设置自动衰减的学习率

    def adjust_learning_rate(optimizer, epoch, start_lr):
        """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
        lr = start_lr * (0.1 ** (epoch // 3))
        for param_group in optimizer.param_groups:
            param_group['lr'] = lr
    

    注释:在调用此函数时需要输入所用已经初始化完毕的optimizer以及对应的epoch,并且start_lr作为初始化的学习率也需要给出。

    optimizer = torch.optim.SGD(net.parameters(),lr = start_lr)
    for epoch in range(100):
        adjust_learning_rate(optimizer,epoch,start_lr)
        print("Epoch:{}  Lr:{:.2E}".format(epoch,optimizer.state_dict()['param_groups'][0]['lr']))
        for data,label in traindataloader :
            data = data.cuda()
            label = label.cuda()
            output = net(data)
            loss = myloss(output,label)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    

    image-20210823172852695

    5 手动根据自定义列表进行学习率指定

    def adjust_learning_rate_list(optimizer, epoch):
        lr_set_list = [[1,1e-1],[2,1e-2],[3,1e-3],[4,1e-4],[5,1e-5]]# 执行此学习率的epoch数
        lr_list = []
        for i in lr_set_list:
            for j in range(i[0]):
                lr_list.append(i[1])
        for param_group in optimizer.param_groups:
            if epoch < len(lr_list)-1:
                param_group['lr'] = lr_list[epoch]
            else:
                param_group['lr'] = lr_list[-1]
    

    image-20210823173823392

    6 使用pytorch提供的学习率

    torch.optim.lr_scheduler内部,基于当前epoch的数值,封装了几种相应的动态学习率调整方法,该部分的官方手册传送门——optim.lr_scheduler官方文档需要注意的是学习率的调整需要应用在优化器参数更新之后,也就是说:

    optimizer = torch.optim.XXXXXXX()#具体optimizer的初始化
    scheduler = torch.optim.lr_scheduler.XXXXXXXXXX()#具体学习率变更策略的初始化
    for i in range(epoch):
        for data,label in dataloader:
            out = net(data)
            output_loss = loss(out,label)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        scheduler.step()
    

    其具体的学习率策略应用的简要代码示例如下:

    6.1 lr_scheduler.LambdaLR

    更新策略

    将每一个参数组的学习率调整为初始化学习率lr的给定函数倍(lr_lambda),在fine-tune中十分有用,我们不仅可以为不同的层设定不同的学习率,还可以为其设定不同的学习率调整策略。

    初始化方法:

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

    几个最常用的函数:

    # 旷世shuffleNet系列中使用的学习率变化策略
    lr_lambda = lambda step : (1.0-step/args.total_iters) if step <= args.total_iters else 0
    
    # CCNet官方源码中改变学习率的方法。这个学习率衰减策略是最常用的,被称作多项式衰减法。
    def lr_poly(base_lr, iter, max_iter, power):
        return base_lr*((1-float(iter)/max_iter)**(power))      
    def adjust_learning_rate(optimizer, learning_rate, i_iter, max_iter, power):
        """Sets the learning rate to the initial LR divided by 5 at 60th, 120th and 160th epochs"""
        lr = lr_poly(learning_rate, i_iter, max_iter, power)
        optimizer.param_groups[0]['lr'] = lr
        return lr
    

    参数

    • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名

    • lr_lambda(function or list):可以是function或是function list,给定整数参数epoch计算乘数的函数,或者是list形式的函数,分别计算各个parameter groups的学习率更新用到的学习率。一般是一个关于epoch数目的函数,从而计算出一个乘数因子,并根据该乘数因子调整初始学习率。

    • last_epoch(int):默认为-1,它一般不用设置,为-1时的作用是将人为设置的学习率设定为调整学习率的基础值lr。这里需要注意的是,last_epoch默认为-1只能保证第一次调整学习率时,原始待调整的值为人工设定的初始学习率,而第二次调整学习率时,调整的基值就变成了第一次调整后的学习率。如果是训练了很多个epoch后中断了,继续训练,这个值就等于加载的模型的epoch。默认为-1表示从头开始训练,即从epoch=1开始

    • verbose(bool):True的话为每次更新打印一个stdout,默认为False

    注意:
    在将optimizer传给scheduler后,在shcduler类的__init__方法中会给optimizer.param_groups列表中的那个元素(字典)增加一个key = "initial_lr"的元素表示初始学习率,等于optimizer.defaults['lr']

    举例:

    lambda1 = lambda epoch: 0.95 ** epoch # 第二组参数的调整方法
    optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) # 选定调整方法
    

    image-20210823205534338

    6.2 torch.optim.lr_scheduler.StepLR

    更新策略:

    这是比较常用的等间隔动态调整方法,每经过step_size个epoch,做一次学习率decay,以gamma值为缩小倍数。

    初始化方法:

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

    参数:

    • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
    • step_size(int):是学习率衰减的周期,每经过step_size 个epoch,做一次学习率decay
    • gamma(float):学习率衰减的乘法因子。Default:0.1
    • last_epoch(int):默认为-1,它一般不用设置,为-1时的作用是将人为设置的学习率设定为调整学习率的基础值lr。这里需要注意的是,last_epoch默认为-1只能保证第一次调整学习率时,原始待调整的值为人工设定的初始学习率,而第二次调整学习率时,调整的基值就变成了第一次调整后的学习率。如果是训练了很多个epoch后中断了,继续训练,这个值就等于加载的模型的epoch。默认为-1表示从头开始训练,即从epoch=1开始
    • verbose(bool):如果为True,每一次更新都会打印一个标准的输出信息 ,Default:False

    注意:

    此函数产生的decay效果,可能与函数外部的对于学习率的更改同时发生,当last_epoch = -1时,将初始lr设置为Ir

    举例:

    optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)
    

    image-20210823210303180

    6.3 lr_scheduler.MultiStepLR

    更新策略:

    一旦达到某一阶段(milestones)时,就可以通过gamma系数降低每个参数组的学习率。

    可以按照milestones列表中给定的学习率,进行分阶段式调整学习率。

    初始化方法:

    torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False)
    

    参数:

    • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
    • milestones(list):是一个关于epoch数值的list,表示在达到哪个epoch范围内开始变化,必须是升序排列
    • gamma(float):学习率衰减的乘法因子。Default:0.1
    • last_epoch(int):默认为-1,它一般不用设置,为-1时的作用是将人为设置的学习率设定为调整学习率的基础值lr。这里需要注意的是,last_epoch默认为-1只能保证第一次调整学习率时,原始待调整的值为人工设定的初始学习率,而第二次调整学习率时,调整的基值就变成了第一次调整后的学习率。如果是训练了很多个epoch后中断了,继续训练,这个值就等于加载的模型的epoch。默认为-1表示从头开始训练,即从epoch=1开始
    • verbose(bool):如果为True,每一次更新都会打印一个标准的输出信息 ,Default:False

    注意:

    此函数产生的decay效果,可能与函数外部的对于学习率的更改同时发生,当last_epoch = -1时,将初始lr设置为lr

    举例:

    optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
    scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[2,6,15], gamma=0.1)
    

    image-20210823211115897

    6.4 lr_scheduler.ExponentialLR

    更新策略:

    每一次epoch,lr都乘gamma

    初始化方法:

    torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1, verbose=False)
    

    参数:

    • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
    • gamma(float):学习率衰减的乘法因子。Default:0.1
    • last_epoch(int):默认为-1,它一般不用设置,为-1时的作用是将人为设置的学习率设定为调整学习率的基础值lr。这里需要注意的是,last_epoch默认为-1只能保证第一次调整学习率时,原始待调整的值为人工设定的初始学习率,而第二次调整学习率时,调整的基值就变成了第一次调整后的学习率。如果是训练了很多个epoch后中断了,继续训练,这个值就等于加载的模型的epoch。默认为-1表示从头开始训练,即从epoch=1开始
    • verbose(bool):如果为True,每一次更新都会打印一个标准的输出信息 ,Default:False

    举例:

    optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.1)
    

    image-20210823211659426

    6.5 lr_scheduler.CosineAnnealingLR

    更新策略:

    按照余弦波形的衰减周期来更新学习率,前半个周期从最大值降到最小值,后半个周期从最小值升到最大值

    初始化方法:

    torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1, verbose=False)
    

    参数:

    • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
    • T_max (int): 余弦波形周期的一半,比如T_max=10,则学习率衰减周期为20,其中前半段即前10个周期学习率从最大值降到最小值,后10个周期从最小值升到最大值
    • eta_min(float):学习率衰减的最小值,Default:0
    • last_epoch(int):默认为-1,它一般不用设置,为-1时的作用是将人为设置的学习率设定为调整学习率的基础值lr。这里需要注意的是,last_epoch默认为-1只能保证第一次调整学习率时,原始待调整的值为人工设定的初始学习率,而第二次调整学习率时,调整的基值就变成了第一次调整后的学习率。如果是训练了很多个epoch后中断了,继续训练,这个值就等于加载的模型的epoch。默认为-1表示从头开始训练,即从epoch=1开始
    • verbose(bool):如果为True,每一次更新都会打印一个标准的输出信息 ,Default:False

    举例:

    optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max = 10)
    

    image-20210823212321628

    6.6 lr_scheduler.ReduceLROnPlateau

    更新策略:

    与上述基于epoch数目调整学习率的方法不同,该方法是PyTorch提供的一种基于验证指标的调整方法。它的原理是:当指标停止改善时,降低学习率。当模型的学习停滞时,训练过程通常会受益于将学习率降低2~10倍。该种调整方法读取一个度量指标,如果在“耐心”期间内没有发现它有所改善,那么就会降低学习率。

    初始化方法:

    torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode= 'rel', cooldown=0, min_1r=0, eps=1e-08)
    

    step()方法:

    scheduler.step(loss)
    

    参数:

    • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
    • mode:可选str字符串数据,为min或max。当选择min时,代表当度量指标停止下降时,开始减小学习率;当选择max时,代表当度量指标停止上升时,开始减小学习率。
    • factor:float类型数据,学习率调整的乘法因子,默认值为0.1。
    • patience:int类型数据,可容忍的度量指标没有提升的epoch数目,默认为10。举例说明,当其设置为10时,我们可以容忍10个epoch内没有提升,如果在第11个epoch依然没有提升,那么就开始降低学习率。
    • verbose:bool数据,如果设置为True,输出每一次更新的信息,默认为False。
    • threshold:float类型数据,衡量新的最佳阈值,仅关注重大变化,默认为0.0001。
    • threshold_mode:可选str字符串数据,为rel或abs,默认为rel。在rel模式下,如果mode参数为max,则动态阈值(dynamic_threshold)为best*(1+threshold),如果mode参数为min,则动态阈值为best+threshold,如果mode参数为min,则动态阈值为best-threshold。
    • cooldown:int类型数据,减少lr后恢复正常操作之前要等待的epoch数,默认为0。
    • min_lr:float或list类型数据,学习率的下界,默认为0。
    • eps:float类型数据,学习率的最小变化值。如果调整后的学习率和调整前的差距小于eps的话,那么就不做任何调整,默认为1e-8。

    举例:

    optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min',patience=5)
    
    scheduler.step(loss)
    

    image-20210823225630101

    LAST 参考文献

    pytorch 模型不同层设置不同的学习率 - 华为云

    PyTorch中设置学习率衰减的方法/torch.optim.lr_scheduler/learning_rate_decay - 知乎

    Pytorch动态调整学习率的方法详解及示例_风雪夜归人o的博客-CSDN博客

    torch.optim — PyTorch 1.9.0 documentation

    pytorch 动态调整学习率 - 超杰

    Pytorch中,动态调整学习率、不同层设置不同学习率和固定某些层训练的方法_我的博客有点东西-CSDN博客

    展开全文
  • PyTorch学习之六个学习率调整策略

    万次阅读 多人点赞 2018-12-24 22:06:38
    PyTorch学习率调整策略通过torch.optim.lr_scheduler接口实现。PyTorch提供的学习率调整策略分为三大类,分别是 有序调整:等间隔调整(Step),按需调整学习率(MultiStep),指数衰减调整(Exponential)和 余弦退火...

    PyTorch学习率调整策略通过torch.optim.lr_scheduler接口实现。PyTorch提供的学习率调整策略分为三大类,分别是

    a. 有序调整:等间隔调整(Step),按需调整学习率(MultiStep),指数衰减调整(Exponential)和 余弦退火CosineAnnealing。
    b. 自适应调整:自适应调整学习率 ReduceLROnPlateau。
    c. 自定义调整:自定义调整学习率 LambdaLR。

    1 等间隔调整学习率 StepLR

    等间隔调整学习率,调整倍数为 gamma 倍,调整间隔为 step_size。间隔单位是step。需要注意的是, step 通常是指 epoch,不要弄成 iteration 了。

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

    参数:

    step_size(int)- 学习率下降间隔数,若为 30,则会在 30、 60、 90…个 step 时,将学习率调整为 lr*gamma。
    gamma(float)- 学习率调整倍数,默认为 0.1 倍,即下降 10 倍。
    last_epoch(int)- 上一个 epoch 数,这个变量用来指示学习率是否需要调整。当last_epoch 符合设定的间隔时,就会对学习率进行调整。当为-1 时,学习率设置为初始值。

    2 按需调整学习率 MultiStepLR

    按设定的间隔调整学习率。这个方法适合后期调试使用,观察 loss 曲线,为每个实验定制学习率调整时机。

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

    参数:

    milestones(list)- 一个 list,每一个元素代表何时调整学习率, list 元素必须是递增的。如 milestones=[30,80,120]
    gamma(float)- 学习率调整倍数,默认为 0.1 倍,即下降 10 倍。

    3 指数衰减调整学习率 ExponentialLR

    按指数衰减调整学习率,调整公式: l r = l r ∗ g a m m a ∗ ∗ e p o c h lr = lr * gamma**epoch lr=lrgammaepoch

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

    参数:

    gamma- 学习率调整倍数的底,指数为 epoch,即 gamma**epoch

    4 余弦退火调整学习率 CosineAnnealingLR

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

    torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)
    

    参数:

    T_max(int)- 一次学习率周期的迭代次数,即 T_max 个 epoch 之后重新设置学习率。
    eta_min(float)- 最小学习率,即在一个周期中,学习率最小会下降到 eta_min,默认值为 0。

    5 自适应调整学习率 ReduceLROnPlateau

    当某指标不再变化(下降或升高),调整学习率,这是非常实用的学习率调整策略。
    例如,当验证集的 loss 不再下降时,进行学习率调整;或者监测验证集的 accuracy,当accuracy 不再上升时,则调整学习率。

    torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
    

    参数:

    mode(str)- 模式选择,有 min 和 max 两种模式, min 表示当指标不再降低(如监测loss), max 表示当指标不再升高(如监测 accuracy)。
    factor(float)- 学习率调整倍数(等同于其它方法的 gamma),即学习率更新为 lr = lr * factor
    patience(int)- 忍受该指标多少个 step 不变化,当忍无可忍时,调整学习率。
    verbose(bool)- 是否打印学习率信息, print(‘Epoch {:5d}: reducing learning rate of group {} to {:.4e}.’.format(epoch, i, new_lr))
    threshold_mode(str)- 选择判断指标是否达最优的模式,有两种模式, rel 和 abs。
    当 threshold_mode == rel,并且 mode == max 时, dynamic_threshold = best * ( 1 +threshold );
    当 threshold_mode == rel,并且 mode == min 时, dynamic_threshold = best * ( 1 -threshold );
    当 threshold_mode == abs,并且 mode== max 时, dynamic_threshold = best + threshold ;
    当 threshold_mode == rel,并且 mode == max 时, dynamic_threshold = best - threshold;

    threshold(float)- 配合 threshold_mode 使用。
    cooldown(int)- “冷却时间“,当调整学习率之后,让学习率调整策略冷静一下,让模型再训练一段时间,再重启监测模式。
    min_lr(float or list)- 学习率下限,可为 float,或者 list,当有多个参数组时,可用 list 进行设置。
    eps(float)- 学习率衰减的最小值,当学习率变化小于 eps 时,则不调整学习率。

    6 自定义调整学习率 LambdaLR

    为不同参数组设定不同学习率调整策略。调整规则为,

    l r = b a s e _ l r ∗ l m b d a ( s e l f . l a s t _ e p o c h ) lr = base\_lr *lmbda(self.last\_epoch) lr=base_lrlmbda(self.last_epoch)

    fine-tune 中十分有用,我们不仅可为不同的层设定不同的学习率,还可以为其设定不同的学习率调整策略。

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

    参数:

    lr_lambda(function or list)- 一个计算学习率调整倍数的函数,输入通常为 step,当有多个参数组时,设为 list。

    展开全文
  • reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=1, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0)
  • Keras提供两种学习率适应方法,可通过回调函数实现。 1. LearningRateScheduler keras.callbacks.LearningRateScheduler(sched...
  • 自定义学习率变化函数 "" 一: 定义学习率和epoch的关系 "" # Learning Rate Schedule def lr_schedule(epoch): lr = 1e-3 if epoch > 180: lr *= 0.5e-3 elif epoch > 160: lr *= 1e-3 elif epoch &...
  • pytorch调整训练学习率方法

    千次阅读 2019-12-03 11:06:40
    PyTorch学习率调整策略通过torch.optim.lr_scheduler接口实现。PyTorch提供的学习率调整策略分为三大类,分别是 a. 有序调整:等间隔调整(Step),按需调整学习率(MultiStep),指数衰减调整(Exponential)和 余弦退火...
  • Keras中调整学习率的方法 通过回调函数callbacks,keras有两种调整训练过程学习率的方法: 第一种 LearningRateScheduler: keras.callbacks.LearningRateScheduler(schedule) ''' 该回调函数是学习率调度器. 参数...
  • pytorch动态调整学习率

    千次阅读 2018-12-03 15:24:40
    自定义根据 epoch 改变学习率。 这种方法在开源代码中常见,此处引用 pytorch 官方实例中的代码 adjust_lr def adjust_learning_rate(optimizer, epoch): &quot;&quot;&quot;Sets the learning ...
  • 【Tensorflow】设置自动衰减的学习率

    千次阅读 2018-05-22 11:05:56
    在训练神经网络的过程中,合理的设置学习率是一个非常重要的事情。对于训练一开始的时候,设置一个大的学习率,可以快速进行迭代,在训练后期,设置小的学习率有利于模型收敛和稳定性。 tf.train.exponential_decay...
  • Pytorch 中的学习率调整方法 Pytorch中的学习率调整有两种方式: 直接修改optimizer中的lr参数; 利用lr_scheduler()提供的几种衰减函数 1. 修改optimizer中的lr: import torch import matplotlib.pyplot as ...
  • torch.optim.lr_scheduler模块提供了一些根据epoch训练次数来调整学习率(learning rate)的方法。学习率调整应该是在优化器更新之后。常见的学习率调整策略有几种: 1、LambdaLR 将每个参数组的学习率设置为初始...
  • 深度学习的学习率调节实践

    千次阅读 2020-08-26 21:45:06
    作者|Luke Newman 编译|VK 来源|Towards Data Science 多层感知器 多层感知器(MLP)是由一个输入层...在这项调查中,我们将在MNIST时尚数据集上训练一个深度MLP,并通过指数增长来寻找最佳学习率,绘制损失图,并找到
  • 深度学习的训练过程中,经常需要动态调整学习率同时保存最佳模型,本教程使用 Keras 框架,通过其自设的回调函数,实现所需 Keras使用手册网址:Keras Documentation(英文版)Keras 中文文档(中文版) 中文版的...
  • 分层学习率设置和学习率衰减(pytorch) 1 分层学习率设置 在使用bert或者其它预训练模型进行微调,下接其它具体任务相关的模块时,会面临这样一个问题,bert由于已经进行了预训练,参数已经达到了一个较好的水平,...
  • 有篇文章总结的很全面,下面将其贴出来: 传送门:pytorch中的学习率调整函数
  • pytorch调整学习率的lr_scheduler机制

    千次阅读 2019-11-06 16:18:22
    有的时候需要我们通过一定机制来调整学习率,这个时候可以借助于torch.optim.lr_scheduler类来进行调整;一般地有下面两种调整策略:(通过两个例子来展示一下) 两种机制:LambdaLR机制和StepLR机制; (1)...
  • 学习率主要用在神经网络的反向传播中,用来调节参数,但学习率的选取很重要,当学习率选取过大时,如下图黄线所示,参数会跳过使损失函数最低的参数,这样有可能使损失变得更大,而选取较小时,网络的训练时间会比较...
  • 调整模型中学习率的方法主要有: 一种是修改optimizer.param_groups中对应的学习率 另一种是新建优化器 注意:由于optimizer十分轻量级,构建开销很小,故可以构建新的optimizer。但新建优化器会重新初始化动量等...
  • Pytorch官方英文文档:...1. 写在前面 疫情在家的这段时间,想系统的学习一遍Pytorch基础知识,因为我发现虽然直接Pytorch实战上手比较快,但是关于一些内部的原理知识其实并不是太懂,这样...
  • tensorflow学习率控制及调试

    千次阅读 2019-05-04 16:37:22
    在深度学习中,学习率变化对模型收敛的结果影响很大,因此很多时候都需要控制学习率的变化。本文以tensorflow实现learning rate test为例,讲述学习率变化控制的方法,以及怎么调试。 一、learning rate test 学习率...
  • Keras提供两种学习率调整方法,都是通过回调函数来实现。 LearningRateScheduler ReduceLROnPlateau 1. LearningRateScheduler keras.callbacks.LearningRateScheduler(schedule) 学习速率定时器,也就是说,定的...
  • YOLOv3学习率

    千次阅读 2019-10-21 08:55:27
    YOLOv3官方版本的学习率配置信息在模型配置文件 *.cfg file 中: learning_rate: 标准学习率 burn_in: 学习率从 0 上升到 learning_rate 的 batch 数目 max_batches: 需要进行训练的 batch 数目 policy: 学习率...
  • 一、学习率概念 学习率是个抽象又简单的概念,神经网络的学习率指的是神经网络对数据进行学习的速率。神经网络学习的过程就是权重更新的过程,权重更新公式如下,其中η表示学习率: 其原理我们已经在上一篇...
  • 深度学习之自适应学习率算法

    万次阅读 2018-06-08 18:29:07
    前言 神经网络研究员早就意识到学习率肯定是难以设置的超参数之一,因为它...如果我们相信方向敏感度在某种程度是轴对齐的,那么每个参数设置不同的学习率,在整个学习过程中自动适应这些学习率是有道理的。Delta-b...
  • 为了克服设备的困难,最近关于学习率方面有一些心得。 我的调参哲学大概是先给一个特别大的学习率(大到模型只要不崩就行),跑一百多epoch,看一下大概什么位置比较好; (跑的过程中可以存下效果top5的模型,用作...
  • 深度学习100问之学习率衰减

    千次阅读 2019-05-26 18:14:49
    目录前言如何使用本教程常用的学习率衰减指数衰减实例对比推荐代码总结参考文章 前言 最近在进行神经网络的训练的时候,经常会遇到这种情况:在多次进行训练尝试之后,为了平衡模型的训练速度和损失大小,选择了一个...
  • 【机器学习】深度学习自适应学习率momentum动量nesterov动量AdamgradRmspropAdam momentum动量 nesterov动量 Adamgrad Rmsprop Adam
  • 深度学习——学习率衰减(learning rate decay)

    万次阅读 多人点赞 2018-09-08 16:03:28
    学习率衰减(learning rate decay) 为了防止学习率过大,在收敛到全局最优点的时候会来回摆荡,所以要让学习率随着训练轮数不断按指数级下降,收敛梯度下降的学习步长。 学习率衰减可以用以下代码实现 decayed_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,845
精华内容 37,538
关键字:

自动调整学习率