speechbrain.nnet.schedulers 模块

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

Authors

• Mirco Ravanelli 2020

• 彼得·普兰廷加 2020

• 洛伦·卢戈斯奇 2020

• 张书聪 2023

摘要

类：

CyclicCosineScheduler	这是一个带有预热的Cyclic-Cosine学习率调度器的实现。
CyclicLRScheduler	这实现了一个循环学习率策略（CLR）。
IntervalScheduler	一个简单的调度器实现，在达到特定步数后将学习率设置为特定值。
InverseSquareRootScheduler	逆平方根调度器，如T5论文中定义的 https://arxiv.org/pdf/1910.10683.pdf
LinearNoamScheduler	这是Squeezeformer论文中扩展的Noam调度器的一个实现。
LinearScheduler	使用线性退火技术的调度器。
LinearWarmupScheduler	创建一个学习率调度器，该调度器在预热期间从0线性增加到优化器中设置的初始学习率，然后在预热期结束后从优化器中设置的初始学习率线性减少到0。
NewBobScheduler	使用new-bob技术的调度器，用于学习率退火。
NoamIntervalScheduler	Noam调度器和Interval调度器的组合。
NoamScheduler	这是一个带有预热的变压器学习率调度器的实现。
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)

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

Parameters:

• optimizer (torch.optim 对象) – 更新此优化器的学习率。

• new_lr (float) – 用于学习率的新值。

• param_group (list of int) – 要更新的参数组索引。如果未提供，则更新所有组。

Example

>>> 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’）。

Parameters:

• lr (float) – 在预热后达到的最大学习率。

• n_warmup_steps (int) – 预热步骤的数量（遵循线性增加）。

• total_steps (int) – 总步数（用于衰减）。

• decay_factor (float) – 每经过decay_every步应用的衰减因子。(默认值: 0.01)

Example

>>> 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

使用新鲍勃技术的调度器，用于学习率退火。

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

Parameters:

• initial_value (float) – 初始超参数值。

• annealing_factor (float) – 这是用于new_bob策略的退火因子。

• improvement_threshold (float) – 这是用于在新Bob策略中执行学习退火的损失之间的改进率。

• patient (int) – 当退火条件被违反 patient 次时，学习率最终会被降低。

Example

>>> 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)

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

Parameters:

metric_value (int) – 用于确定是否更改超参数值的数字。

Return type:

当前和新的超参数值。

save(path)

将当前指标保存在指定路径上。

load(path, end_of_epoch=False)

加载所需的信息。

class speechbrain.nnet.schedulers.LinearScheduler(initial_value, final_value, epoch_count)

基础类：object

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

学习率在指定的周期数内线性衰减。

Parameters:

• initial_value (float) – 初始化时的值。

• final_value (float) – 当epoch计数达到epoch_count - 1时使用的值。

• epoch_count (int) – 训练轮数。

Example

>>> 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)

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

Parameters:

current_epoch (int) – 数据集已被迭代的次数。

Return type:

当前和新的超参数值。

class speechbrain.nnet.schedulers.LinearWarmupScheduler(initial_value, num_warmup_steps, num_training_steps)

基础类：object

创建一个学习率计划，该计划在优化器中设置的初始学习率线性下降到0，在预热期间，学习率从0线性增加到优化器中设置的初始学习率。 * Ge Li 2022

Parameters:

• initial_value (float) – 初始化时的值（lr0）。

• num_warmup_steps (int) – 预热步数。学习率在第 num_warmup_steps + 1 步时达到 lr0。

• num_training_steps (int) – 训练步骤的总数。

Example

>>> 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)

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

Parameters:

current_step (int) – 模型已更新的步骤数。

Return type:

当前和新的超参数值。

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_decay因子在周期内衰减。

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

Parameters:

• initial_value (float) – 正在更新的超参数的初始值。

• decay_factor (float) – 与初始值相乘的因子

• decay_drop (float) – 退火因子（超参数值的衰减速度更快 当 decay_drop 值较高时）。

