优化器#

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.9.19/lib/python3.9/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.9.19/lib/python3.9/pickle.py'>, pickle_protocol=2, verbose=True)[source]#

构造函数。

参数:

  • model – 被包装的模型。

  • optimizer – 被包装的优化器。

  • criterion – 被包装的损失函数。

  • device – 进行测试的设备。可以是一个字符串（“cpu”或“cuda”），带有可选的设备类型序号（例如“cuda:X”，其中 X 是序号）。或者，也可以是一个表示计算将发生的设备的对象的引用。默认值: None，使用与 model 相同的设备。

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

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

  • amp – 使用自动混合精度

  • pickle_module – 用于对元数据和对象进行 pickle 操作的模块，默认为 pickle。此参数由 torch.save 使用，更多详细信息请查看: https://pytorch.ac.cn/docs/stable/generated/torch.save.html#torch.save。

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

  • verbose – 详细输出

返回值:

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 – 从开始处修剪的批量数。

  • skip_end – 从结束处修剪的批量数。

返回值:

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

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

绘制学习率范围测试结果。

参数:

  • skip_start – 从开始处修剪的批量数。

  • skip_end – 从开始处修剪的批量数。

  • log_lr – 如果为 True，则以对数比例绘制学习率；否则，以线性比例绘制。

  • ax – 在指定的 matplotlib axes 对象中创建图，并且不显示图形。如果为 None，则在此方法中创建图形和 axes 对象并显示图形。

  • steepest_lr – 绘制具有最陡梯度的学习率。

返回值:

包含图的 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 – 训练集数据加载器。

  • val_loader – 验证集数据加载器（如果需要）。

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

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

  • start_lr – 范围测试的起始学习率。默认值为优化器的学习率。

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

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

  • step_mode – 学习率增加的调度模式: (linear 或 exp)。

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

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

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

  • non_blocking_transfer – 当为 True 时，如果可能，异步将数据移动到设备，例如将带有锁页内存的 CPU Tensor 移动到 CUDA 设备。

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

返回值:

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

Novograd 基于 Stochastic Gradient Methods with Layer-wise Adaptive Moments for Training of Deep Networks。代码改编自 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 – 一个重新评估模型并返回损失的闭包。默认为 None。

生成参数组#

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

用于为优化器生成具有不同学习率值的参数组的工具函数。输出的参数组与 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 函数对应的学习率值列表。

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

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

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

在一定数量的迭代过程中，以指数方式增加两个边界之间的学习率。

LinearLR#

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

在一定数量的迭代过程中，以线性方式增加两个边界之间的学习率。

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) – 上一轮的索引。

  • warmup_multiplier (float) – 如果提供，线性预热从此初始学习率的分数开始。必须在 0..1 区间内。默认为 0

返回值:

None

在本页
显示源文件