torch.nn.Module()

torch.nn.Module()

如果自己想研究，官方文档

它是所有的神经网络的根父类！ 你的神经网络必然要继承！
模块也可以包含其他模块，允许将它们嵌套在树结构中。所以呢，你可以将子模块指定为常规属性。常规定义子模块的方法如下：

以这种方式分配的子模块将被注册（也就是成为你的该分支下的子类），当你调用to()等方法的时候时，它们的参数也将被转换，等等。
当然子模块就可以包含各种线性or卷积等操作了！ 也就是模型

变量：

1. training (bool) - Boolean表示该模块是处于培训模式还是评估模式。

方法：

1. add_module(name, module)：

将子模块添加到当前模块。
可以使用给定的名称作为属性访问该模块。
参数：

• name： 该处填写子模块的名称
• module： 该处是要添加的子模块！

2. apply(fn)

递归地将fn函数应用于每个子模块(由.children()返回) 和 self。典型的用法包括初始化模型的参数(参见torch.nn.init)。
参数：
fn (Module -> None)：用于每个子模块的函数，中间的参数必然是子模块！ 如果用于参数的初始化，那么就该递归该模块下的各个函数
返回：
self
返回类型：
Module

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

3. children()

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

4. cpu（）

将所有模型参数和缓冲区移动到CPU。
此方法将就地修改模块（应该当前代码之前的所有立刻移动到别处）。

5. cuda（device=None）

将所有模型参数和缓冲区移动到GPU。
这也使得相关的参数和缓冲区成为不同的对象。因此，如果模块将在GPU上运行而被优化，则应该在构建优化器之前调用它。
同样的，此方法将就地修改模块。
参数：
Device (int，optional)-如果指定了，所有参数将被复制到该设备
返回：
slef
返回类型：
Module

6. eval()

将模块设置为评估模式。
这只对某些模块有效。如果他们在培训/评估模式中受到影响，请参阅特定模块的文档以了解他们的行为细节，如Dropout, BatchNorm等。
同时这和 self.train(False) 是同等的！

返回：
slef
返回类型：
Module

7. float（）

将所有浮点参数和缓冲区强制转换为浮点数据类型。
此方法将就地修改模块。
返回：

• slef
  返回类型：
• Module

8. forward（）

定义在每次调用时执行的计算。
应该被所有子类覆盖。
注意： 虽然前向传递的方法需要在这个函数中定义，但是应该在之后调用Module实例而不是这个，因为前者负责运行已注册的钩子，而后者则会默默地忽略它们。

9. get_buffer(target)

如果存在，返回target给出的缓冲区，否则抛出错误。
有关此方法的功能以及如何正确指定目标的更详细的解释，请参阅get_submodule的文档字符串。
参数：

• target - 要查找的缓冲区的全限定字符串名称。(参见get_submodule了解如何指定全限定字符串。)
  Returns
  目标引用的缓冲区
  Return type
  torch.Tensor
  Raises:
  AttributeError—如果目标字符串引用了无效的路径或解析为非缓冲区的内容

10.get_parameter(target)

如果target指定的参数存在，则返回该参数，否则抛出错误。
有关此方法的功能以及如何正确指定目标的更详细的解释，请参阅get_submodule的文档字符串。
参数：

• target - 要查找的参数的全限定字符串名称。(参见get_submodule了解如何指定全限定字符串。)
  Returns
  目标引用的参数
  Return type
  torch.nn.Parameter
  Raises:
  AttributeError—如果目标字符串引用了无效的路径或解析到不是nn.Parameter

11.get_submodule(target)

如果target给出的子模块存在，则返回子模块，否则抛出错误。
例如，假设你有一个nn.Module A是这样的:
(图中显示了一个神经网络。模块A有一个嵌套的子模块net_b，它本身有两个子模块net_c和linear。然后Net_c有一个子模块conv。)

要检查是否有线性子模块，可以调用get_submodule(“net_b.linear”)。要检查是否有conv子模块，可以调用get_submodule(“net_b.net_c.conv”)。
get_submodule运行时受模块在target中的嵌套程度的限制。对named_modules的查询获得了相同的结果，但是传递模块的数量是O(N)。因此，对于检查是否存在子模块的简单检查，应该始终使用get_submodule。
参数：

