speechbrain.nnet.schedulers 模块

用于更新超参数（如学习率）的调度器。

作者

Mirco Ravanelli 2020
Peter Plantinga 2020
Loren Lugosch 2020
Shucong Zhang 2023

摘要

类

`CyclicCosineScheduler`	这是带有预热 (warmup) 的 Cyclic-Cosine 学习率调度器的实现。
`CyclicLRScheduler`	这实现了循环学习率策略 (CLR)。
`IntervalScheduler`	一个简单的调度器实现，在达到特定步数后将学习率设置为特定值。
`InverseSquareRootScheduler`	Inverse Square Root 调度器，定义见 T5 论文 https://arxiv.org/pdf/1910.10683.pdf
`LinearNoamScheduler`	这是 Squeezeformer 论文中扩展 Noam 调度器的实现。
`LinearScheduler`	采用线性退火技术的调度器。
`LinearWarmupScheduler`	创建一个调度器，其学习率在预热期（在此期间学习率从 0 线性增加到优化器中设置的初始学习率）结束后，从优化器中设置的初始学习率线性下降到 0。
`NewBobScheduler`	采用 new-bob 技术的调度器，用于 LR 退火。
`NoamIntervalScheduler`	Noam 调度器和 Interval 调度器的组合。
`NoamScheduler`	这是 transformer 学习率调度器（带有预热）的实现。参考文献: https://arxiv.org/abs/1706.03762
`ReduceLROnPlateau`	学习率调度器，如果在高原期目标损失函数停滞不前或开始增加，则降低学习率。
`ScheduledLoss`	一个方便的类，用于按计划切换到不同的损失函数
`StepScheduler`	采用步进退火技术的学习率调度器。
`TriStageLRSchedule`	线性预热，然后非常缓慢地衰减，并在训练结束时再次线性冷却。
`WarmAndExpDecayLRSchedule`	线性预热，然后在 'total_steps' 步内指数衰减到 ('lr' / 'decay_factor')。
`WarmCoolDecayLRSchedule`	线性预热，然后非常缓慢地衰减，并在训练结束时再次线性冷却。

函数

update_learning_rate

更改优化器中的学习率值。

参考

speechbrain.nnet.schedulers.update_learning_rate(optimizer, new_lr, param_group=None)[源码]

更改优化器中的学习率值。

参数:

optimizer (torch.optim 对象) – 更新此优化器的学习率。
new_lr (float) – 用于学习率的新值。
param_group (list of int) – 要更新的参数组索引。如果未提供，则更新所有组。

示例

>>> from torch.optim import SGD
>>> from speechbrain.nnet.linear import Linear
>>> model = Linear(n_neurons=10, input_size=10)
>>> optimizer = SGD(model.parameters(), lr=0.1)
>>> update_learning_rate(optimizer, 0.2)
>>> optimizer.param_groups[0]["lr"]
0.2

class speechbrain.nnet.schedulers.WarmAndExpDecayLRSchedule(lr, n_warmup_steps, total_steps, decay_factor=0.1)[源码]

基类: object

线性预热，然后在 ‘total_steps’ 步内指数衰减到 (‘lr’ / ‘decay_factor’)。

参数:

lr (float) – 预热后达到的最大学习率。
n_warmup_steps (int) – 预热步数（遵循线性增加）。
total_steps (int) – 总步数（用于衰减）。
decay_factor (float) – 每 decay_every 步应用的衰减因子。(默认值: 0.01)

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler = WarmAndExpDecayLRSchedule(lr=1, n_warmup_steps=2, decay_factor=0.01, total_steps=6)
>>> scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.0
>>> scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.5
>>> scheduler(optim)
>>> optim.param_groups[0]["lr"]
1
>>> scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.31622776601683794

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False, device=None)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.NewBobScheduler(initial_value, annealing_factor=0.5, improvement_threshold=0.0025, patient=0)[源码]

基类: object

采用 new-bob 技术的调度器，用于 LR 退火。

学习率根据验证性能进行退火。具体来说：如果 (past_loss-current_loss)/past_loss < impr_threshold: lr = lr * annealing_factor。

参数:

initial_value (float) – 初始超参数值。
annealing_factor (float) – 在 new_bob 策略中使用的退火因子。
improvement_threshold (float) – 用于在 new_bob 策略中执行学习退火的损失之间的改进率。
patient (int) – 当退火条件被违反 patient 次后，学习率最终被降低。

示例

>>> scheduler = NewBobScheduler(initial_value=1.0)
>>> scheduler(metric_value=10.0)
(1.0, 1.0)
>>> scheduler(metric_value=2.0)
(1.0, 1.0)
>>> scheduler(metric_value=2.5)
(1.0, 0.5)

__call__(metric_value)[源码]

返回超参数的当前值和新值。

参数:: metric_value (int) – 用于确定是否更改超参数值的数字。
返回类型:: 当前和新的超参数值。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.LinearScheduler(initial_value, final_value, epoch_count)[源码]

基类: object

采用线性退火技术的调度器。

学习率在指定数量的 epoch 内线性衰减。

参数:

initial_value (float) – 初始化时的值。
final_value (float) – 当 epoch 计数达到 epoch_count - 1 时使用的值。
epoch_count (int) – Epoch 数。

示例

>>> scheduler = LinearScheduler(1.0, 0.0, 4)
>>> scheduler(current_epoch=1)
(1.0, 0.666...)
>>> scheduler(current_epoch=2)
(0.666..., 0.333...)
>>> scheduler(current_epoch=3)
(0.333..., 0.0)
>>> scheduler(current_epoch=4)
(0.0, 0.0)

__call__(current_epoch)[源码]

返回超参数的当前值和新值。

参数:: current_epoch (int) – 数据集已迭代的次数。
返回类型:: 当前和新的超参数值。

class speechbrain.nnet.schedulers.LinearWarmupScheduler(initial_value, num_warmup_steps, num_training_steps)[源码]

基类: object

创建一个调度器，其学习率在预热期（在此期间学习率从 0 线性增加到优化器中设置的初始学习率）结束后，从优化器中设置的初始学习率线性下降到 0。* Ge Li 2022

参数:

initial_value (float) – 初始化时的值 (lr0)。
num_warmup_steps (int) – 预热步数。学习率在 num_warmup_steps + 1 步时达到 lr0。
num_training_steps (int) – 总训练步数。

示例

>>> scheduler = LinearWarmupScheduler(1.0, 2, 4)
>>> scheduler.get_next_value()
0.0
>>> scheduler.get_next_value()
0.5
>>> scheduler.get_next_value()
1.0
>>> scheduler.get_next_value()
0.5
>>> scheduler.get_next_value()
0.0

calculate_lr(current_step)[源码]

返回超参数的当前值和新值。

参数:: current_step (int) – 模型已更新的步数。
返回类型:: 当前和新的超参数值。

get_next_value()[源码]: 返回超参数的下一个学习率值。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.StepScheduler(initial_value, decay_factor=None, decay_drop=None, half_life=None)[源码]

基类: object

采用步进退火技术的学习率调度器。

超参数的值会随着 epoch 以选定的 epoch_decay 因子衰减。

value = init_value * decay_factor ^ floor((1 + epoch) / decay_drop)

参数:

initial_value (float) – 正在更新的超参数的初始值。
decay_factor (float) – 与 initial_value 相乘的因子
decay_drop (float) – 退火因子（decay_drop 值越高，超参数值衰减越快）。
half_life (int) – 一个方便的参数，用于设置 decay_factor，使得参数在指定 epoch 时下降到其值的一半。不能与 decay_factor 或 decay_drop 同时使用

示例

>>> scheduler = StepScheduler(initial_value=1.0)
>>> scheduler(current_epoch=1)
(1.0, 0.5)
>>> scheduler(current_epoch=2)
(0.5, 0.5)
>>> scheduler(current_epoch=3)
(0.5, 0.25)

DEFAULT_DECAY_FACTOR = 0.5

DEFAULT_DECAY_DROP = 2

__call__(current_epoch)[源码]

返回当前和新的超参数值。

参数:: current_epoch (int) – 数据集已迭代的次数。
返回类型:: 当前和新的超参数值。

