优化器#

LearningRateFinder#

class monai.optimizers.LearningRateFinder(model, optimizer, criterion, device=None, memory_cache=True, cache_dir=None, amp=False, pickle_module=<module 'pickle' from '/home/docs/.asdf/installs/python/3.10.19/lib/python3.10/pickle.py'>, pickle_protocol=2, verbose=True)[source]#

学习率范围测试。

学习率范围测试在预训练运行期间以线性或指数方式在两个边界之间增加学习率。它提供了关于网络在一定学习率范围内训练效果如何以及最优学习率是多少的有价值信息。

示例 (fastai 方法): >>> lr_finder = LearningRateFinder(net, optimizer, criterion) >>> lr_finder.range_test(data_loader, end_lr=100, num_iter=100) >>> lr_finder.get_steepest_gradient() >>> lr_finder.plot() # 用于检查损失-学习率曲线图

示例 (Leslie Smith 的方法): >>> lr_finder = LearningRateFinder(net, optimizer, criterion) >>> lr_finder.range_test(train_loader, val_loader=val_loader, end_lr=1, num_iter=100, step_mode=”linear”)

支持梯度累积；示例： >>> train_data = … # 准备好的数据集 >>> desired_bs, real_bs = 32, 4 # 批次大小 >>> accumulation_steps = desired_bs // real_bs # 累积所需的步数 >>> data_loader = torch.utils.data.DataLoader(train_data, batch_size=real_bs, shuffle=True) >>> acc_lr_finder = LearningRateFinder(net, optimizer, criterion) >>> acc_lr_finder.range_test(data_loader, end_lr=10, num_iter=100, accumulation_steps=accumulation_steps)

默认情况下，图像将根据批处理数据是否为字典从数据加载器中提取，使用 x[“image”] 或 x[0]（标签提取行为类似）。如果您的数据加载器返回其他内容，请传递一个可调用函数来提取它，例如： >>> image_extractor = lambda x: x[“input”] >>> label_extractor = lambda x: x[100] >>> lr_finder = LearningRateFinder(net, optimizer, criterion) >>> lr_finder.range_test(train_loader, val_loader, image_extractor, label_extractor)

参考文献：修改自： davidtvs/pytorch-lr-finder。训练神经网络的周期性学习率： https://arxiv.org/abs/1506.01186

__init__(model, optimizer, criterion, device=None, memory_cache=True, cache_dir=None, amp=False, pickle_module=<module 'pickle' from '/home/docs/.asdf/installs/python/3.10.19/lib/python3.10/pickle.py'>, pickle_protocol=2, verbose=True)[source]#

构造函数。

参数:

  • model (Module) – 封装的模型。

  • optimizer (Optimizer) – 封装的优化器。

  • criterion (Module) – 封装的损失函数。

  • device (Union[str, device, None]) – 进行测试的设备。运行一个字符串（“cpu” 或 “cuda”），并可选设备类型的序号（例如 “cuda:X”，其中 X 是序号）。或者，可以是表示计算发生所在设备的对象。默认值：None，使用与 model 相同的设备。

  • memory_cache (bool) – 如果此标志设置为 True，则模型和优化器的 state_dict 将缓存在内存中。否则，它们将保存到 cache_dir 下的文件中。

  • cache_dir (Optional[str, None]) – 用于存储临时文件的路径。如果未指定路径，则使用系统范围的临时目录。注意，如果 memory_cache 为 True，此参数将被忽略。

  • amp (bool) – 使用自动混合精度 (Automatic Mixed Precision)。

  • pickle_module (module) – 用于序列化元数据和对象的模块，默认为 pickle。此参数由 torch.save 使用，更多详情请查看： https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。

  • pickle_protocol (int) – 可以指定以覆盖默认协议，默认为 2。此参数由 torch.save 使用，更多详情请查看： https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。

  • verbose (bool) – 是否输出详细日志。

返回:

None

get_lrs_and_losses(skip_start=0, skip_end=0)[source]#

获取学习率及其对应的损失。

参数:

  • skip_start (int) – 从开始处修剪的批次数量。

  • skip_end (int) – 从末尾处修剪的批次数量。

返回类型:

tuple[list, list]

get_steepest_gradient(skip_start=0, skip_end=0)[source]#

获取具有最陡峭梯度的学习率及其对应的损失。

参数:

  • skip_start (int) – 从开始处修剪的批次数量。

  • skip_end (int) – 从末尾处修剪的批次数量。

返回类型:

UnionType[tuple[float, float], tuple[None, None]]

返回:

具有最陡峭梯度的学习率及其对应的损失。

plot(skip_start=0, skip_end=0, log_lr=True, ax=None, steepest_lr=True)[source]#

绘制学习率范围测试图。

参数:

  • skip_start (int) – 从开始处修剪的批次数量。

  • skip_end (int) – 从开始处修剪的批次数量。

  • log_lr (bool) – True 表示以对数刻度绘制学习率；否则，以线性刻度绘制。

  • ax (Optional[Any, None]) – 图表在指定的 matplotlib 坐标轴对象中创建，且不会显示图形。如果为 None，则在此方法中创建图形和坐标轴对象并显示图形。

  • steepest_lr (bool) – 标记具有最陡峭梯度的学习率。

返回类型:

Optional[Any, None]

返回:

包含图表的 matplotlib.axes.Axes 对象。如果未安装 matplotlib，则返回 None。

range_test(train_loader, val_loader=None, image_extractor=<function default_image_extractor>, label_extractor=<function default_label_extractor>, start_lr=None, end_lr=10.0, num_iter=100, step_mode='exp', smooth_f=0.05, diverge_th=5, accumulation_steps=1, non_blocking_transfer=True, auto_reset=True)[source]#

执行学习率范围测试。