• half_life (int) – 一个方便的参数，用于设置 decay_factor，使得参数在指定的周期内降至其值的一半。不能与 decay_factor 或 decay_drop 一起使用。

Example

>>> 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)

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

Parameters:

current_epoch (int) – 数据集已被迭代的次数。

Return type:

当前和新的超参数值。

class speechbrain.nnet.schedulers.NoamScheduler(lr_initial, n_warmup_steps, model_size=None)

基础类：object

这是带有预热的变压器学习率调度器的实现。 参考: https://arxiv.org/abs/1706.03762

注意：此调度程序在每次更新模型权重时都会对学习率进行退火，并且必须保存n_steps以便重新启动。

Parameters:

• lr_initial (float) – 初始学习率（即在第0个epoch时使用的学习率）。

• n_warmup_steps (int) – 预热步骤的数量

• model_size (int) – transformer的嵌入维度大小。它用于缩放调度器达到的最大学习率值。它被除以model_size ** (0.5)。 如果未指定，最大学习率值将乘以warmup_steps ** (0.5)。

Example

>>> 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)

Parameters:

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

Returns:

• 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 Scheduler 和 Interval Scheduler 的组合。 该调度器表现为 Noam Scheduler，并在设计的步骤中以设计的衰减率降低学习率。

注意：此调度程序在每次更新模型权重时都会对学习率进行退火，并且必须保存n_steps以便重新启动。

Parameters:

• lr_initial (float) – 初始学习率（即在第0个epoch时使用的学习率）。

• n_warmup_steps (int) – 预热步骤的数量。

• anneal_steps (list) – 预先设计的步骤，其中学习率将被退火。

• anneal_rates (list) – 每个退火步骤的预设计衰减率。

• model_size (int) – transformer的嵌入维度大小。它用于缩放调度器达到的最大学习率值。它被除以model_size ** (0.5)。 如果未指定，则最大学习率值将乘以warmup_steps ** (0.5)。

Example

>>> 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)

Parameters:

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

Returns:

• 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以便重新启动。

Parameters:

• lr_initial (float) – 初始学习率（即在第0个epoch时使用的学习率）。

• n_warmup_steps (int) – 预热步骤的数量。

• n_keep_steps (int) – 在预热步骤之后，学习率保持不变的步骤数。

Example

>>> 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)

Parameters:

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

Returns:

• 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

这是一个带有预热的Cyclic-Cosine学习率调度器的实现。

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

注意：此调度程序在每次更新模型权重时都会对学习率进行退火，并且必须保存n_steps以便重新启动。

Parameters:

• n_warmup_steps (int) – 预热步骤的数量。

• lr_initial (float) – 初始学习率（即在第0个epoch时使用的学习率）。

• total_steps (int) – 更新步骤的总数。

Example

>>> 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)

Parameters:

opt (list of optimizers) – 使用此调度程序更新的优化器。

Returns:

• 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的区别在于，这个调度器会记住最后一次没有观察到改进的步骤，并与该特定损失值进行比较，而不是与最近的损失值进行比较。

Parameters:

• lr_min (float) – 允许的最小学习率。

• factor (float) – 用于减少学习率的因子。

• 耐心 (int) – 在减少学习率之前需要等待多少个周期。

• dont_halve_until_epoch (int) – 等待减半的周期数。

Example

>>> 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)

Parameters:

• optim_list (list of optimizers) – 使用此调度程序更新的优化器。

• current_epoch (int) – 数据集已被迭代的次数。

• current_loss (int) – 用于确定是否更改学习率的数字。

Returns:

• 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**(周期迭代次数) 缩放的循环。

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

Parameters:

• base_lr (float) – 初始学习率，这是周期中的下限。

• max_lr (float) – 循环中的上限。功能上， 它定义了循环的幅度（max_lr - base_lr）。 任何周期的lr都是base_lr 和幅度的一些缩放的总和；因此 根据缩放函数，max_lr可能实际上不会被达到。

