4.1 模型构造

  1. import torch
  2. from torch import nn
  4. print(torch.__version__)
  1. 1.1.0

4.1.1 继承 Module 类来构造模型

Module 是 torch.nn 模块提供的一个模型构造类，是所有神经网络模块的基类

  1. class MLP(nn.Module):
  2.     # 声明带有模型参数的层，这里声明了两个全连接层
  3.     def __init__(self, **kwargs):
  4.         # 调用MLP父类Block的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数参数
  5.         super(MLP, self).__init__(**kwargs)
  6.         self.hidden = nn.Linear(784, 256) # 隐藏层
  7.         self.act = nn.ReLU()
  8.         self.output = nn.Linear(256, 10)  # 输出层
  11.     # 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
  12.     def forward(self, x):
  13.         a = self.act(self.hidden(x))
  14.         return self.output(a)
  1. X = torch.rand(2, 784)
  2. net = MLP()
  3. print(net)
  4. net(X)
  7. """
  8. MLP(
  9.   (hidden): Linear(in_features=784, out_features=256, bias=True)
  10.   (act): ReLU()
  11.   (output): Linear(in_features=256, out_features=10, bias=True)
  12. )
  15. tensor([[ 0.0234, -0.2646, -0.1168, -0.2127,  0.0884, -0.0456,  0.0811,  0.0297,
  16.           0.2032,  0.1364],
  17.         [ 0.1479, -0.1545, -0.0265, -0.2119, -0.0543, -0.0086,  0.0902, -0.1017,
  18.           0.1504,  0.1144]], grad_fn=<AddmmBackward>)
  19. """

4.1.2 Module 的子类

4.1.2.1 Sequential 类

Sequential 类可以通过更加简单的方式定义模型

  1. class MySequential(nn.Module):
  2.     from collections import OrderedDict
  3.     def __init__(self, *args):
  4.         super(MySequential, self).__init__()
  5.         if len(args) == 1 and isinstance(args[0], OrderedDict): # 如果传入的是一个OrderedDict
  6.             for key, module in args[0].items():
  7.                 # key 是这个模块的名称
  8.                 # module 是模块的实现方法
  9.                 self.add_module(key, module)  # add_module方法会将module添加进self._modules(一个OrderedDict)
  10.         else:  # 传入的是一些Module
  11.             for idx, module in enumerate(args):
  12.                 self.add_module(str(idx), module)
  14.     def forward(self, input):
  15.         # self._modules返回一个 OrderedDict，保证会按照成员添加时的顺序遍历成
  16.         for module in self._modules.values():
  17.             input = module(input)
  18.         return input
  1. net = MySequential(
  2.         nn.Linear(784, 256),
  3.         nn.ReLU(),
  4.         nn.Linear(256, 10), 
  5.         )
  6. print(net)
  7. net(X)
  10. # 输出
  11. """
  12. MySequential(
  13.   (0): Linear(in_features=784, out_features=256, bias=True)
  14.   (1): ReLU()
  15.   (2): Linear(in_features=256, out_features=10, bias=True)
  16. )
  19. tensor([[ 0.1273,  0.1642, -0.1060,  0.1401,  0.0609, -0.0199, -0.0140, -0.0588,
  20.           0.1765, -0.1296],
  21.         [ 0.0267,  0.1670, -0.0626,  0.0744,  0.0574,  0.0413,  0.1313, -0.1479,
  22.           0.0932, -0.0615]], grad_fn=<AddmmBackward>)
  23. """
  1. from collections import OrderedDict
  2. net = MySequential(
  3.     OrderedDict([("Linear_1", nn.Linear(784, 256)),
  4.                 ("relu_1", nn.ReLU()),
  5.                 ("Linear_2", nn.Linear(256, 10))])
  6. )
  8. print(net)
  10. """
  11. MySequential(
  12.   (Linear_1): Linear(in_features=784, out_features=256, bias=True)
  13.   (relu_1): ReLU()
  14.   (Linear_2): Linear(in_features=256, out_features=10, bias=True)
  15. )
  16. """

4.1.2.2 ModuleList 类