class speechbrain.nnet.schedulers.NoamScheduler(lr_initial, n_warmup_steps, model_size=None)[源码]

基类: object

这是 transformer 学习率调度器（带有预热）的实现。参考文献: https://arxiv.org/abs/1706.03762

注意: 此调度器在模型权重每次更新时都会退火学习率，并且必须保存 n_steps 以供重新启动。

参数:

lr_initial (float) – 初始学习率（即 epoch 0 使用的学习率）。
n_warmup_steps (int) – 预热步数
model_size (int) – transformer embed_dim 的大小。用于缩放调度器达到的最大学习率值。它被 model_size ** (0.5) 除。如果未指定，则最大学习率值改为乘以 warmup_steps ** (0.5)。

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler =NoamScheduler(optim.param_groups[0]["lr"], 3)
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.3333333333333333
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.6666666666666666
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.9999999999999999

__call__(opt)[源码]

参数:

opt (optimizer) – 使用此调度器更新的优化器。

返回:

current_lr (float) – 更新前的学习率。
lr (float) – 更新后的学习率。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.NoamIntervalScheduler(lr_initial, n_warmup_steps, anneal_steps, anneal_rates, model_size=None)[源码]

基类: object

Noam 调度器和 Interval 调度器的组合。此调度器行为类似于 Noam 调度器，并在设计的步数以设计的衰减率进行学习率退火。

注意: 此调度器在模型权重每次更新时都会退火学习率，并且必须保存 n_steps 以供重新启动。

参数:

lr_initial (float) – 初始学习率（即 epoch 0 使用的学习率）。
n_warmup_steps (int) – 预热步数。
anneal_steps (list) – 预先设计的学习率需要退火的步数。
anneal_rates (list) – 每个退火步的预先设计的衰减率。
model_size (int) – transformer embed_dim 的大小。用于缩放调度器达到的最大学习率值。它被 model_size ** (0.5) 除。如果未指定，则最大学习率值改为乘以 warmup_steps ** (0.5)。

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler = NoamIntervalScheduler(
...    lr_initial=optim.param_groups[0]["lr"],
...    n_warmup_steps=3,
...    anneal_steps=[6, 9],
...    anneal_rates=[0.5, 0.1],
... )
>>> for _ in range(10):
...     curr_lr,next_lr=scheduler(optim)
...     print(optim.param_groups[0]["lr"])
0.3333333333333333
0.6666666666666666
0.9999999999999999
0.8660254037844386
0.7745966692414833
0.7071067811865475
0.3273268353539886
0.3061862178478973
0.28867513459481287
0.027386127875258306

__call__(opt)[源码]

参数:

opt (optimizer) – 使用此调度器更新的优化器。

返回:

current_lr (float) – 更新前的学习率。
lr (float) – 更新后的学习率。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False, device=None)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.LinearNoamScheduler(lr_initial, n_warmup_steps, n_keep_steps)[源码]

基类: object

这是 Squeezeformer 论文中扩展 Noam 调度器的实现。参考文献: https://arxiv.org/pdf/2206.00888.pdf

注意: 此调度器在模型权重每次更新时都会退火学习率，并且必须保存 n_steps 以供重新启动。

参数:

lr_initial (float) – 初始学习率（即 epoch 0 使用的学习率）。
n_warmup_steps (int) – 预热步数。
n_keep_steps (int) – 预热步数后，学习率保持不变的步数。

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler =LinearNoamScheduler(optim.param_groups[0]["lr"], 2, 2)
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.5
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
1.0
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
1.0
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
1.0
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.6666666666666666

__call__(opt)[源码]

参数:

opt (optimizer) – 使用此调度器更新的优化器。

返回:

current_lr (float) – 更新前的学习率。
lr (float) – 更新后的学习率。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False, device=None)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.CyclicCosineScheduler(n_warmup_steps, lr_initial=None, total_steps=100000)[源码]

基类: object

这是带有预热 (warmup) 的 Cyclic-Cosine 学习率调度器的实现。

参考文献: https://openreview.net/pdf?id=BJYwwY9ll

注意: 此调度器在模型权重每次更新时都会退火学习率，并且必须保存 n_steps 以供重新启动。

