模块 ¶

类 torch.nn.Module(*args, **kwargs)[source][source] ¶

所有神经网络模块的基类。

您的模型也应该继承这个类。

模块还可以包含其他模块，允许它们以树状结构嵌套。您可以将子模块作为常规属性分配：

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

以这种方式分配的子模块将被注册，并且在您调用 to() 等时，它们的参数也将被转换。

注意

如上例所示，在分配子类之前，必须先对父类进行 __init__() 调用。

变量:

训练（布尔值）- 布尔值表示此模块是否处于训练或评估模式。

add_module(name, module)

向当前模块添加子模块。

可以使用给定的名称将该模块作为属性访问。

参数:

• 子模块名称（str）- 子模块的名称。可以使用给定的名称从该模块访问子模块

• 模块（Module）- 要添加到模块中的子模块。

apply(fn)[source][source]

Apply fn 递归地应用于每个子模块（如 .children() 返回的）以及自身。

典型用途包括初始化模型的参数（参见 torch.nn.init）。

参数:

fn ( Module -> None) – 对每个子模块应用此函数

返回值:

self

返回类型:

模块

示例：

>>> @torch.no_grad()
>>> def init_weights(m):
>>>     print(m)
>>>     if type(m) == nn.Linear:
>>>         m.weight.fill_(1.0)
>>>         print(m.weight)
>>> net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
>>> net.apply(init_weights)
Linear(in_features=2, out_features=2, bias=True)
Parameter containing:
tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
Linear(in_features=2, out_features=2, bias=True)
Parameter containing:
tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
Sequential(
  (0): Linear(in_features=2, out_features=2, bias=True)
  (1): Linear(in_features=2, out_features=2, bias=True)
)

bfloat16()

将所有浮点参数和缓冲区转换为 bfloat16 数据类型。

注意

此方法会就地修改模块。

返回值:

self

返回类型:

模块

buffers(recurse=True)

返回模块缓冲区的迭代器。

参数:

recurse (布尔) – 如果为 True，则生成此模块及其所有子模块的缓冲区。否则，仅生成此模块的直接成员缓冲区。

生成:

torch.Tensor – 模块缓冲区

返回类型:

迭代器[Tensor]

示例：

>>> for buf in model.buffers():
>>>     print(type(buf), buf.size())
<class 'torch.Tensor'> (20L,)
<class 'torch.Tensor'> (20L, 1L, 5L, 5L)

children()

返回遍历直接子模块的迭代器。

生成:

模块 - 子模块

返回类型:

Iterator[模块]

compile(*args, **kwargs)

使用 torch.compile() 编译此模块的前向。

此模块的__call__方法已编译，所有参数都原样传递给 torch.compile() 。

查看第 0#条以获取此函数参数的详细信息。

cpu()

将所有模型参数和缓冲区移动到 CPU。

注意

此方法会就地修改模块。

返回值:

self

返回类型:

模块

cuda(device=None)

将所有模型参数和缓冲区移动到 GPU 上。

这也将关联的参数和缓冲区变为不同的对象。因此，如果模块将在 GPU 上优化时继续存在，则应在构建优化器之前调用此方法。

注意

此方法会就地修改模块。

参数:

设备（整型，可选）- 如果指定，所有参数都将复制到该设备

返回值:

self

返回类型:

模块

double()[源][源] ¶

将所有浮点参数和缓冲区转换为 double 数据类型。

注意

此方法会就地修改模块。

返回值:

self

返回类型:

模块

eval()

将模块设置为评估模式。

此操作仅对某些模块有效。请参阅特定模块的文档，了解其在训练/评估模式下的行为细节，例如是否受影响，例如 Dropout ， BatchNorm 等。

这与 self.train(False) 等效。

请参阅“局部禁用梯度计算”以比较 .eval() 与其他可能与之混淆的类似机制。

返回值:

self

返回类型:

模块

extra_repr()

返回模块的额外表示。

要打印自定义的额外信息，您应该在您自己的模块中重新实现此方法。单行和多行字符串均可接受。

返回类型:

str

float()[来源][来源] ¶

