0602-nn.Module
0602-nn.Module
pytorch完整教程目录：https://www.cnblogs.com/nickchen121/p/14662511.html
一、nn.Module
torch.nn 的核心数据结构就是 Module，它可以看做是某一层，也可以看做是整个神经网络。最常见的做法就是直接继承 nn.module，然后构建自己的网络模型结构。
1.1 构建一层网络——全连接层
接下来我们通过使用 nn.Module 实现一个全连接层（仿射层），输出 y 和输入 x 满足 \(y=Wx+b\)，其中 w 和 b 是可学习参数。
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): # 输入的数据维度，输出的数据维度
super(Linear,
self).__init__() # 等价于 nn.Module.__init__(self)，继承父类的init构造函数
self.w = nn.Parameter(t.randn(in_features, out_features))
self.b = nn.Parameter(t.randn(out_features))
def forward(self, x):
x = x.mm(self.w)
return x + self.b.expand_as(x)
layer = Linear(4, 3)
input = V(t.randn(2, 4))
output = layer(input) # y = Wx + b 的形状是(2,3) = (2,4)*(4*3)+(1,3).expanda_as(x)
output
tensor([[ 1.1407, -0.1323, 0.3659],
[ 2.4265, -1.2330, -0.9984]], grad_fn=<AddBackward0>)
for name, parameter in layer.named_parameters():
print(name, parameter)
w Parameter containing:
tensor([[-1.3990, -1.9669, -0.0430],
[ 0.8150, 0.8829, -1.0932],
[-0.3793, 0.2708, 0.9691],
[-0.9613, -0.3259, 0.5103]], requires_grad=True)
b Parameter containing:
tensor([ 0.9333, -0.7481, -0.6074], requires_grad=True)
从上述代码可以看出实现一个全连接层非常简单，但是需要注意以下几点：
- 自定义 Linear 必须要继承
nn.Module，并且自定义类的构造函数需要继承nn.Module的构造函数 - 在构造函数中必须自己定义可学习的参数，并且要封装为 Parameter，上述代码则是把 w 和 b 封装成 Parameter，并且可以发现 Parameter 这种数据结构默认
requires_grad=True - forward 函数的作用是实现前向传播过程，其输入可以是一个或多个 variable，对 x 的任何操作也必须是 variable 支持的操作
- 不需要自己写一个反向传播函数，因为它的前向传播都是对 variable 进行操作，
nn.Module能够利用 autograd 自动进行反向传播 - 调用
layer(input)时就能得到 input 的结果，其实它的内部是做了layer.__call__(input)操作，在 call 函数中，主要调用了layer.forward(x)，另外还对钩子做了一定的处理，因此直接使用layer(x)，而不是使用layer.forward(x)，钩子的具体内容会在接下来讲解。对于__call__的作用，可以参考这篇文章：详解__call__
1.2 构建多层网络——多层感知机
上述只是实现了一个一层网络结构的模型，下面我们通过更复杂的网络——多层感知机，来感受下 Module 的模块真正强大的地方。多层感知机的网络结构如下图所示：
从多层感知机的网络结构，我们可以看出它由两个全连接层组成，并且它采用 sigimoid 函数作为激活函数。
class Perceptron(nn.Module):
def __init__(self, in_features, hidden_features, out_features):
nn.Module.__init__(self)
self.layer1 = Linear(in_features,
hidden_features) # 此处的 Linear 是前面定义的全连接层
self.layer2 = Linear(hidden_features, out_features)
def forward(self, x):
x = self.layer1(x)
x = t.sigimoid(x)
return self.layer2(x)
perceptron = Perceptron(3, 4, 1)
for name, param in perceptron.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])
从上述代码中，可以看出多层感知机也非常容易，但是也要注意以下两点：
- 构造函数中，可以利用前面自定义的 Linear 层作为当前 module 对象的一个子 module，并且它的可学习参数也会称为当前 module 的可学习参数，也就是说主 module 可以递归查找子 module 中的 parameter
- 在前向传播过程中，我们将输出变量都命名为 x，是为了让 Python 回收一些中间层的输出，从而节省内存，但是有些 variable 虽然名字被覆盖，但是由于它在反向传播过程中仍然需要用到，此时 Python 不会回收这部分数据
对于 parameter的命名有如下规范：
- 如果没有子模块，parameter 直接命名。例如
self.param_name = nn.Parameter(t.randn(3,4))，则会命名称为 param_name - 对于子模块的 parameter，会在它的名字前面加上当前 module 的名字。例如
self.sub_module = SubModel()，SubModel 中也有个名字叫做 param_name 的 parameter，则它的实际名字为sub_module.param_name
虽然我们自己定义神经网络的层（layer）看起来不是特别费力，但是 torch 为了让用书使用起来更方便，它对绝大多数的 layer 都做了封装，此处不做延伸，有兴趣的可以去参照官方文档，或者参考这一篇文章：0802_转载-nn模块中的网络层介绍
阅读上述介绍的文章时，需要注意下面三点：
- 构造函数的参数，如
nn.Linear(in_features, out_features, bias)，需要关注这三个参数的作用 - 属性、可学习参数和子 module。例如
nn.Linear中有 weight 和 bias 两个可学习参数，不包含子 module - 输入输出的形状，如
nn.linear的输入形状是(N,input_features)，输出是(N, output_features)，其中 N 是 batch_size
注：这些自定义的 layer 对输入性状都有一定的假设：输入的不是一个数据，而是一个 batch。如果想要输入一个数据，必须调用 unsqueeze(0) 函数将数据伪装成 batch_size=1 的batch