参数:

n_warmup_steps (int) – 预热步数。
lr_initial (float) – 初始学习率（即 epoch 0 使用的学习率）。
total_steps (int) – 总更新步数。

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler =CyclicCosineScheduler(3, optim.param_groups[0]["lr"])
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.9999999990130395
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
0.9999999997532598
>>> curr_lr,next_lr=scheduler(optim)
>>> optim.param_groups[0]["lr"]
1.0

__call__(opt)[源码]

参数:

opt (optimizer 列表) – 使用此调度器更新的优化器。

返回:

current_lr (float) – 更新前的学习率。
lr (float) – 更新后的学习率。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.ReduceLROnPlateau(lr_min=1e-08, factor=0.5, patience=2, dont_halve_until_epoch=65)[源码]

基类: object

学习率调度器，如果在高原期目标损失函数停滞不前或开始增加，则降低学习率。与 NewBobLRScheduler 的不同之处在于，此调度器会记录未观察到改进的最后一步，并与该特定损失值进行比较，而不是与最近的损失进行比较。

参数:

lr_min (float) – 允许的最小学习率。
factor (float) – 用于降低学习率的因子。
patience (int) – 在降低学习率之前等待的 epoch 数。
dont_halve_until_epoch (int) – 等待直到减半的 epoch 数。

示例

>>> from torch.optim import Adam
>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(n_neurons=10, input_size=3)
>>> optim = Adam(lr=1.0, params=model.parameters())
>>> output = model(inp_tensor)
>>> scheduler = ReduceLROnPlateau(0.25, 0.5, 2, 1)
>>> curr_lr,next_lr=scheduler([optim],current_epoch=1, current_loss=10.0)
>>> curr_lr,next_lr=scheduler([optim],current_epoch=2, current_loss=11.0)
>>> curr_lr,next_lr=scheduler([optim],current_epoch=3, current_loss=13.0)
>>> curr_lr,next_lr=scheduler([optim],current_epoch=4, current_loss=14.0)
>>> next_lr
0.5

__call__(optim_list, current_epoch, current_loss)[源码]

参数:

optim_list (optimizer 列表) – 使用此调度器更新的优化器。
current_epoch (int) – 数据集已迭代的次数。
current_loss (int) – 用于确定是否更改学习率的数字。

返回:

current_lr (float) – 更新前的学习率。
next_lr (float) – 更新后的学习率。

save(path)[源码]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[源码]: 加载所需信息。

class speechbrain.nnet.schedulers.CyclicLRScheduler(base_lr=0.001, max_lr=0.006, step_size=2000.0, mode='triangular', gamma=1.0, scale_fn=None, scale_mode='cycle')[源码]

基类: object