• step_size (int) – 每个半周期的训练迭代次数。作者建议将 step_size 设置为每个周期训练迭代次数的 2-8 倍。

• mode (str) – 其中之一为 {triangular, triangular2, exp_range}。 默认为 'triangular'。 值对应于上述详细策略。 如果 scale_fn 不为 None，则忽略此参数。

• gamma (float) – 'exp_range' 缩放函数中的常数： gamma**(循环迭代次数)

• scale_fn (lambda 函数) – 由单参数 lambda 函数定义的自定义缩放策略，其中 对于所有 x >= 0，0 <= scale_fn(x) <= 1。 忽略 mode 参数

• scale_mode (str) – {‘cycle’, ‘iterations’}. 定义 scale_fn 是在周期数还是周期迭代次数（自周期开始以来的训练迭代次数）上评估。默认值为‘cycle’。

Example

>>> 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)

清除迭代。

on_batch_end(opt)

Parameters:

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

save(path)

将当前指标保存在指定路径上。

load(path, end_of_epoch=False)

加载所需的信息。

class speechbrain.nnet.schedulers.IntervalScheduler(intervals)

基础类：object

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

Parameters:

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

Example

>>> 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)

Parameters:

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

Returns:

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

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

save(path)

将当前指标保存在指定路径上。

load(path, end_of_epoch=False)

加载所需的信息。

class speechbrain.nnet.schedulers.InverseSquareRootScheduler(warmup_steps)

基础类：object

逆平方根调度器，如T5论文中定义 https://arxiv.org/pdf/1910.10683.pdf

Parameters:

warmup_steps (int) – 学习率保持恒定的步数

__call__(opt)

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

Parameters:

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

Return type:

当前和新的超参数值

save(path)

将当前指标保存在指定路径上。

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

基础类：object

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

参考

扩展视觉变换器 arxiv.org/abs/2106.04560

param lr:

热身阶段后达到的最大学习率。

type lr:

浮点数

param warmup:

预热步骤的数量（遵循线性增加）。

type warmup:

整数

param cooldown:

冷却步骤的数量（遵循线性减少）。

type cooldown:

整数

param total_steps:

总步数（用于衰减）。

type total_steps:

整数

param decay_factor:

衰减因子每经过decay_every步应用一次。

type decay_factor:

浮点数

param decay_every:

每隔 decay_every 步将衰减因子应用于学习率。

type decay_every:

整数

Example

>>> 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)

将当前指标保存在指定路径上。

load(path, end_of_epoch=False)

加载所需的信息。

class speechbrain.nnet.schedulers.ScheduledLoss(schedule)

基础：Module

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

Parameters:

schedule (list) –

一个包含以下键的字典列表

loss_fn: 使用的损失函数 steps: 在切换到下一个之前应用的步骤数

切换到下一个

Example

>>> 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)

计算指定步骤编号的损失。

Parameters:

• *args (元组)

• **kwargs (dict) – 传递给此函数的任何参数将被传递给指定的 loss_fn

Returns:

result – 损失值

Return type:

torch.Tensor

save(path)

在指定路径上保存当前状态。

load(path, end_of_epoch=False, device=None)

加载所需的信息。

find_next_switch()

根据计划找到下一次切换将发生的阈值

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

基础类：object

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

Parameters:

• lr (float) – 在预热后达到的最大学习率。

• warmup_steps (int) – 预热步数（遵循线性增长）。

• hold_steps (int) – 保持步数（学习率保持不变）。

• decay_steps (int) – 衰减步数。

• total_steps (int) – 总步数（用于衰减）。

• init_lr_scale (float) – 在预热阶段初始学习率的缩放比例。

• final_lr_scale (float) – 最终学习率比例。

Example

>>> 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)

计算与当前步骤（num_updates）对应的学习率。

save(path)

将当前指标保存在指定路径上。

load(path, end_of_epoch=False, device=None)

加载所需的信息。