将所有浮点参数和缓冲区转换为 float 数据类型。

注意

此方法会就地修改模块。

返回值:

self

返回类型:

模块

forward(*input)

定义每次调用时执行的运算。

应由所有子类重写。

注意

虽然前向传播的配方需要在函数内部定义，但应该调用该实例的 Module 而不是这个，因为前者负责运行已注册的钩子，而后者则默默地忽略它们。

get_buffer(target)[source][source]

如果存在，则返回由 target 指定的缓冲区，否则抛出错误。

请参阅 get_submodule 的文档字符串以获取此方法功能以及如何正确指定 target 的更详细说明。

参数:

目标（str）- 要查找的缓冲区的完全限定字符串名称。（参见 get_submodule 了解如何指定完全限定字符串。）

返回值:

由 target 引用的缓冲区

返回类型:

torch.Tensor

引发:

AttributeError - 如果目标字符串引用了无效的路径或解析为不是缓冲区的对象

get_extra_state()[源][源] ¶

将任何额外的状态返回以包含在模块的状态字典中。

如果您需要存储额外的状态，请实现此功能并为您的模块添加相应的 set_extra_state() 。此函数在构建模块的状态字典时被调用。

注意，额外的状态应该是可序列化的，以确保状态字典的序列化工作正常。我们只为序列化张量提供向后兼容性保证；如果其他对象的序列化 pickle 形式发生变化，它们可能会破坏向后兼容性。

返回值:

将任何额外的状态存储在模块的状态字典中

返回类型:

对象

get_parameter(目标)[源][源] ¶

如果存在，则返回由 target 指定的参数，否则抛出错误。

请参阅 get_submodule 的文档字符串以获取此方法功能以及如何正确指定 target 的更详细说明。

参数:

target (str) – 要查找的参数的完全限定字符串名称。（请参阅 get_submodule 了解如何指定完全限定字符串。）

返回值:

引用的参数 target

返回类型:

torch.nn.Parameter

引发:

属性错误 - 如果目标字符串引用了无效的路径或解析为不是 nn.Parameter 的内容

get_submodule(目标)[源][源] ¶

如果存在，则返回由 target 指定的子模块，否则抛出错误。

例如，假设你有一个类似这样的 nn.Module A ：

A(
    (net_b): Module(
        (net_c): Module(
            (conv): Conv2d(16, 33, kernel_size=(3, 3), stride=(2, 2))
        )
        (linear): Linear(in_features=100, out_features=200, bias=True)
    )
)

（图中显示了 nn.Module A . A ，它有一个嵌套的子模块 net_b ，该子模块本身有两个子模块 net_c 和 linear 。 net_c 然后有一个子模块 conv 。）

要检查我们是否有 linear 子模块，我们会调用 get_submodule("net_b.linear") 。要检查我们是否有 conv 子模块，我们会调用 get_submodule("net_b.net_c.conv") 。

get_submodule 的运行时间受模块嵌套程度的限制。对 target 的查询可以达到相同的结果，但它在传递模块的数量上是 O(N)。因此，为了简单地检查是否存在某个子模块，应该始终使用 get_submodule 。

参数:

目标（str）- 要查找的子模块的完全限定字符串名称。（参见上面的示例了解如何指定完全限定字符串。）

返回值:

由 target 引用的子模块

返回类型:

torch.nn.Module

引发:

属性错误 - 如果在从目标字符串生成的路径中，任何（子）路径解析为不存在的属性名称或不是 nn.Module 实例的对象，则会发生此错误。

half()

将所有浮点参数和缓冲区转换为 half 数据类型。

注意

此方法会就地修改模块。

返回值:

self

返回类型:

模块

ipu(设备=None)[源][源] ¶

将所有模型参数和缓冲区移动到 IPU。

这也将使相关的参数和缓冲区成为不同的对象。因此，如果模块将在 IPU 上运行并优化，则应在构建优化器之前调用此操作。

注意

此方法会就地修改模块。

参数:

设备（整型，可选）- 如果指定，所有参数都将复制到该设备

返回值:

self

返回类型:

模块

load_state_dict(state_dict, strict=True, assign=False)