ModuleList 接收⼀个⼦模块的列表作为输⼊，然后也可以类似List那样进⾏append和extend操作

  1. net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
  2. net.append(nn.Linear(256, 10)) # # 类似List的append操作
  3. print(net[-1])  # 类似List的索引访问
  4. print(net)
  5. # net(torch.zeros(1, 784)) # 会报NotImplementedError
  7. """
  8. Linear(in_features=256, out_features=10, bias=True)
  9. ModuleList(
  10.   (0): Linear(in_features=784, out_features=256, bias=True)
  11.   (1): ReLU()
  12.   (2): Linear(in_features=256, out_features=10, bias=True)
  13. )
  14. """
  1. class MyModule(nn.Module):
  2.     def __init__(self):
  3.         super(MyModule, self).__init__()
  4.         self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])
  6.     def forward(self, x):
  7.         # ModuleList can act as an iterable, or be indexed using ints
  8.         for i, l in enumerate(self.linears):
  9.             x = self.linears[i // 2](x) + l(x)
  10.         return x
  1. class Module_ModuleList(nn.Module):
  2.     def __init__(self):
  3.         super(Module_ModuleList, self).__init__()
  4.         self.linears = nn.ModuleList([nn.Linear(10, 10)])
  6. class Module_List(nn.Module):
  7.     def __init__(self):
  8.         super(Module_List, self).__init__()
  9.         self.linears = [nn.Linear(10, 10)]
  11. net1 = Module_ModuleList()
  12. net2 = Module_List()
  14. print("net1:")
  15. for p in net1.parameters():
  16.     print(p.size())
  18. print("net2:")
  19. for p in net2.parameters():
  20.     print(p)
  23. """
  24. net1:
  25. torch.Size([10, 10])
  26. torch.Size([10])
  27. net2:
  28. """

4.1.2.3 ModuleDict 类

ModuleDict 接收⼀个⼦模块的字典作为输⼊, 然后也可以类似字典那样进⾏添加访问操作:

  1. net = nn.ModuleDict({
  2.     'linear': nn.Linear(784, 256),
  3.     'act': nn.ReLU(),
  4. })
  5. net['output'] = nn.Linear(256, 10) # 添加
  6. print(net['linear']) # 访问
  7. print(net.output)
  8. print(net)
  9. # net(torch.zeros(1, 784)) # 会报NotImplementedError
  12. """
  13. Linear(in_features=784, out_features=256, bias=True)
  14. Linear(in_features=256, out_features=10, bias=True)
  15. ModuleDict(
  16.   (act): ReLU()
  17.   (linear): Linear(in_features=784, out_features=256, bias=True)
  18.   (output): Linear(in_features=256, out_features=10, bias=True)
  19. )
  20. """

4.1.3 构造复杂的模型

虽然上⾯介绍的这些类可以使模型构造更加简单，且不需要定义 forward 函数，但直接继承 Module类可以极⼤地拓展模型构造的灵活性。下⾯我们构造⼀个稍微复杂点的⽹络 FancyMLP 。在这个⽹络
中，我们通过 get_constant 函数创建训练中不被迭代的参数，即常数参数。在前向计算中，除了使⽤
创建的常数参数外，我们还使⽤ Tensor 的函数和Python的控制流，并多次调⽤相同的层。 V

  1. class FancyMLP(nn.Module):
  2.     def __init__(self, **kwargs):
  3.         super(FancyMLP, self).__init__(**kwargs)
  5.         self.rand_weight = torch.rand((20, 20), requires_grad=False) # 不可训练参数（常数参数）
  6.         self.linear = nn.Linear(20, 20)
  8.     def forward(self, x):
  9.         x = self.linear(x)
  10.         # 使用创建的常数参数，以及nn.functional中的relu函数和mm函数
  11.         x = nn.functional.relu(torch.mm(x, self.rand_weight.data) + 1)
  13.         # 复用全连接层。等价于两个全连接层共享参数
  14.         x = self.linear(x)
  15.         # 控制流，这里我们需要调用item函数来返回标量进行比较
  16.         while x.norm().item() > 1:
  17.             x /= 2
  18.         if x.norm().item() < 0.8:
  19.             x *= 10
  20.         return x.sum()
  1. X = torch.rand(2, 20)
  2. net = FancyMLP()
  3. print(net)
  4. net(X)
  6. """
  7. FancyMLP(
  8.   (linear): Linear(in_features=20, out_features=20, bias=True)
  9. )
  12. tensor(0.8907, grad_fn=<SumBackward0>)
  13. """
  1. class NestMLP(nn.Module):
  2.     def __init__(self, **kwargs):
  3.         super(NestMLP, self).__init__(**kwargs)
  4.         self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU()) 
  6.     def forward(self, x):
  7.         return self.net(x)
  9. net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP())
  11. X = torch.rand(2, 40)
  12. print(net)
  13. net(X)
  18. """
  19. Sequential(
  20.   (0): NestMLP(
  21.     (net): Sequential(
  22.       (0): Linear(in_features=40, out_features=30, bias=True)
  23.       (1): ReLU()
  24.     )
  25.   )
  26.   (1): Linear(in_features=30, out_features=20, bias=True)
  27.   (2): FancyMLP(
  28.     (linear): Linear(in_features=20, out_features=20, bias=True)
  29.   )
  30. )
  34. tensor(-0.4605, grad_fn=<SumBackward0>)
  35. """