参数:

  • train_loader (DataLoader) – 训练集数据加载器。

  • val_loader (Optional[DataLoader, None]) – 验证数据加载器（如果需要）。

  • image_extractor (Callable) – 用于从数据批次中获取图像的可调用函数。默认值：x[“image”] if isinstance(x, dict) else x[0]。

  • label_extractor (Callable) – 用于从数据批次中获取标签的可调用函数。默认值：x[“label”] if isinstance(x, dict) else x[1]。

  • start_lr (Optional[float, None]) – 范围测试的起始学习率。默认为优化器的学习率。

  • end_lr (float) – 要测试的最大学习率。如果结果开始发散，测试可能会提前停止。

  • num_iter (int) – 测试的最大迭代次数。

  • step_mode (str) – 增加学习率的计划：（linear 或 exp）。

  • smooth_f (float) – [0, 1[ 区间内的损失平滑因子。如果设置为 0 则禁用，否则使用指数平滑法平滑损失。

  • diverge_th (int) – 当损失超过阈值 diverge_th * best_loss 时停止测试。

  • accumulation_steps (int) – 梯度累积的步数。如果设置为 1，则不累积梯度。

  • non_blocking_transfer (bool) – 当为 True 时，如果可能，异步地将数据移动到设备，例如，将具有固定内存的 CPU 张量移动到 CUDA 设备。

  • auto_reset (bool) – 如果为 True，则在测试结束时将模型和优化器恢复到原始状态。

返回类型:

None

返回:

None

reset()[source]#

将模型和优化器恢复到其初始状态。

返回类型:

None

Novograd#

class monai.optimizers.Novograd(params, lr=0.001, betas=(0.9, 0.98), eps=1e-08, weight_decay=0, grad_averaging=False, amsgrad=False)[source]#

基于 Stochastic Gradient Methods with Layer-wise Adaptive Moments for Training of Deep Networks 的 Novograd。代码改编自 Jasper for PyTorch 和 OpenSeq2Seq 的实现。

参数:

  • params (Iterable) – 待优化的参数或定义参数组的字典的迭代器。

  • lr (float) – 学习率。默认值为 1e-3。

  • betas (tuple[float, float]) – 用于计算梯度及其平方的运行平均值的系数。默认值为 (0.9, 0.98)。

  • eps (float) – 添加到分母以提高数值稳定性的项。默认值为 1e-8。

  • weight_decay (float) – 权重衰减 (L2 惩罚)。默认值为 0。

  • grad_averaging (bool) – 梯度平均。默认值为 False。

  • amsgrad (bool) – 是否使用论文 On the Convergence of Adam and Beyond 中的该算法的 AMSGrad 变体。默认值为 False。

step(closure=None)[source]#

执行单个优化步骤。

参数:

closure (Optional[Callable[~T], None]) – 重新评估模型并返回损失的闭包。默认值为 None。

返回类型:

Optional[~T, None]

Generate parameter groups#

monai.optimizers.generate_param_groups(network, layer_matches, match_types, lr_values, include_others=True)[source]#

用于为优化器生成具有不同 LR 值的参数组的实用函数。输出的参数组与 layer_match 函数的顺序相同。

参数:

  • network (Module) – 用于生成参数组的源网络。

  • layer_matches (Sequence[Callable]) – 一系列可调用函数，用于选择或过滤网络层组。对于 “select” 类型，输入将是 network；对于 “filter” 类型，输入将是 network.named_parameters() 中的每一项。对于 “select”，参数将为 select_func(network).parameters()。对于 “filter”，参数将为 (x[1] for x in filter(f, network.named_parameters()))

  • match_types (Sequence[str]) – 一系列标签，用于标识与 layer_matches 函数对应的匹配类型，可以是 “select” 或 “filter”。

  • lr_values (Sequence[float]) – 与 layer_matches 函数对应的 LR 值列表。

  • include_others (bool) – 是否将剩余层作为最后一组包含，默认为 True。

它主要用于为不同的网络元素设置不同的 LR 值，例如 

net = Unet(spatial_dims=3, in_channels=1, out_channels=3, channels=[2, 2, 2], strides=[1, 1, 1])
print(net)  # print out network components to select expected items
print(net.named_parameters())  # print out all the named parameters to filter out expected items
params = generate_param_groups(
    network=net,
    layer_matches=[lambda x: x.model[0], lambda x: "2.0.conv" in x[0]],
    match_types=["select", "filter"],
    lr_values=[1e-2, 1e-3],
)
# the groups will be a list of dictionaries:
# [{'params': <generator object Module.parameters at 0x7f9090a70bf8>, 'lr': 0.01},
#  {'params': <filter object at 0x7f9088fd0dd8>, 'lr': 0.001},
#  {'params': <filter object at 0x7f9088fd0da0>}]
optimizer = torch.optim.Adam(params, 1e-4)
返回类型:

list[dict]

ExponentialLR#

class monai.optimizers.ExponentialLR(optimizer, end_lr, num_iter, last_epoch=-1)[source]#

在多次迭代中，在两个边界之间以指数方式增加学习率。

get_lr()[source]#

为优化器的每个 param_groups 计算下一个学习率。

返回:

为优化器的每个 param_groups 提供的学习率列表，其类型与其当前的 group["lr"] 相同。

返回类型:

list[float | Tensor]

注意

如果您想检查最近的学习率，请改用 get_last_lr()。

注意

返回的 Tensor 是副本，绝不会与优化器的 group["lr"] 产生别名。

LinearLR#

class monai.optimizers.LinearLR(optimizer, end_lr, num_iter, last_epoch=-1)[source]#

在多次迭代中，在两个边界之间线性增加学习率。

get_lr()[source]#

为优化器的每个 param_groups 计算下一个学习率。

返回:

为优化器的每个 param_groups 提供的学习率列表，其类型与其当前的 group["lr"] 相同。

返回类型:

list[float | Tensor]

注意

如果您想检查最近的学习率，请改用 get_last_lr()。

注意

返回的 Tensor 是副本，绝不会与优化器的 group["lr"] 产生别名。

WarmupCosineSchedule#

class monai.optimizers.WarmupCosineSchedule(optimizer, warmup_steps, t_total, end_lr=0.0, cycles=0.5, last_epoch=-1, warmup_multiplier=0)[source]#

线性热身，然后进行余弦衰减。基于 https://hugging-face.cn/ 的实现。

__init__(optimizer, warmup_steps, t_total, end_lr=0.0, cycles=0.5, last_epoch=-1, warmup_multiplier=0)[source]#
参数:

  • optimizer (Optimizer) – 封装的优化器。

  • warmup_steps (int) – 热身迭代次数。

  • t_total (int) – 总的训练迭代次数。

  • end_lr (float) – 最终学习率。默认值为 0.0。

  • cycles (float) – 余弦周期参数。

  • last_epoch (int) – 最后一个 epoch 的索引。

  • warmup_multiplier (float) – 如果提供，则从初始学习率的该比例开始线性热身。必须在 0 到 1 的区间内。默认值为 0。

返回:

None

get_lr()[source]#

为优化器的每个 param_groups 计算下一个学习率。

通过 last_epoch 时 lr_lambdas 的输出来缩放 base_lrs。

返回:

为优化器的每个 param_groups 提供的学习率列表，其类型与其当前的 group["lr"] 相同。

返回类型:

list[float | Tensor]

注意

如果您想检查最近的学习率，请改用 get_last_lr()。

注意

返回的 Tensor 是副本，绝不会与优化器的 group["lr"] 产生别名。