torch.optim#
创建于: 2025年6月13日 | 最后更新于: 2025年6月13日
torch.optim 是一个实现了各种优化算法的包。
目前已支持大多数常用的方法，且接口足够通用，以便将来轻松集成更复杂的方法。
如何使用优化器#
要使用 torch.optim，您必须构造一个优化器对象，该对象将保存当前状态并根据计算出的梯度更新参数。
构造优化器#
要构造一个 Optimizer，您必须为其提供一个可迭代对象，该对象包含要优化的参数（都应该是 Parameter 类型）或命名参数（(str, Parameter) 元组）。然后，您可以指定优化器特定的选项，例如学习率、权重衰减等。
示例
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)
命名参数示例
optimizer = optim.SGD(model.named_parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([('layer0', var1), ('layer1', var2)], lr=0.0001)
逐参数选项#
Optimizer 也支持指定逐参数选项。为此，您不是传递 Variable 的可迭代对象，而是传递 dict 的可迭代对象。每个字典将定义一个独立的参数组，并且应包含一个 params 键，其中包含属于该组的参数列表。其他键应与优化器接受的关键字参数匹配，并将用作该组的优化选项。
例如，当您想要指定逐层学习率时，这非常有用
optim.SGD([
{'params': model.base.parameters(), 'lr': 1e-2},
{'params': model.classifier.parameters()}
], lr=1e-3, momentum=0.9)
optim.SGD([
{'params': model.base.named_parameters(), 'lr': 1e-2},
{'params': model.classifier.named_parameters()}
], lr=1e-3, momentum=0.9)
这意味着 model.base 的参数将使用 1e-2 的学习率，而 model.classifier 的参数将保持默认学习率 1e-3。最后，所有参数都将使用 0.9 的动量。
注意
您仍然可以传递关键字参数作为选项。它们将用作默认值，用于未覆盖它们的组。当您只想更改一个选项，同时保持所有其他选项在参数组之间一致时，这非常有用。
另请考虑以下与参数的不同惩罚相关的示例。请记住，parameters() 返回一个可迭代对象，其中包含所有可学习参数，包括可能倾向于不同惩罚的偏置和其他参数。为了解决这个问题，可以为每个参数组指定单独的惩罚权重
bias_params = [p for name, p in self.named_parameters() if 'bias' in name]
others = [p for name, p in self.named_parameters() if 'bias' not in name]
optim.SGD([
{'params': others},
{'params': bias_params, 'weight_decay': 0}
], weight_decay=1e-2, lr=1e-2)
通过这种方式，偏置项与非偏置项分离，并且 specifically 为偏置项设置了 weight_decay 为 0，以避免对该组进行任何惩罚。
执行优化步骤#
所有优化器都实现了一个 step() 方法，该方法用于更新参数。它可以通过两种方式使用
optimizer.step()#
这是大多数优化器支持的简化版本。该函数可以在使用例如 backward() 计算梯度后调用。
示例
for input, target in dataset:
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
optimizer.step(closure)#
一些优化算法（例如共轭梯度和 LBFGS）需要多次重新评估函数，因此您必须传入一个闭包，以便它们可以重新计算您的模型。该闭包应该清除梯度，计算损失，并返回损失。
示例
for input, target in dataset:
def closure():
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
return loss
optimizer.step(closure)
基类#
- class torch.optim.Optimizer(params, defaults)[source]#
所有优化器的基类。
警告
参数需要指定为具有确定性排序的集合，该排序在不同运行之间保持一致。不满足这些属性的对象示例是集合和字典值的迭代器。
- 参数
params (iterable) – 一个包含
torch.Tensor或dict的可迭代对象。指定应优化哪些张量。defaults (dict[str, Any]) – (dict)：一个包含优化选项默认值的字典（当参数组未指定时使用）。
向 |
|
加载优化器状态。 |
|
注册一个 load_state_dict 预钩子，它将在调用 |
|
注册一个 load_state_dict 后钩子，它将在调用 |
|
将优化器的状态作为 |
|
注册一个 state dict 预钩子，它将在调用 |
|
注册一个 state dict 后钩子，它将在调用 |
|
执行一次优化步骤来更新参数。 |
|
注册一个优化器步骤预钩子，它将在优化器步骤之前被调用。 |
|
注册一个优化器步骤后钩子，它将在优化器步骤之后被调用。 |
|
重置所有已优化 |
算法#
实现 Adadelta 算法。 |
|
实现 Adafactor 算法。 |
|
实现 Adagrad 算法。 |
|
实现 Adam 算法。 |
|
实现 AdamW 算法，其中权重衰减不会累积在动量或方差中。 |
|
SparseAdam 实现了一种适用于稀疏梯度的 Adam 算法的掩码版本。 |
|
实现 Adamax 算法（基于无穷范数的 Adam 变体）。 |
|
实现平均随机梯度下降。 |
|
实现 L-BFGS 算法。 |
|
实现 NAdam 算法。 |
|
实现 RAdam 算法。 |
|
实现 RMSprop 算法。 |
|
实现弹性反向传播算法。 |
|
实现随机梯度下降（可选带有动量）。 |
我们的许多算法都有针对性能、可读性或通用性优化的各种实现，因此如果用户没有指定特定实现，我们通常会默认选择当前设备上最快的实现。
我们有三种主要的实现类别：for-loop、foreach（多张量）和 fused。最直接的实现是对参数进行 for 循环，其中包含大量的计算。For 循环通常比我们的 foreach 实现慢，后者将参数组合成一个多张量并一次性运行大量的计算，从而节省了许多顺序内核调用。我们的一些优化器甚至有更快的 fused 实现，它们将大量的计算融合到一个内核中。我们可以将 foreach 实现视为水平融合，而 fused 实现则在此基础上进行垂直融合。
一般来说，这三种实现的性能顺序是 fused > foreach > for-loop。因此，在适用时，我们默认使用 foreach 而非 for-loop。适用意味着 foreach 实现可用，用户未指定任何特定于实现的 kwargs（例如，fused、foreach、differentiable），并且所有张量都是原生的。请注意，虽然 fused 应该比 foreach 更快，但这些实现较新，我们希望在全面启用它们之前给予它们更多的时间进行“烘焙”。我们总结了下表中每种实现的稳定性状态，欢迎您尝试！
下表显示了每种算法的可用和默认实现
算法 |
默认 |
有 foreach 吗？ |
有 fused 吗？ |
|---|---|---|---|
foreach |
是 |
否 |
|
for-loop |
否 |
否 |
|
foreach |
是 |
是（仅限 CPU） |
|
foreach |
是 |
是 |
|
foreach |
是 |
是 |
|
for-loop |
否 |
否 |
|
foreach |
是 |
否 |
|
foreach |
是 |
否 |
|
for-loop |
否 |
否 |
|
foreach |
是 |
否 |
|
foreach |
是 |
否 |
|
foreach |
是 |
否 |
|
foreach |
是 |
否 |
|
foreach |
是 |
是 |
下表显示了 fused 实现的稳定性状态
如何调整学习率#
torch.optim.lr_scheduler.LRScheduler 提供了几种根据 epoch 数量调整学习率的方法。torch.optim.lr_scheduler.ReduceLROnPlateau 允许根据某些验证测量动态降低学习率。
学习率调度应在优化器更新之后应用；例如，您应该这样编写代码
示例
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
scheduler = ExponentialLR(optimizer, gamma=0.9)
for epoch in range(20):
for input, target in dataset:
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
scheduler.step()
大多数学习率调度器可以背靠背调用（也称为链式调度器）。结果是每个调度器依次应用于前一个调度器获得的学习率。
示例
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
scheduler1 = ExponentialLR(optimizer, gamma=0.9)
scheduler2 = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)
for epoch in range(20):
for input, target in dataset:
optimizer.zero_grad()
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
scheduler1.step()
scheduler2.step()
在文档的许多地方，我们将使用以下模板来指代调度器算法。
>>> scheduler = ...
>>> for epoch in range(100):
>>> train(...)
>>> validate(...)
>>> scheduler.step()
警告
在 PyTorch 1.1.0 之前，学习率调度器应该在优化器更新之前调用；1.1.0 以一种不兼容的方式改变了这种行为。如果您在优化器更新（调用 optimizer.step()）之前使用学习率调度器（调用 scheduler.step()），这将跳过学习率调度的第一个值。如果您在升级到 PyTorch 1.1.0 后无法重现结果，请检查您是否在错误的时间调用了 scheduler.step()。
在优化过程中调整学习率。 |
|
设置初始学习率。 |
|
将每个参数组的学习率乘以指定函数中给出的因子。 |
|
每 step_size 个 epoch 将每个参数组的学习率衰减 gamma。 |
|
一旦 epoch 数达到其中一个里程碑，就将每个参数组的学习率衰减 gamma。 |
|
将每个参数组的学习率乘以一个小的常数因子。 |
|
通过线性改变小的乘法因子来衰减每个参数组的学习率。 |
|
每 epoch 将每个参数组的学习率衰减 gamma。 |
|
使用给定 total_iters 中的多项式函数来衰减每个参数组的学习率。 |
|
使用余弦退火调度设置每个参数组的学习率。 |
|
链式连接一系列学习率调度器。 |
|
包含一系列调度器，这些调度器预计在优化过程中按顺序调用。 |
|
当指标停止改进时降低学习率。 |
|
根据循环学习率策略 (CLR) 设置每个参数组的学习率。 |
|
根据 1 周期学习率策略设置每个参数组的学习率。 |
|
使用余弦退火调度设置每个参数组的学习率。 |
如何利用命名参数加载优化器状态字典#
函数 load_state_dict() 会存储加载状态字典中可选的 param_names 内容（如果存在）。但是，加载优化器状态的过程不受影响，因为参数的顺序对于保持兼容性很重要（在不同顺序的情况下）。要利用从加载状态字典中加载的参数名称，需要根据所需的行为实现一个自定义的 register_load_state_dict_pre_hook。
例如，当模型架构发生变化，但权重和优化器状态需要保持不变时，这会很有用。以下示例演示了如何实现此自定义。
示例
class OneLayerModel(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(3, 4)
def forward(self, x):
return self.fc(x)
model = OneLayerModel()
optimizer = optim.SGD(model.named_parameters(), lr=0.01, momentum=0.9)
# training..
torch.save(optimizer.state_dict(), PATH)
假设 model 实现了专家模型 (MoE)，我们想要复制它并恢复两个专家的训练，它们都以与 fc 层相同的方式初始化。对于以下 model2，我们创建了两个与 fc 相同的层，并通过将 model 的模型权重和优化器状态加载到 model2 的 fc1 和 fc2 中来恢复训练（并相应地调整它们）
class TwoLayerModel(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(3, 4)
self.fc2 = nn.Linear(3, 4)
def forward(self, x):
return (self.fc1(x) + self.fc2(x)) / 2
model2 = TwoLayerModel()
# adapt and load model weights..
optimizer2 = optim.SGD(model2.named_parameters(), lr=0.01, momentum=0.9)
要加载 optimizer2 的状态字典，并使用先前优化器的状态字典，以便 fc1 和 fc2 都将用 fc 优化器状态的副本进行初始化（以便从 fc 中恢复每个层的训练），我们可以使用以下钩子
def adapt_state_dict_ids(optimizer, state_dict):
adapted_state_dict = deepcopy(optimizer.state_dict())
# Copy setup parameters (lr, weight_decay, etc.), in case they differ in the loaded state dict.
for k, v in state_dict['param_groups'][0].items():
if k not in ['params', 'param_names']:
adapted_state_dict['param_groups'][0][k] = v
lookup_dict = {
'fc1.weight': 'fc.weight',
'fc1.bias': 'fc.bias',
'fc2.weight': 'fc.weight',
'fc2.bias': 'fc.bias'
}
clone_deepcopy = lambda d: {k: (v.clone() if isinstance(v, torch.Tensor) else deepcopy(v)) for k, v in d.items()}
for param_id, param_name in zip(
optimizer.state_dict()['param_groups'][0]['params'],
optimizer.state_dict()['param_groups'][0]['param_names']):
name_in_loaded = lookup_dict[param_name]
index_in_loaded_list = state_dict['param_groups'][0]['param_names'].index(name_in_loaded)
id_in_loaded = state_dict['param_groups'][0]['params'][index_in_loaded_list]
# Copy the state of the corresponding parameter
if id_in_loaded in state_dict['state']:
adapted_state_dict['state'][param_id] = clone_deepcopy(state_dict['state'][id_in_loaded])
return adapted_state_dict
optimizer2.register_load_state_dict_pre_hook(adapt_state_dict_ids)
optimizer2.load_state_dict(torch.load(PATH)) # The previous optimizer saved state_dict
这确保了在模型加载期间将使用为 model2 层提供正确状态的适配后的 state_dict。请注意，此代码是专门为此示例设计的（例如，假设只有一个参数组），其他情况可能需要不同的适配。
以下示例展示了当模型结构发生变化时如何处理加载的 state dict 中缺失的参数。Model_bypass 添加了一个新的 bypass 层，该层在原始 Model1 中不存在。为了恢复训练，使用自定义的 adapt_state_dict_missing_param 钩子来适配优化器的 state_dict，确保现有参数正确映射，而缺失的参数（如旁路层）保持不变（如本例中初始化）。这种方法可以在模型更改的情况下平滑加载和恢复优化器状态。新的旁路层将从头开始训练
class Model1(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(5, 5)
def forward(self, x):
return self.fc(x) + x
model = Model1()
optimizer = optim.SGD(model.named_parameters(), lr=0.01, momentum=0.9)
# training..
torch.save(optimizer.state_dict(), PATH)
class Model_bypass(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(5, 5)
self.bypass = nn.Linear(5, 5, bias=False)
torch.nn.init.eye_(self.bypass.weight)
def forward(self, x):
return self.fc(x) + self.bypass(x)
model2 = Model_bypass()
optimizer2 = optim.SGD(model2.named_parameters(), lr=0.01, momentum=0.9)
def adapt_state_dict_missing_param(optimizer, state_dict):
adapted_state_dict = deepcopy(optimizer.state_dict())
# Copy setup parameters (lr, weight_decay, etc.), in case they differ in the loaded state dict.
for k, v in state_dict['param_groups'][0].items():
if k not in ['params', 'param_names']:
adapted_state_dict['param_groups'][0][k] = v
lookup_dict = {
'fc.weight': 'fc.weight',
'fc.bias': 'fc.bias',
'bypass.weight': None,
}
clone_deepcopy = lambda d: {k: (v.clone() if isinstance(v, torch.Tensor) else deepcopy(v)) for k, v in d.items()}
for param_id, param_name in zip(
optimizer.state_dict()['param_groups'][0]['params'],
optimizer.state_dict()['param_groups'][0]['param_names']):
name_in_loaded = lookup_dict[param_name]
if name_in_loaded in state_dict['param_groups'][0]['param_names']:
index_in_loaded_list = state_dict['param_groups'][0]['param_names'].index(name_in_loaded)
id_in_loaded = state_dict['param_groups'][0]['params'][index_in_loaded_list]
# Copy the state of the corresponding parameter
if id_in_loaded in state_dict['state']:
adapted_state_dict['state'][param_id] = clone_deepcopy(state_dict['state'][id_in_loaded])
return adapted_state_dict
optimizer2.register_load_state_dict_pre_hook(adapt_state_dict_ids)
optimizer2.load_state_dict(torch.load(PATH)) # The previous optimizer saved state_dict
作为第三个例子，除了按照参数顺序加载状态（默认方法）外，此钩子还可以用于根据参数名称加载
def names_matching(optimizer, state_dict):
assert len(state_dict['param_groups']) == len(optimizer.state_dict()['param_groups'])
adapted_state_dict = deepcopy(optimizer.state_dict())
for g_ind in range(len(state_dict['param_groups'])):
assert len(state_dict['param_groups'][g_ind]['params']) == len(
optimizer.state_dict()['param_groups'][g_ind]['params'])
for k, v in state_dict['param_groups'][g_ind].items():
if k not in ['params', 'param_names']:
adapted_state_dict['param_groups'][g_ind][k] = v
for param_id, param_name in zip(
optimizer.state_dict()['param_groups'][g_ind]['params'],
optimizer.state_dict()['param_groups'][g_ind]['param_names']):
index_in_loaded_list = state_dict['param_groups'][g_ind]['param_names'].index(param_name)
id_in_loaded = state_dict['param_groups'][g_ind]['params'][index_in_loaded_list]
# Copy the state of the corresponding parameter
if id_in_loaded in state_dict['state']:
adapted_state_dict['state'][param_id] = deepcopy(state_dict['state'][id_in_loaded])
return adapted_state_dict
权重平均 (SWA 和 EMA)#
torch.optim.swa_utils.AveragedModel 实现了随机权重平均 (SWA) 和指数移动平均 (EMA)，torch.optim.swa_utils.SWALR 实现了 SWA 学习率调度器，而 torch.optim.swa_utils.update_bn() 是一个实用函数，用于在训练结束时更新 SWA/EMA 批归一化统计信息。
SWA 在 Averaging Weights Leads to Wider Optima and Better Generalization 中被提出。
EMA 是一种广为人知的技术，通过减少所需的权重更新次数来缩短训练时间。它是 Polyak 平均 的变体，但使用指数权重而非迭代间等权重。
构建平均模型#
AveragedModel 类用于计算 SWA 或 EMA 模型的权重。
您可以通过运行以下命令创建一个 SWA 平均模型
>>> averaged_model = AveragedModel(model)
EMA 模型通过指定 multi_avg_fn 参数来构建，如下所示
>>> decay = 0.999
>>> averaged_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(decay))
衰减是一个介于 0 和 1 之间的参数，它控制平均参数的衰减速度。如果未提供给 torch.optim.swa_utils.get_ema_multi_avg_fn()，则默认为 0.999。衰减值应接近 1.0，因为较小的值可能导致优化收敛问题。
torch.optim.swa_utils.get_ema_multi_avg_fn() 返回一个对权重应用以下 EMA 方程的函数
其中 alpha 是 EMA 衰减。
此处，模型 model 可以是任意 torch.nn.Module 对象。averaged_model 将跟踪 model 参数的运行平均值。要更新这些平均值，您应该在 optimizer.step() 之后使用 update_parameters() 函数
>>> averaged_model.update_parameters(model)
对于 SWA 和 EMA，此调用通常在优化器 step() 之后立即进行。在 SWA 的情况下，这通常在训练开始时跳过一些步骤。
自定义平均策略#
默认情况下，torch.optim.swa_utils.AveragedModel 计算您提供的参数的运行等平均值，但您也可以使用 avg_fn 或 multi_avg_fn 参数来自定义平均函数
avg_fn允许定义一个对每个参数元组（平均参数、模型参数）进行操作的函数，并应返回新的平均参数。multi_avg_fn允许定义更高效的操作，同时作用于参数列表元组（平均参数列表、模型参数列表），例如使用torch._foreach*函数。此函数必须就地更新平均参数。
在以下示例中，ema_model 使用 avg_fn 参数计算指数移动平均值
>>> ema_avg = lambda averaged_model_parameter, model_parameter, num_averaged:\
>>> 0.9 * averaged_model_parameter + 0.1 * model_parameter
>>> ema_model = torch.optim.swa_utils.AveragedModel(model, avg_fn=ema_avg)
在以下示例中，ema_model 使用更高效的 multi_avg_fn 参数计算指数移动平均值
>>> ema_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(0.9))
SWA 学习率调度器#
通常，在 SWA 中，学习率被设置为一个较高的常数值。SWALR 是一个学习率调度器，它将学习率退火到一个固定值，然后保持不变。例如，以下代码创建了一个调度器，它在每个参数组中，以 5 个 epoch 的时间，将学习率从初始值线性退火到 0.05
>>> swa_scheduler = torch.optim.swa_utils.SWALR(optimizer, \
>>> anneal_strategy="linear", anneal_epochs=5, swa_lr=0.05)
您也可以通过设置 anneal_strategy="cos" 来使用余弦退火而不是线性退火到固定值。
处理批归一化#
update_bn() 是一个实用函数，允许在训练结束时对给定数据加载器 loader 上的 SWA 模型计算批归一化统计信息
>>> torch.optim.swa_utils.update_bn(loader, swa_model)
update_bn() 将 swa_model 应用于数据加载器中的每个元素，并计算模型中每个批归一化层的激活统计信息。
警告
update_bn() 假定数据加载器 loader 中的每个数据批次要么是一个张量，要么是一个张量列表或元组，在后一种情况下，假定 model.forward() 应该在对应于数据批次的列表或元组的第一个元素上调用。如果您的数据加载器具有不同的结构，您可以通过使用 swa_model 对数据集的每个元素进行前向传递来更新 swa_model 的批归一化统计信息。
整合所有：SWA#
在下面的示例中，swa_model 是 SWA 模型，它累积权重的平均值。我们总共训练模型 300 个 epoch，并在 epoch 160 切换到 SWA 学习率调度器并开始收集参数的 SWA 平均值
>>> loader, optimizer, model, loss_fn = ...
>>> swa_model = torch.optim.swa_utils.AveragedModel(model)
>>> scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=300)
>>> swa_start = 160
>>> swa_scheduler = SWALR(optimizer, swa_lr=0.05)
>>>
>>> for epoch in range(300):
>>> for input, target in loader:
>>> optimizer.zero_grad()
>>> loss_fn(model(input), target).backward()
>>> optimizer.step()
>>> if epoch > swa_start:
>>> swa_model.update_parameters(model)
>>> swa_scheduler.step()
>>> else:
>>> scheduler.step()
>>>
>>> # Update bn statistics for the swa_model at the end
>>> torch.optim.swa_utils.update_bn(loader, swa_model)
>>> # Use swa_model to make predictions on test data
>>> preds = swa_model(test_input)
整合所有：EMA#
在以下示例中，ema_model 是 EMA 模型，它以 0.999 的衰减率累积权重的指数衰减平均值。我们总共训练模型 300 个 epoch，并立即开始收集 EMA 平均值。
>>> loader, optimizer, model, loss_fn = ...
>>> ema_model = torch.optim.swa_utils.AveragedModel(model, \
>>> multi_avg_fn=torch.optim.swa_utils.get_ema_multi_avg_fn(0.999))
>>>
>>> for epoch in range(300):
>>> for input, target in loader:
>>> optimizer.zero_grad()
>>> loss_fn(model(input), target).backward()
>>> optimizer.step()
>>> ema_model.update_parameters(model)
>>>
>>> # Update bn statistics for the ema_model at the end
>>> torch.optim.swa_utils.update_bn(loader, ema_model)
>>> # Use ema_model to make predictions on test data
>>> preds = ema_model(test_input)
实现随机权重平均 (SWA) 和指数移动平均 (EMA) 的平均模型。 |
|
将每个参数组的学习率退火到一个固定值。 |
- torch.optim.swa_utils.update_bn(loader, model, device=None)[source]#
更新模型中的 BatchNorm running_mean、running_var 缓冲区。
它对 loader 中的数据执行一次传递，以估计模型中 BatchNorm 层的激活统计信息。
- 参数
loader (torch.utils.data.DataLoader) – 用于计算激活统计的数据集加载器。每个数据批次都应该是一个张量，或一个列表/元组，其第一个元素是包含数据的张量。
model (torch.nn.Module) – 我们希望更新 BatchNorm 统计信息的模型。
device (torch.device, optional) – 如果设置，数据将在传递到
model之前传输到device。
示例
>>> loader, model = ... >>> torch.optim.swa_utils.update_bn(loader, model)
注意
update_bn 实用程序假定
loader中的每个数据批次要么是一个张量，要么是一个张量列表或元组；在后一种情况下，假定model.forward()应该在与数据批次对应的列表或元组的第一个元素上调用。