• target - 要查找的子模块的全限定字符串名称。(参见上面的示例，了解如何指定全限定字符串。)
  Returns
  被target引用的子模块
  Return type
  torch.nn.Modules
  Raises:
  AttributeError—如果目标字符串引用了无效的路径或解析到不是nn.Module

12.load_state_dict(state_dict, strict=True)

将state_dict中的参数和缓冲区复制到该模块及其后代模块中。如果strict为True，则state_dict的键必须与该模块的*state_dict()*函数返回的键完全匹配。
参数：

• State_dict (dict): 一个包含参数和持久缓冲区的字典。
• Strict (bool，optional): 是否严格强制state_dict中的键与该模块的*state_dict()*函数返回的键相匹配。默认值:Ture
  Returns
• Missing_keys是一个包含丢失键的STR列表
• unexpected keys是一个包含意外键的STR列表
  Return type
  NamedTuple with missing_keys and unexpected_keys fields

13. modules()

返回包含网络中所有模块的一个迭代器。
**迭代器的意思就是可以被for循环访问！**而经过for循环后得到的就是一个又一个的tuple！

产生：
Module – a module in the network
重复的模块只返回一次。在下面的示例中，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)

14. named_children()

返回直接子模块上的迭代器，生成模块名和模块本身（模块本身啥子哦？ ）。
如果返回的是两个，可以记住这个格式，如果满足条件就输出特定模块！

产生：
(string, Module) – 包含名称和子模块的元组

例子：

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

15. parameters(recurse=True)

返回模块参数上的迭代器。
这通常被传递给优化器。
参数：
recurse (bool) -如果为True，则生成该模块和所有子模块的参数。否则，只生成该模块的直接成员参数。

产生：
Parameter – module parameter

举例：

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

16. requires_grad_(requires_grad=True)

更改autograd是否应该记录此模块中参数的操作。
该方法就地设置参数的requires_grad属性。
这种方法有助于冻结模块的一部分，以便对模型的各个部分进行微调或单独训练(如GAN训练)。
请参阅Locally disabling gradient computation 来比较**.requires_grad_()**和几个可能与之混淆的类似机制。
参数：
Requires_grad (bool) - autograd是否应该记录对该模块中的参数的操作。默认值:真的。
返回：
self
Return type：
Module

17. state_dict(destination=None, prefix=’’, keep_vars=False)

返回包含整个模块状态的字典。
**参数和持久缓冲区(**例如运行平均值)都包括在内。键是相应的参数和缓冲区名称。
返回：
包含模块的整个状态的字典
Return type：
dict
举例：

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

18. to(*args, **kwargs)

移动和/或强制转换参数和缓冲区。
这里可以被叫做：

它的签名类似于torch.Tensor.to()，但只接受浮点数或复杂的dtype’s。此外，该方法只将浮点数或复杂参数和缓冲区强制转换为:attr: ’ dtype(如果给定)。
如果给定，整型参数和缓冲区将被移到device，但dtype不变。当设置non_blocking时，如果可能的话，它会尝试相对于主机进行异步转换/移动，例如，将带有固定内存的CPU张量移动到CUDA设备。

此方法将就地修改模块。

Parameters

• device(torch.device) -在这个模块中参数和缓冲器的期望设备
• Dtype(torch.dtype) -这个模块中参数和缓冲区的浮点型或复杂的Dtype
• tensor(torch.tensor)-张量的dtype和设备是这个模块中所有参数和缓冲区所需的dtype和设备
• memory_format (torch.memory_format) -该模块中4D参数和缓冲区所需的内存格式(仅关键字参数)
  返回：
  self
  Return type：
  Module

举例：

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

19. train(mode=True)

将模块设置为训练模式。
这只对某些模块有效。如果他们在培训/评估模式中受到影响，请参阅特定模块的文档以了解他们的行为细节，如Dropout, BatchNorm等。

参数：
mode (bool) -是否设置训练模式(True)或评估模式(False)。默认值:真的。
返回：
self
Return type：
Module

20. zero_grad(set_to_none=False)

设置所有模型参数的梯度为零。更多内容请查看torch. optim. optimizer下的类似函数。
参数：
set_to_none (bool) -不设置为零，而是将梯度值设置为None。详见torch. optimizer . optimizer .zero_grad()。