0
0

pytorch-scheduler（调度器）

scheduler简介

schedueler类型

scheduler（调度器）是一种用于调整优化算法中学习率的机制。学习率是控制模型参数更新幅度的关键超参数，而调度器根据预定的策略在训练过程中动态地调整学习率。

优化器负责根据损失函数的梯度更新模型的参数，而调度器则负责调整优化过程中使用的特定参数，通常是学习率。调度器通过调整学习率帮助优化器更有效地搜索参数空间，避免陷入局部最小值，并加快收敛速度。

调度器允许实现复杂的训练策略，学习率预热、周期性调整或突然降低学习率，这些策略对于优化器的性能至关重要。

学习率绘图函数
我们设定一简单的模型，得带100 epoch，绘制迭代过程中loss的变化

  1. import os
  2. import torch
  3. from torch.optim import lr_scheduler
  4. import matplotlib.pyplot as plt
  6. # 模拟训练过程，每循环一次更新一次学习率defget_lr_scheduler(optim, scheduler, total_step):'''
  7.     get lr values
  8.     '''
  9.     lrs =[]for step inrange(total_step):
  10.         lr_current = optim.param_groups[0]['lr']
  11.         lrs.append(lr_current)if scheduler isnotNone:
  12.             scheduler.step()return lrs
  13. # 将损失函数替换为学习率，模拟根据损失函数进行自适调整的学习率变化 defget_lr_scheduler1(optim, scheduler, total_step):'''
  14.     get lr values
  15.     '''
  16.     lrs =[]for step inrange(total_step):
  17.         lr_current = optim.param_groups[0]['lr']
  18.         lrs.append(lr_current)if scheduler isnotNone:
  19.             scheduler.step(lr_current)return lrs

余弦拟退火（CosineAnnealingLR）

torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1, verbose=‘deprecated’)
cosine形式的退火学习率变化机制，顾名思义，学习率变化曲线是cos形式的，定义一个正弦曲线需要四个参数，周期、最大最小值、相位。其中周期=2T_max，eta_min周期函数的峰值，last_epoch表示加载模型的迭代步数，定义cos曲线的初始位置，当它为-1时，参数不生效，初始相位就是0，否则就是last_epochT_max/pi。
在这里插入图片描述当 last_epoch=-1 时，将初始学习率设置为学习率。请注意，由于计划是递归定义的，学习率可以同时被此调度程序之外的其他操作者修改。如果学习率仅由这个调度程序设置，那么每个步骤的学习率变为：
\begin{aligned} \eta_t = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1 + \cos\left(\frac{T_{cur}}{T_{max}}\pi\right)\right) \end{aligned}

  1. defplot_cosine_aneal():
  2.     plt.clf()
  3.     optim = torch.optim.Adam([{'params': model.parameters(),'initial_lr': initial_lr}], lr=initial_lr)
  5.     scheduler = lr_scheduler.CosineAnnealingLR(
  6.         optim, T_max=40, eta_min=0.2)
  7.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  8.     plt.plot(lrs, label='eta_min=0.2,,last epoch=-1')# if not re defined, the init lr will be lrs[-1]
  9.     optim = torch.optim.Adam([{'params': model.parameters(),'initial_lr': initial_lr}], lr=initial_lr)
  10.     scheduler = lr_scheduler.CosineAnnealingLR(
  11.         optim, T_max=40, eta_min=0.2, last_epoch=10)
  12.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  13.     plt.plot(lrs, label='eta_min=0.2,,last epoch=10')# eta_min
  14.     scheduler = lr_scheduler.CosineAnnealingLR(
  15.         optim, T_max=40, eta_min=0.5, last_epoch=10)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs, label='eta_min=0.5,,last epoch=10')
  19.     plt.title('CosineAnnealingLR')
  20.     plt.legend()
  21.     plt.show()
  22. plot_cosine_aneal()

在这里插入图片描述

LambdaLR

torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda = function, last_epoch=- 1, verbose=False)
LambdaLR 可以根据用户定义的 lambda 函数或 lambda 函数列表来调整学习率。当您想要实现标准调度器未提供的自定义学习率计划时，这种调度器特别有用。
Lambda 函数是使用 Python 中的 lambda 关键字定义的小型匿名函数。
Lambda 函数应该接受一个参数（周期索引）并返回一个乘数，学习率将乘以这个乘数。

  1. defplot_lambdalr():
  2.     plt.clf()# Lambda1
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.LambdaLR(
  5.         optim, lr_lambda=lambda step: step%40/100.)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label='lambda step: step%40/100.')#Lambda2
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.LambdaLR(
  10.         optim, lr_lambda=lambda step:max(0,1- step /100))
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label='lambda step: max(0, 1 - step / 100)')
  14.     plt.title('LambdaLR')
  15.     plt.legend()
  16.     plt.show()
  17.     
  18. plot_lambdalr()

在这里插入图片描述

MultiplicativeLR

torch.optim.lr_scheduler.MultiplicativeLR(optimizer, lr_lambda, last_epoch=-1, verbose=‘deprecated’)
学习率在达到特定的epoch时降低，将每个参数组的学习率乘以指定函数给出的因子，通常用于在训练的不同阶段使用不同的学习率。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_multiplicativelr():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.MultiplicativeLR(
  5.         optim, lr_lambda=lambda step:0.9)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='step=0.9')# plt.title('MultiplicativeLR')# plt.show()
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.MultiplicativeLR(
  10.         optim, lr_lambda=lambda step:0.8)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='step=0.8')#
  13.     optim = torch.optim.Adam([{'params': model.parameters(),'initial_lr': initial_lr}], lr=initial_lr)
  14.     scheduler = lr_scheduler.MultiplicativeLR(
  15.         optim, lr_lambda=lambda step:0.8,last_epoch=20)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs,label ='step=0.8,last_epoch=20')
  19.     plt.title('MultiplicativeLR')
  20.     plt.legend()
  21.     plt.show()
  22. plot_multiplicativelr()

在这里插入图片描述

StepLR

torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1, verbose=‘deprecated’)
学习率在预定的周期（epoch）后按固定比例衰减,每 step_size = epoch 个周期将每个参数组的学习率按 gamma 的因子衰减。请注意，这种衰减可能与此调度程序之外对学习率的其他变化同时发生。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_steplr():
  2.     plt.clf()#gamma=0.5
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.StepLR(
  5.         optim, step_size=20, gamma=0.5)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='gamma=0.5')#gamma=0.8
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.StepLR(
  10.         optim, step_size=20, gamma=0.8)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='gamma=0.8')
  14.     plt.title('StepLR')
  15.     plt.legend()
  16.     plt.show()
  17. plot_steplr()

在这里插入图片描述

MultiStepLR

torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=‘deprecated’)
每当达到里程碑中的某个周期数时，将每个参数组的学习率按 gamma 的因子衰减。请注意，这种衰减可能与此调度程序之外对学习率的其他变化同时发生。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_multisteplr():
  2.     plt.clf()#example1
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.MultiStepLR(
  5.         optim, milestones=[50,80], gamma=0.5)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='milestones=[50, 80], gamma=0.5')#example2
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.MultiStepLR(
  10.         optim, milestones=[50,70,90], gamma=0.5)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='milestones=[50, 70,90], gamma=0.5')#example3
  13.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  14.     scheduler = lr_scheduler.MultiStepLR(
  15.         optim, milestones=[50,70,90], gamma=0.8)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs,label ='milestones=[50, 70,90], gamma=0.8')
  18.     plt.title('MultiStepLR')
  19.     plt.legend()
  20.     plt.show()
  21. plot_multisteplr()

在这里插入图片描述

ConstantLR

torch.optim.lr_scheduler.ConstantLR(optimizer, factor=0.3333333333333333, total_iters=5, last_epoch=-1, verbose=‘deprecated’)
将每个参数组的学习率乘以一个小的常数因子，直到周期数达到预定义的里程碑：total_iters。请注意，这种小常数因子的乘法可能与此调度程序之外对学习率的其他变化同时发生。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_constantlr():
  2.     plt.clf()##
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.ConstantLR(
  5.         optim, factor=0.2, total_iters=30)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='factor=0.2, total_iters=30')##
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.ConstantLR(
  10.         optim, factor=0.8, total_iters=30)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='factor=0.8, total_iters=30')
  13.     plt.title('ConstantLR')
  14.     plt.legend()
  15.     plt.show()
  16. plot_constantlr()

在这里插入图片描述

LinearLR

torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.3333333333333333, end_factor=1.0, total_iters=5, last_epoch=-1, verbose=‘deprecated’)
将每个参数组的学习率通过线性变化的小乘法因子进行衰减，直到周期数达到预定义的里程碑：total_iters。请注意，这种衰减可能与此调度程序之外对学习率的其他变化同时发生。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_linearlr():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.LinearLR(
  5.         optim, start_factor=0.5, total_iters=30, end_factor=0.8)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='start_factor=0.5, total_iters=30, end_factor=0.8')##
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.LinearLR(
  10.         optim, start_factor=0.1, total_iters=30, end_factor=0.8)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='start_factor=0.1, total_iters=30, end_factor=0.8')##
  13.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  14.     scheduler = lr_scheduler.LinearLR(
  15.         optim, start_factor=0.1, total_iters=30, end_factor=0.5)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs,label ='start_factor=0.1, total_iters=30, end_factor=0.8')
  19.     plt.title('LinearLR')
  20.     plt.legend()
  21.     plt.show()
  22. plot_linearlr()

在这里插入图片描述

ExponentialLR

torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1, verbose=‘deprecated’)
每个周期将每个参数组的学习率按 gamma 的因子衰减。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_exponential():
  2.     plt.clf()# 
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.ExponentialLR(
  5.         optim, gamma=0.95)
  6.     lrs = get_lr_scheduler(optim, scheduler,100)
  7.     plt.plot(lrs,label ='gamma=0.95')# 
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.ExponentialLR(
  10.         optim, gamma=0.5)
  11.     lrs = get_lr_scheduler(optim, scheduler,100)
  12.     plt.plot(lrs,label ='gamma=0.5')
  13.     plt.title('ExponentialLR')
  14.     plt.legend()
  15.     plt.show()
  16. plot_exponential()

在这里插入图片描述

PolynomialLR

torch.optim.lr_scheduler.PolynomialLR(optimizer, total_iters=5, power=1.0, last_epoch=-1, verbose=‘deprecated’)
使用给定的总迭代次数 total_iters，通过多项式函数对每个参数组的学习率进行衰减。当 last_epoch=-1 时，将初始学习率设置为学习率。

  1. defplot_PolynomialLR():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.PolynomialLR(optim, total_iters=100, power=0.09, last_epoch=-1, verbose='deprecated')
  5.     lrs = get_lr_scheduler(optim, scheduler,100)
  6.     plt.plot(lrs,label ='total_iters=100, power=0.09')##
  7.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  8.     scheduler = lr_scheduler.PolynomialLR(optim, total_iters=50, power=0.9, last_epoch=-1, verbose='deprecated')
  9.     lrs = get_lr_scheduler(optim, scheduler,100)
  10.     plt.plot(lrs,label ='total_iters=50, power=0.09')##
  11.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  12.     scheduler = lr_scheduler.PolynomialLR(optim, total_iters=50, power=0.1, last_epoch=-1, verbose='deprecated')
  13.     lrs = get_lr_scheduler(optim, scheduler,100)
  14.     plt.plot(lrs,label ='total_iters=50, power=0.1')
  16.     plt.title('plot_PolynomialLR')
  17.     plt.legend()
  18.     plt.show()
  19. plot_PolynomialLR()

在这里插入图片描述

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=‘deprecated’)
根据循环学习率策略（CLR）设置每个参数组的学习率。该策略以恒定频率在两个边界之间循环变化学习率，如在论文《Cyclical Learning Rates for Training Neural Networks》中详细描述的那样。两个边界之间的距离可以按每次迭代或每个周期进行缩放。
循环学习率策略在每个批次之后改变学习率。应在使用一个批次进行训练后调用 step() 函数。

  1. defplot_CyclicLR():
  2.     plt.clf()# 
  3.     optim = torch.optim.SGD(model.parameters(), lr=initial_lr, momentum=0.9)
  4.     scheduler = lr_scheduler.CyclicLR(
  5.         optim, base_lr = initial_lr,max_lr=0.1,step_size_up=20,)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='max_lr=0.1,step_size_up=20')# 
  8.     optim = torch.optim.SGD(model.parameters(), lr=initial_lr, momentum=0.9)
  9.     scheduler = lr_scheduler.CyclicLR(
  10.         optim, base_lr = initial_lr,max_lr=0.01,step_size_up=20,)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='max_lr=0.01,step_size_up=20')#
  13.     optim = torch.optim.SGD(model.parameters(), lr=initial_lr, momentum=0.9)
  14.     scheduler = lr_scheduler.CyclicLR(
  15.         optim, base_lr = initial_lr,max_lr=0.01,step_size_up=10,)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs,label ='max_lr=0.01,step_size_up=10')
  19.     plt.title('OneCycleLR')
  20.     plt.legend()
  21.     plt.show()
  22. plot_CyclicLR()

在这里插入图片描述

OneCycleLR

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=‘deprecated’)

  1. defplot_onecyclelr():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.OneCycleLR(
  5.         optim, max_lr=0.001, epochs=10, steps_per_epoch=10, pct_start=0.1)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='pct_start=0.2,s=10,p=0.1')##
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.OneCycleLR(
  10.         optim, max_lr=0.001, epochs=10, steps_per_epoch=10, pct_start=0.5)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='max_lr=0.001,pct_start=0.2,s=10,p=0.5')##
  13.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  14.     scheduler = lr_scheduler.OneCycleLR(
  15.         optim, max_lr=0.005, epochs=10, steps_per_epoch=10, pct_start=0.5)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs,label ='max_lr=0.01,pct_start=0.2,s=10,p=0.5')
  19.     plt.title('OneCycleLR')
  20.     plt.legend()
  21.     plt.show()
  22. plot_onecyclelr()

在这里插入图片描述

CosineAnnealingWarmRestarts

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0, T_mult=1, eta_min=0, last_epoch=-1, verbose=‘deprecated’)

  1. defCosineAnnealingWarmRestarts():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.CosineAnnealingWarmRestarts(
  5.         optim, eta_min=0., T_0=50, T_mult=1)
  6.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  7.     plt.plot(lrs,label ='T_0=50,T_mult=1')#
  8.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  9.     scheduler = lr_scheduler.CosineAnnealingWarmRestarts(
  10.         optim, eta_min=0., T_0=50, T_mult=10)
  11.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  12.     plt.plot(lrs,label ='T_0=50,T_mult=10')#
  13.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  14.     scheduler = lr_scheduler.CosineAnnealingWarmRestarts(
  15.         optim, eta_min=0., T_0=80, T_mult=10)
  16.     lrs = get_lr_scheduler(optim, scheduler, total_step)
  17.     plt.plot(lrs,label ='T_0=80,T_mult=10')
  19.     plt.title('CosineAnnealingWarmRestarts')
  20.     plt.legend()
  21.     plt.show()
  23. CosineAnnealingWarmRestarts()

在这里插入图片描述

ChainedScheduler

torch.optim.lr_scheduler.ChainedScheduler(schedulers)
将学习率调度器列表串联起来。它接受一列表可串联的学习率调度器，并仅通过一次调用连续执行它们各自的 step() 函数。

  1. defplot_ChainedScheduler():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)print(initial_lr)
  4.     scheduler1 = lr_scheduler.LinearLR(
  5.         optim, start_factor=0.2, total_iters=5, end_factor=0.9)# scheduler2 = lr_scheduler.ExponentialLR(#     optim, gamma=0.99)
  6.     scheduler2 = lr_scheduler.OneCycleLR(
  7.         optim, max_lr=0.001, epochs=10, steps_per_epoch=10, pct_start=0.1)
  8.     scheduler = torch.optim.lr_scheduler.ChainedScheduler([scheduler1, scheduler2])# scheduler = lr_scheduler.ExponentialLR(#     optim, gamma=0.95)
  9.     lrs = get_lr_scheduler(optim, scheduler,100)
  10.     plt.plot(lrs)
  12.     plt.title('plot_ChainedScheduler')
  13.     plt.show()
  14. plot_ChainedScheduler()

在这里插入图片描述

SequentialLR

torch.optim.lr_scheduler.SequentialLR(optimizer, schedulers, milestones, last_epoch=-1, verbose=‘deprecated’)
接收预期在优化过程中顺序调用的调度器列表，以及提供确切间隔的里程碑点，这些里程碑点指明在给定周期应该调用哪个调度器。

  1. defplot_SequentialLR():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler1 = lr_scheduler.LinearLR(
  5.         optim, start_factor=0.2, total_iters=10, end_factor=0.9)
  6.     scheduler2 = lr_scheduler.OneCycleLR(
  7.         optim, max_lr=0.01, epochs=10, steps_per_epoch=10, pct_start=0.1)
  8.     scheduler = torch.optim.lr_scheduler.SequentialLR(optim,[scheduler1, scheduler2],milestones =[10])# scheduler = lr_scheduler.ExponentialLR(#     optim, gamma=0.95)
  9.     lrs = get_lr_scheduler(optim, scheduler,100)
  10.     plt.plot(lrs)
  12.     plt.title('SequentialLR')
  13.     plt.show()
  14. plot_SequentialLR()

在这里插入图片描述

ReduceLROnPlateau

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=‘deprecated’)
当性能不再提升时降低学习率”。这是一种学习率调度策略，用于在模型的某个性能指标（如验证集上的损失）不再显著改善时减小学习率，以此来微调模型并防止过拟合。

  1. defplot_ReduceLROnPlateau():
  2.     plt.clf()
  3.     optim = torch.optim.Adam(model.parameters(), lr=initial_lr)
  4.     scheduler = lr_scheduler.ReduceLROnPlateau(optim, mode='min')
  5.     lrs = get_lr_scheduler1(optim, scheduler,100)
  6.     plt.plot(lrs)
  8.     plt.title('ReduceLROnPlateau')
  9.     plt.show()
  10. plot_ReduceLROnPlateau()

在这里插入图片描述
reference1
reference2

标签： pytorch 人工智能 python
本文转载自: https://blog.csdn.net/d8dongdong/article/details/140700673
版权归原作者 云朵不吃雨 所有， 如有侵权，请联系我们删除。
登录后发布评论

“pytorch-scheduler（调度器）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
scheduler简介