这实现了循环学习率策略 (CLR)。该方法以固定的频率在两个边界之间循环学习率，详细信息参见这篇论文 (https://arxiv.org/abs/1506.01186)。循环的幅度可以按每次迭代或每个循环进行缩放。

该类有三种内置策略，如论文所述。“triangular”

基本三角形循环，无幅度缩放。

“triangular2”: 基本三角形循环，每个循环将初始幅度减半。
“exp_range”: 一个循环，在每次循环迭代时按 gamma**(循环迭代次数) 缩放初始幅度。

更多详情，请参阅参考文献。

参数:

base_lr (float) – 初始学习率，即循环中的下界。
max_lr (float) – 循环中的上界。功能上，它定义了循环幅度 (max_lr - base_lr)。任何循环的学习率是 base_lr 和幅度的一些缩放的总和；因此，实际可能无法达到 max_lr，具体取决于缩放函数。
step_size (int) – 每半个循环的训练迭代次数。作者建议将 step_size 设置为 epoch 训练迭代次数的 2-8 倍。
模式 (str) – {triangular, triangular2, exp_range} 之一。默认值 ‘triangular’。值对应于上面详述的策略。如果 scale_fn 不是 None，则忽略此参数。
gamma (float) – ‘exp_range’ 缩放函数中的常数：gamma**(cycle iterations)
scale_fn (lambda 函数) – 由一个单参数 lambda 函数定义的自定义缩放策略，其中对于所有 x >= 0，都有 0 <= scale_fn(x) <= 1。忽略 mode 参数。
scale_mode (str) – {‘cycle’, ‘iterations’}。定义 scale_fn 是根据周期数还是周期迭代次数（自周期开始以来的训练迭代次数）进行评估。默认值是 ‘cycle’。

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler = CyclicLRScheduler(base_lr=0.1, max_lr=0.3, step_size=2)
>>> scheduler.on_batch_end(optim)
>>> optim.param_groups[0]["lr"]
0.2
>>> scheduler.on_batch_end(optim)
>>> optim.param_groups[0]["lr"]
0.3
>>> scheduler.on_batch_end(optim)
>>> optim.param_groups[0]["lr"]
0.2

clr(clr_iterations)[source]: 清除迭代次数。

on_batch_end(opt)[source]

参数:: opt (optimizers) – 使用此调度器更新的优化器。

save(path)[source]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[source]: 加载所需信息。

class speechbrain.nnet.schedulers.IntervalScheduler(intervals)[source]

基类: object

一个简单的调度器实现，在达到特定步数后将学习率设置为特定值。

参数:: intervals (list) – 字典列表： {“steps”: <步数>, “lr”: 学习率} ‘steps’ 表示应用给定学习率时的全局步数。

示例

>>> import torch
>>> from speechbrain.nnet.schedulers import IntervalScheduler
>>> from speechbrain.nnet.linear import Linear
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> scheduler = IntervalScheduler(
...    intervals=[
...        {"steps": 2, "lr": 0.01},
...        {"steps": 5, "lr": 0.005},
...        {"steps": 9, "lr": 0.001}
...    ]
... )
>>> optim.param_groups[0]["lr"]
1
>>> for _ in range(10):
...     pre, post = scheduler(optim)
...     print(f"{pre} -> {post}")
1 -> 1
1 -> 0.01
0.01 -> 0.01
0.01 -> 0.01
0.01 -> 0.005
0.005 -> 0.005
0.005 -> 0.005
0.005 -> 0.005
0.005 -> 0.001
0.001 -> 0.001

__call__(opt)[source]

参数:

opt (optimizer) – 使用此调度器更新的优化器。

返回:

current_lr (float) – 更新前的学习率。
lr (float) – 更新后的学习率。

save(path)[source]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[source]: 加载所需信息。

class speechbrain.nnet.schedulers.InverseSquareRootScheduler(warmup_steps)[source]

基类: object

Inverse Square Root 调度器，定义见 T5 论文 https://arxiv.org/pdf/1910.10683.pdf

参数:: warmup_steps (int) – 学习率保持常数的步数。

__call__(opt)[source]

返回当前和新的超参数值。

参数:: opt (optimizer) – 使用此调度器更新的优化器。
返回类型:: 当前和新的超参数值

save(path)[source]: 将当前指标保存到指定路径。

class speechbrain.nnet.schedulers.WarmCoolDecayLRSchedule(lr, warmup, cooldown, total_steps, decay_factor=0.75, decay_every=100000)[source]

基类: object

线性预热，非常缓慢地衰减，并在训练结束时再次线性冷却。这是一个三步调度器。

参考

Scaling Vision Transformers arxiv.org/abs/2106.04560

参数 lr:: 预热后达到的最大学习率。
类型 lr:: float
参数 warmup:: 预热步数（呈线性增加）。
类型 warmup:: int
参数 cooldown:: 冷却步数（呈线性减少）。
类型 cooldown:: int
参数 total_steps:: 总步数（用于衰减）。
类型 total_steps:: int
参数 decay_factor:: 每隔 decay_every 步应用的衰减因子。
类型 decay_factor:: float
参数 decay_every:: 每隔 decay_every 步将衰减因子应用于学习率。
类型 decay_every:: int

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler = WarmCoolDecayLRSchedule(lr=1, warmup=2, total_steps=6, decay_factor=0.5, decay_every=1, cooldown=1)
>>> optim.param_groups[0]["lr"]
1
>>> scheduler(optim, 1)
>>> optim.param_groups[0]["lr"]
0.5
>>> scheduler(optim, 2)
>>> optim.param_groups[0]["lr"]
1.0
>>> scheduler(optim, 3)
>>> optim.param_groups[0]["lr"]
0.5
>>> scheduler(optim, 4)
>>> optim.param_groups[0]["lr"]
0.25
>>> scheduler(optim, 5)
>>> optim.param_groups[0]["lr"]
0.12500000000000003
>>> scheduler(optim, 6)
>>> optim.param_groups[0]["lr"]
0.0

save(path)[source]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False)[source]: 加载所需信息。

