『PyTorch』第七弹_nn.Module扩展层

有下面代码能够看出torch层函数(nn.Module)用法，使用超参数实例化层函数类(常位于网络class的__init__中)，而网络class实际上就是一个高级的递归的nn.Module的class。

 

一般

torch.nn的核心数据结构是Module，它是一个抽象概念，既能够表示神经网络中的某个层（layer），也能够表示一个包含不少层的神经网络。

在实际使用中，最多见的作法是继承nn.Module，撰写本身的网络/层。

• 自定义层Linear必须继承nn.Module，而且在其构造函数中需调用nn.Module的构造函数，即super(Linear, self).__init__() 或nn.Module.__init__(self)，推荐使用第一种用法。
• 在构造函数__init__中必须本身定义可学习的参数，并封装成Parameter，如在本例中咱们把w和b封装成parameter。parameter是一种特殊的Variable，但其默认须要求导（requires_grad = True）。
• forward函数实现前向传播过程，其输入能够是一个或多个variable，对x的任何操做也必须是variable支持的操做。
• 无需写反向传播函数，因其前向传播都是对variable进行操做，nn.Module可以利用autograd自动实现反向传播，这点比Function简单许多。
• 使用时，直观上可将layer当作数学概念中的函数，调用layer(input)便可获得input对应的结果。它等价于layers.__call__(input)，在__call__函数中，主要调用的是 layer.forward(x)，另外还对钩子作了一些处理。因此在实际使用中应尽可能使用layer(x)而不是使用layer.forward(x)。
• Module中的可学习参数能够经过named_parameters()或者parameters()返回迭代器，前者会给每一个parameter都附上名字，使其更具备辨识度。

Module可以自动检测到本身的Parameter，并将其做为学习参数。

可见利用Module实现的全链接层，比利用Function实现的更为简单，因其再也不须要写反向传播函数。

import torch as t
from torch import nn
from torch.autograd import Variable as V

class Linear(nn.Module):
    def __init__(self, in_features, out_features):
        # nn.Module.__init__(self)
        super(Linear, self).__init__()
        self.w = nn.Parameter(t.randn(in_features, out_features)) # nn.Parameter是特殊Variable
        self.b = nn.Parameter(t.randn(out_features))
        
    def forward(self, x):
        x = x.mm(self.w)
        return x + self.b

layer = Linear(4, 3)
input = V(t.randn(2, 4))
output = layer(input)
print(output)

for name, Parameter in layer.named_parameters():
    print(name, Parameter)

Variable containing:
 4.1151  2.4139  3.5544
-0.4792 -0.9400 -7.6010
[torch.FloatTensor of size 2x3]

w Parameter containing:
 1.1856  0.9246  1.1707
 0.2632 -0.1697  0.7543
-0.4501 -0.2762 -3.1405
-1.1943  1.2800  1.0712
[torch.FloatTensor of size 4x3]

b Parameter containing:
 1.9577
 1.8570
 0.5249
[torch.FloatTensor of size 3]

 

递归

除了parameter以外，Module还包含子Module，主Module可以递归查找子Module中的parameter。

• 构造函数__init__中，可利用前面自定义的Linear层(module)，做为当前module对象的一个子module，它的可学习参数，也会成为当前module的可学习参数。
• 在前向传播函数中，咱们有意识地将输出变量都命名成x，是为了能让Python回收一些中间层的输出，从而节省内存。但并非全部都会被回收，有些variable虽然名字被覆盖，但其在反向传播仍须要用到，此时Python的内存回收模块将经过检查引用计数，不会回收这一部份内存。

module中parameter的命名规范：

• 对于相似self.param_name = nn.Parameter(t.randn(3, 4))，命名为param_name
• 对于子Module中的parameter，会其名字以前加上当前Module的名字。如对于self.sub_module = SubModel()，SubModel中有个parameter的名字叫作param_name，那么两者拼接而成的parameter name 就是sub_module.param_name。

下面再来看看稍微复杂一点的网络，多层感知机：

class Perceptron (nn.Module):
    def __init__(self, in_features, hidden_features, out_features):
        nn.Module.__init__(self)
        self.layer1 = Linear(in_features, hidden_features)
        self.layer2 = Linear(hidden_features, out_features)
        
    def forward(self, x):
        x = self.layer1(x)
        x = t.sigmoid(x)
        return self.layer2(x)

per = Perceptron(3, 4, 1)
for name, param in per.named_parameters():
    print(name, param.size())

('layer1.w', torch.Size([3, 4]))
('layer1.b', torch.Size([4]))
('layer2.w', torch.Size([4, 1]))
('layer2.b', torch.Size([1]))