从 state_dict 复制参数和缓冲区到本模块及其子模块。

如果 strict 等于 True ，则 state_dict 的键必须与该模块的 state_dict() 函数返回的键完全匹配。

警告

如果 assign 等于 True ，优化器必须在调用 load_state_dict 之后创建，除非 get_swap_module_params_on_conversion() 等于 True 。

参数:

• state_dict (dict) – 包含参数和持久缓冲区的字典。

• strict (bool, 可选) – 是否严格强制 state_dict 中的键与该模块的 state_dict() 函数返回的键匹配。默认值： True

• 将 (bool, 可选) – 当设置为 False 时，当前模块中张量的属性被保留，而设置为 True 则保留状态字典中张量的属性。唯一的例外是 Default: ``False` 的 requires_grad 字段。

返回值:

• missing_keys 是一个包含任何预期但缺失于提供的 @0# 中的键的字符串列表。

  的此模块但缺失的键列表。

• unexpected_keys 是一个包含不期望的键的字符串列表。

  由本模块预期但出现在提供的 state_dict 中。

返回类型:

使用 NamedTuple 、 missing_keys 和 unexpected_keys 字段

注意

如果一个参数或缓冲区被注册为 None ，并且其对应的关键字存在于 state_dict 中， load_state_dict() 将引发一个 RuntimeError 。

modules()

返回网络中所有模块的迭代器。

生成:

模块 - 网络中的模块

返回类型:

Iterator[模块]

注意

重复模块只返回一次。在下面的示例中， l 只会返回一次。

示例：

>>> l = nn.Linear(2, 2)
>>> net = nn.Sequential(l, l)
>>> for idx, m in enumerate(net.modules()):
...     print(idx, '->', m)

0 -> Sequential(
  (0): Linear(in_features=2, out_features=2, bias=True)
  (1): Linear(in_features=2, out_features=2, bias=True)
)
1 -> Linear(in_features=2, out_features=2, bias=True)

mtia(device=None)

将所有模型参数和缓冲区移动到 MTIA。

这也将关联的参数和缓冲区变为不同的对象。因此，如果模块将在 MTIA 上优化时继续存在，应该在构建优化器之前调用此方法。

注意

此方法会就地修改模块。

参数:

设备（整型，可选）- 如果指定，所有参数都将复制到该设备

返回值:

self

返回类型:

模块

named_buffers(prefix='', recurse=True, remove_duplicate=True)

返回模块缓冲区的迭代器，同时返回缓冲区的名称以及缓冲区本身。

参数:

• prefix（字符串）- 预先添加到所有缓冲区名称的前缀。

• recurse（bool，可选）- 如果为 True，则生成此模块及其所有子模块的缓冲区。否则，仅生成此模块的直接成员缓冲区。默认为 True。

• remove_duplicate（bool，可选）- 是否在结果中删除重复的缓冲区。默认为 True。

生成:

（str，torch.Tensor）- 包含名称和缓冲区的元组

返回类型:

迭代器[tuple[str, torch.Tensor]]

示例：

>>> for name, buf in self.named_buffers():
>>>     if name in ['running_var']:
>>>         print(buf.size())

named_children()

返回一个遍历直接子模块的迭代器，返回模块名称及其本身。

生成:

(str, 模块) - 包含名称和子模块的元组

返回类型:

Iterator[tuple[str, torch.nn.modules.module.Module]]

示例：

>>> for name, module in model.named_children():
>>>     if name in ['conv4', 'conv5']:
>>>         print(module)

named_modules(memo=None, prefix='', remove_duplicate=True)

返回网络中所有模块的迭代器，同时返回模块的名称及其本身。

参数:

• memo (Optional[set[torch.nn.modules.module.Module]]) – 用于存储已添加到结果中的模块集合的备忘录

• prefix (str) – 模块名称前缀，将被添加到模块名称中

• remove_duplicate (bool) – 是否在结果中移除重复的模块实例

生成:

(str, Module) – 名称和模块的元组

注意

重复模块只返回一次。在下面的示例中， l 只会返回一次。

示例：

>>> l = nn.Linear(2, 2)
>>> net = nn.Sequential(l, l)
>>> for idx, m in enumerate(net.named_modules()):
...     print(idx, '->', m)

0 -> ('', Sequential(
  (0): Linear(in_features=2, out_features=2, bias=True)
  (1): Linear(in_features=2, out_features=2, bias=True)
))
1 -> ('0', Linear(in_features=2, out_features=2, bias=True))

named_parameters(prefix='', recurse=True, remove_duplicate=True)

返回模块参数的迭代器，同时返回参数的名称及其本身。

参数:

• prefix (str) – 预先添加到所有参数名称的前缀。

• recurse (bool) – 如果为 True，则生成此模块及其所有子模块的参数。否则，仅生成此模块的直接成员参数。

• remove_duplicate (bool, optional) – 是否从结果中移除重复的参数。默认为 True。

生成:

(str, Parameter) – 包含名称和参数的元组

返回类型:

迭代器[tuple[str, torch.nn.parameter.Parameter]]

示例：

>>> for name, param in self.named_parameters():
>>>     if name in ['bias']:
>>>         print(param.size())

parameters(recurse=True)

返回模块参数的迭代器。

这通常传递给优化器。

参数:

recurse (bool) – 如果为 True，则生成此模块及其所有子模块的参数。否则，仅生成此模块的直接成员参数。

生成:

参数 – 模块参数

返回类型:

迭代器[参数]

示例：

>>> for param in model.parameters():
>>>     print(type(param), param.size())
<class 'torch.Tensor'> (20L,)
<class 'torch.Tensor'> (20L, 1L, 5L, 5L)

注册回退钩子(hook)[源代码][源代码] ¶

在模块上注册反向钩子。

此功能已被弃用，推荐使用 register_full_backward_hook() ，此函数的行为将在未来版本中发生变化。

返回值:

一个可以用来通过调用 handle.remove() 移除已添加钩子的句柄。

返回类型:

torch.utils.hooks.RemovableHandle

注册缓冲区(name, tensor, persistent=True)[源代码][源代码] ¶

将缓冲区添加到模块中。

这通常用于注册一个不应被视为模型参数的缓冲区。例如，BatchNorm 的 running_mean 不是参数，而是模块状态的一部分。缓冲区默认情况下是持久的，将与参数一起保存。通过设置 persistent 为 False 可以改变这种行为。持久缓冲区和非持久缓冲区之间的唯一区别是后者不会成为此模块的 state_dict 的一部分。

缓冲区可以通过给定的名称作为属性进行访问。

参数:

• name (str) – 缓冲区的名称。可以通过给定的名称从该模块访问缓冲区

• tensor (Tensor 或 None) – 要注册的缓冲区。如果为 None ，则忽略在缓冲区上运行的运算，如 cuda 。如果为 None ，则该缓冲区不包括在模块的 state_dict 中。

• 持久性（布尔值）- 是否缓冲区是此模块的 state_dict 的一部分。

示例：

>>> self.register_buffer('running_mean', torch.zeros(num_features))

注册前向钩子(hook, *, prepend=False, with_kwargs=False, always_call=False)[源代码][源代码] ¶

在模块上注册前向钩子。

每当 forward() 计算输出后，都会调用该钩子。

如果 with_kwargs 是 False 或者未指定，则输入只包含传递给模块的位置参数。关键字参数不会传递给钩子，只会传递给 forward 。钩子可以修改输出。它可以就地修改输入，但对前向没有影响，因为这是在调用 forward() 之后调用的。钩子应具有以下签名：

hook(module, args, output) -> None or modified output

如果 with_kwargs 是 True ，则前向钩子将传递给前向函数的 kwargs ，并期望返回可能已修改的输出。钩子应具有以下签名：

hook(module, args, kwargs, output) -> None or modified output

参数:

• hook（可调用对象）- 用户定义的将被注册的钩子。

• prepend（布尔值）- 如果 True ，则提供的 hook 将在所有现有的 forward 钩子之前触发。否则，提供的 hook 将在所有现有的 forward 钩子之后触发。注意，使用 register_module_forward_hook() 注册的全局 forward 钩子将在使用此方法注册的所有钩子之前触发。默认： False

• with_kwargs (bool) – 如果 True ，则 hook 将接收传递给 forward 函数的 kwargs 参数。默认： False

• always_call (bool) – 如果 True ，则无论在调用 Module 时是否抛出异常， hook 都将被执行。默认： False

返回值:

一个可以用来通过调用 handle.remove() 移除已添加钩子的句柄。

返回类型:

torch.utils.hooks.RemovableHandle

注册前向预钩子(hook, *, prepend=False, with_kwargs=False)[源代码][源代码] ¶

在模块上注册一个前置钩子。

每次调用 forward() 之前都会调用此钩子。

如果 with_kwargs 为 false 或未指定，则输入仅包含传递给模块的位置参数。关键字参数不会传递给钩子，只会传递给 forward 。钩子可以修改输入。用户可以在钩子中返回一个元组或单个修改后的值。如果返回单个值（除非该值已经是元组），我们将将其包装成元组。钩子应具有以下签名：

hook(module, args) -> None or modified input

如果 with_kwargs 为 true，则前置钩子将传递给 forward 函数提供的 kwargs。如果钩子修改了输入，则应返回 args 和 kwargs。钩子应具有以下签名：

hook(module, args, kwargs) -> None or a tuple of modified input and kwargs

参数:

• hook（可调用对象）- 用户定义的将被注册的钩子。

• prepend（布尔值）- 如果为 true，提供的 hook 将在所有现有的 forward_pre 钩子之前触发。否则，提供的 hook 将在所有现有的 forward_pre 钩子之后触发。注意，使用 register_module_forward_pre_hook() 注册的全局 forward_pre 钩子将在所有通过此方法注册的钩子之前触发。默认值： False

• with_kwargs（布尔值）- 如果为 true， hook 将传递给前向函数的 kwargs。默认值： False

返回值:

一个可以用来通过调用 handle.remove() 移除已添加钩子的句柄。

返回类型:

torch.utils.hooks.RemovableHandle

注册完整反向钩子(hook, prepend=False)[source][source] ¶

在模块上注册反向钩子。

每当计算模块相对于梯度的值时，都会调用此钩子，即当计算模块输出相对于梯度的值时，钩子将执行。钩子应具有以下签名：

hook(module, grad_input, grad_output) -> tuple(Tensor) or None

grad_input 和 grad_output 是包含相对于输入和输出的梯度的元组。钩子不应修改其参数，但可以可选地返回一个新的相对于输入的梯度，该梯度将用于后续计算中的 grad_input 。 grad_input 只对应于作为位置参数给出的输入，所有关键字参数都被忽略。 grad_input 和 grad_output 中的条目对于所有非-Tensor 参数都是 None 。

由于技术原因，当此钩子应用于模块时，其前向函数将接收传递给模块的每个 Tensor 的视图。同样，调用者将接收模块前向函数返回的每个 Tensor 的视图。

警告

使用反向钩子时，不允许就地修改输入或输出，否则将引发错误。

参数:

• hook (Callable) – 要注册的用户定义钩子。

• prepend (bool) – 如果为 true，则提供的 hook 将在所有现有的 backward 钩子之前触发。否则，提供的 hook 将在所有现有的 backward 钩子之后触发。请注意，使用 register_module_full_backward_hook() 注册的全局 backward 钩子将在使用此方法注册的所有钩子之前触发。

返回值:

一个可以用来通过调用 handle.remove() 移除已添加钩子的句柄。

返回类型:

torch.utils.hooks.RemovableHandle

注册完整反向前钩子(hook, prepend=False)[source][source] ¶

在模块上注册反向前钩子。

每当计算模块的梯度时，都会调用该钩子。钩子应具有以下签名：

hook(module, grad_output) -> tuple[Tensor] or None

grad_output 是一个元组。钩子不应该修改其参数，但它可以可选地返回一个关于输出的新梯度，该梯度将用于后续计算中替代 grad_output 。 grad_output 中的条目对于所有非 Tensor 参数将是 None 。

由于技术原因，当此钩子应用于模块时，其前向函数将接收传递给模块的每个 Tensor 的视图。同样，调用者将接收模块前向函数返回的每个 Tensor 的视图。

警告

使用反向钩子时，不允许就地修改输入，否则将引发错误。

参数:

• hook (Callable) – 要注册的用户定义钩子。

• prepend (bool) – 如果为 true，则提供的 hook 将在所有现有的 backward_pre 钩子之前触发。否则，提供的 hook 将在所有现有的 backward_pre 钩子之后触发。请注意，使用 register_module_full_backward_pre_hook() 注册的全局 backward_pre 钩子将在使用此方法注册的所有钩子之前触发。

返回值:

一个可以用来通过调用 handle.remove() 移除已添加钩子的句柄。

返回类型:

torch.utils.hooks.RemovableHandle

注册加载状态字典后钩子(hook)[source][source] ¶

注册一个在模块的 load_state_dict() 被调用后运行的钩子。

应具有以下签名::

hook(module, incompatible_keys) -> None

module 参数是当前注册此钩子的模块， incompatible_keys 参数是一个包含属性 missing_keys 和 unexpected_keys 的 NamedTuple 。 missing_keys 是一个包含缺失键的 list 的 str ， unexpected_keys 是一个包含意外键的 list 的 str 。

给定的 incompatible_keys 可以在需要时就地修改。

注意，当调用 load_state_dict() 时，执行的检查会受到钩子对 missing_keys 或 unexpected_keys 的修改的影响，这是预期的。向任一集合添加内容将导致在调用 strict=True 时抛出错误，清除缺失和意外的键将避免错误。

返回值:

一个可以用来通过调用 handle.remove() 移除已添加钩子的句柄。

返回类型:

torch.utils.hooks.RemovableHandle

注册加载状态字典前钩子(hook)[source][source] ¶

在模块的 load_state_dict() 被调用之前注册一个预钩子。

应具有以下签名::

hook(module, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs) -> None # noqa: B950

参数:

hook (Callable) – 在加载状态字典之前将被调用的可调用钩子。

注册模块（name，module）

add_module() 的别名

注册参数（name，param）

向模块添加参数。

可以使用给定的名称将该参数作为属性访问。

参数:

• name (str) – 参数名称。可以使用此名称从该模块访问参数

• param (Parameter 或 None) – 要添加到模块的参数。如果为 None ，则忽略对参数运行的运算，如 cuda 。如果为 None ，则参数不包括在模块的 state_dict 中。

注册状态字典后钩子（hook）

注册 state_dict() 方法的后钩子。

应具有以下签名::

hook(module, state_dict, prefix, local_metadata) -> None

已注册的钩子可以修改 state_dict 内部。

注册状态字典前钩子（hook）

注册 state_dict() 方法的预钩子。

应具有以下签名::

hook(module, prefix, keep_vars) -> None

已注册的钩子可以在执行 state_dict 调用之前进行预处理。

requires_grad_(requires_grad=True)

如果自动微分应该记录此模块中参数的操作，请更改。

此方法将参数的 requires_grad 属性就地设置。

此方法有助于冻结模块的一部分以进行微调或单独训练模型的一部分（例如，GAN 训练）。

请参阅本地禁用梯度计算以比较 .requires_grad_() 与可能与之混淆的几个类似机制。

参数:

requires_grad (布尔值) – 是否应在此模块的参数上记录 autograd 操作。默认： True 。

返回值:

self

返回类型:

模块

设置额外状态(state)[source][source] ¶

设置加载的状态字典中包含的额外状态。

此函数从 load_state_dict() 调用，用于处理在 state_dict 中找到的任何额外状态。如果需要在其 state_dict 中存储额外状态，请实现此函数以及相应的 get_extra_state() 。

参数:

state (dict) – 从 state_dict 中获取的额外状态

设置子模块(target, module, strict=False)[source][source] ¶

如果存在，设置由 target 给定的子模块，否则抛出错误。

注意

如果将 strict 设置为 False （默认），则方法将替换现有的子模块或如果父模块存在，则创建新的子模块。如果将 strict 设置为 True ，则方法将仅尝试替换现有的子模块，如果子模块不存在，则抛出错误。

例如，假设你有一个类似这样的 nn.Module A ：

A(
    (net_b): Module(
        (net_c): Module(
            (conv): Conv2d(3, 3, 3)
        )
        (linear): Linear(3, 3)
    )
)

（图示显示了一个 nn.Module A 。 A 有一个嵌套的子模块 net_b ，该子模块本身有两个子模块 net_c 和 linear 。 net_c 然后有一个子模块 conv 。）

要用新的子模块 Linear 覆盖 Conv2d ，你可以调用 set_submodule("net_b.net_c.conv", nn.Linear(1, 1)) ，其中 strict 可以是 True 或 False 。

将新子模块 Conv2d 添加到现有模块 net_b 中，您将调用 set_submodule("net_b.conv", nn.Conv2d(1, 1, 1)) 。

在上述示例中，如果您设置了 strict=True 并调用了 set_submodule("net_b.conv", nn.Conv2d(1, 1, 1), strict=True) ，则会引发 AttributeError 异常，因为 net_b 没有名为 conv 的子模块。

参数:

• 目标（str）- 要查找的子模块的完全限定字符串名称。（参见上面的示例了解如何指定完全限定字符串。）

• module (Module) – 要设置的子模块所在的模块。

• strict（布尔值）- 如果 False ，该方法将替换现有子模块或如果父模块存在则创建新子模块。如果 True ，该方法将仅尝试替换现有子模块，如果子模块不存在则抛出错误。

引发:

• ValueError - 如果 target 字符串为空或如果 module 不是 nn.Module 的实例。

• AttributeError - 如果从 target 字符串生成的路径上的任何点，(子)路径解析为不存在的属性名称或不是 nn.Module 实例的对象。

share_memory()

见 torch.Tensor.share_memory_() 。

返回类型:

T

state_dict(*, destination: T_destination, prefix: str = '', keep_vars: bool = False) → T_destination

state_dict(*, prefix: str = '', keep_vars: bool = False) → dict[str, Any]

返回包含模块整个状态的引用字典。

包含参数和持久缓冲区（例如运行平均值）。键对应参数和缓冲区名称。设置为 None 的参数和缓冲区不包括在内。

注意

返回的对象是浅拷贝。它包含对模块参数和缓冲区的引用。

警告

目前 state_dict() 也接受 destination 、 prefix 和 keep_vars 的位置参数，但这一功能将被弃用，未来版本将强制使用关键字参数。

警告

请避免使用 destination 参数，因为它不是为最终用户设计的。

参数:

• destination (dict, optional) – 如果提供，模块的状态将被更新到 dict 中，并返回相同的对象。否则，将创建一个 OrderedDict 并返回。默认： None 。

• prefix (str, optional) – 添加到参数和缓冲区名称的前缀，用于在 state_dict 中组成键。默认： '' 。

• keep_vars (bool, 可选) – 默认情况下，状态字典中返回的 Tensor s 将从 autograd 中分离。如果设置为 True ，则不会执行分离。默认： False 。

返回值:

包含整个模块状态的字典

返回类型:

字典

示例：

>>> module.state_dict().keys()
['bias', 'weight']

to(device: Optional[DeviceLikeType] = ..., dtype: Optional[dtype] = ..., non_blocking: bool = ...) → Self

to(dtype: dtype, non_blocking: bool = ...) → Self

to(tensor: Tensor, non_blocking: bool = ...) → Self

移动和/或转换参数和缓冲区。

这可以称为

to(device=None, dtype=None, non_blocking=False)

to(dtype, non_blocking=False)

to(tensor, non_blocking=False)

将输入的文本翻译为简体中文如下： 将输入转换为 torch.channels_last 格式[源][源]

其签名与 torch.Tensor.to() 相似，但仅接受浮点或复数 dtype 。此外，此方法将仅将浮点或复数参数和缓冲区转换为 dtype （如果提供）。如果提供，整数参数和缓冲区将移动 device ，但数据类型不变。当 non_blocking 设置时，如果可能，将尝试相对于主机异步转换/移动，例如，将具有固定内存的 CPU 张量移动到 CUDA 设备。

以下为示例。

注意

此方法会就地修改模块。

参数:

• 设备（ torch.device ）- 本模块中参数和缓冲区的期望设备

• 数据类型（ torch.dtype ）- 本模块中参数和缓冲区的期望浮点或复杂数据类型

• 张量（torch.Tensor）- 张量的数据类型和设备为本模块中所有参数和缓冲区的期望数据类型和设备

• 内存格式（ torch.memory_format ）- 本模块中 4D 参数和缓冲区的期望内存格式（关键字参数）

返回值:

self

返回类型:

模块

示例：

>>> linear = nn.Linear(2, 2)
>>> linear.weight
Parameter containing:
tensor([[ 0.1913, -0.3420],
        [-0.5113, -0.2325]])
>>> linear.to(torch.double)
Linear(in_features=2, out_features=2, bias=True)
>>> linear.weight
Parameter containing:
tensor([[ 0.1913, -0.3420],
        [-0.5113, -0.2325]], dtype=torch.float64)
>>> gpu1 = torch.device("cuda:1")
>>> linear.to(gpu1, dtype=torch.half, non_blocking=True)
Linear(in_features=2, out_features=2, bias=True)
>>> linear.weight
Parameter containing:
tensor([[ 0.1914, -0.3420],
        [-0.5112, -0.2324]], dtype=torch.float16, device='cuda:1')
>>> cpu = torch.device("cpu")
>>> linear.to(cpu)
Linear(in_features=2, out_features=2, bias=True)
>>> linear.weight
Parameter containing:
tensor([[ 0.1914, -0.3420],
        [-0.5112, -0.2324]], dtype=torch.float16)

>>> linear = nn.Linear(2, 2, bias=None).to(torch.cdouble)
>>> linear.weight
Parameter containing:
tensor([[ 0.3741+0.j,  0.2382+0.j],
        [ 0.5593+0.j, -0.4443+0.j]], dtype=torch.complex128)
>>> linear(torch.ones(3, 2, dtype=torch.cdouble))
tensor([[0.6122+0.j, 0.1150+0.j],
        [0.6122+0.j, 0.1150+0.j],
        [0.6122+0.j, 0.1150+0.j]], dtype=torch.complex128)

to_empty(*, 设备, recurse=True)[source][source] ¶

将参数和缓冲区移动到指定的设备，而不复制存储。

参数:

• device ( torch.device ) – 此模块中参数和缓冲区所期望的设备。

• recurse (bool) – 是否递归地将子模块的参数和缓冲区移动到指定的设备。

返回值:

self

返回类型:

模块

train(模式=True)[source][source] ¶

设置模块为训练模式。

此设置仅对某些模块有效。有关特定模块在训练/评估模式下的行为细节，请参阅相应模块的文档，例如它们是否受影响，例如 Dropout ， BatchNorm 等。

参数:

mode (bool) – 是否设置训练模式（ True ）或评估模式（ False ）。默认： True 。

返回值:

self

返回类型:

模块

type(dst_type)[source][source] ¶ 类型(dst_type)[来源][来源] ¶

将所有参数和缓冲区转换为 dst_type 。

注意

此方法会就地修改模块。

参数:

dst_type (类型或字符串) – 所需类型

返回值:

self

返回类型:

模块

xpu(设备=None)[source][source] ¶

将所有模型参数和缓冲区移动到 XPU。

这也将关联的参数和缓冲区变为不同的对象。因此，如果模块将在 XPU 上运行并优化，则应在构建优化器之前调用此方法。

注意

此方法会就地修改模块。

参数:

设备（整型，可选）- 如果指定，所有参数都将复制到该设备

返回值:

self

返回类型:

模块

zero_grad(设置为 None=True)[source][source] ¶

重置所有模型参数的梯度。

更多上下文，请参阅 torch.optim.Optimizer 下的类似函数。

参数:

set_to_none (布尔值) – 不是设置为 0，而是将 grads 设置为 None。详见 torch.optim.Optimizer.zero_grad() 。