class speechbrain.nnet.schedulers.ScheduledLoss(schedule)[source]

基类： Module

一个方便的类，用于按计划切换到不同的损失函数

参数:

schedule (list) – 包含以下键的字典列表

loss_fn: 要使用的损失函数 steps: 在切换到下一个损失函数之前应用的步数: （这是对前一行的补充）

到下一个

示例

>>> loss_fn = ScheduledLoss(
...     schedule=[
...         {"steps": 3, "loss_fn": nn.MSELoss()},
...         {"steps": 2, "loss_fn": nn.L1Loss()},
...         {"loss_fn": nn.SmoothL1Loss()}
...     ]
... )
>>> x = torch.tensor([1., 2.])
>>> y = torch.tensor([1.5, 2.5])
>>> for idx in range(10):
...     loss = loss_fn(x, y)
...     print(loss.item())
0.25
0.25
0.25
0.5
0.5
0.125
0.125
0.125
0.125
0.125

forward(*args, **kwargs)[source]

计算指定步数的损失。

参数:

*args (tuple)
**kwargs (dict) – 传递给此方法的任何参数都将传递给指定的 loss_fn

返回:

结果 – 损失值

返回类型:

torch.Tensor

save(path)[source]: 将当前状态保存到指定路径。

load(path, end_of_epoch=False, device=None)[source]: 加载所需信息。

find_next_switch()[source]: 根据调度查找下一个切换将发生的阈值

class speechbrain.nnet.schedulers.TriStageLRSchedule(lr, warmup_steps, hold_steps, decay_steps, total_steps, init_lr_scale=0.01, final_lr_scale=0.05)[source]

基类: object

在训练结束时线性预热，非常缓慢地衰减，然后再次线性冷却。这是一个三阶段调度器。参考 https://arxiv.org/pdf/1904.08779.pdf

参数:

lr (float) – 预热后达到的最大学习率。
warmup_steps (int) – 预热步数（呈线性增加）。
hold_steps (int) – 保持步数（学习率保持不变）。
decay_steps (int) – 衰减步数。
total_steps (int) – 总步数（用于衰减）。
init_lr_scale (float) – 预热阶段的初始学习率比例。
final_lr_scale (float) – 最终学习率比例。

示例

>>> from speechbrain.nnet.linear import Linear
>>> inp_tensor = torch.rand([1,660,3])
>>> model = Linear(input_size=3, n_neurons=4)
>>> optim = torch.optim.Adam(model.parameters(), lr=1)
>>> output = model(inp_tensor)
>>> scheduler = TriStageLRSchedule(lr=1, warmup_steps=2, hold_steps=2, decay_steps=2, total_steps=6, init_lr_scale=0.01, final_lr_scale=0.05)
>>> optim.param_groups[0]["lr"]
1
>>> scheduler(optim, 1)
>>> optim.param_groups[0]["lr"]
0.505
>>> scheduler(optim, 2)
>>> optim.param_groups[0]["lr"]
1
>>> scheduler(optim, 3)
>>> optim.param_groups[0]["lr"]
1
>>> scheduler(optim, 4)
>>> optim.param_groups[0]["lr"]
1.0
>>> scheduler(optim, 5)
>>> optim.param_groups[0]["lr"]
0.223606797749979
>>> scheduler(optim, 6)
>>> optim.param_groups[0]["lr"]
0.05000000000000001

__call__(opt, num_updates)[source]: 计算与当前步数 (num_updates) 相对应的学习率。

save(path)[source]: 将当前指标保存到指定路径。

load(path, end_of_epoch=False, device=None)[source]: 加载所需信息。