PyTorch从入门到实践 | (4) 神经网络工具箱nn

在上一篇博客中，我们使用autograd可实现深度学习模型，但其抽象程度较低，如果用其来实现深度学习模型，则需要编写的代码量极大。在这种情况下，torch.nn应运而生，其是专门为深度学习而设计的模块。torch.nn的核心数据结构是Module，它是一个抽象概念，既可以表示神经网络中的某个层（layer），也可以表示一个包含很多层的神经网络。在实际使用中，最常见的做法是继承nn.Module，撰写自己的网络/层。下面先来看看如何用nn.Module实现自己的全连接层。全连接层，又名仿射层，输出y和输入x满足y=wx+b,w和b是可学习的参数。

import torch 
from torch import nn

class Linear(nn.Module): #继承nn.Module
    def __init__(self, in_features, out_features): #输入/输出特征/单元数
        super(Linear, self).__init__() # 调用父类构造函数 等价于nn.Module.__init__(self)
        self.w = nn.Parameter(torch.randn(in_features, out_features))
        self.b = nn.Parameter(torch.randn(out_features))
    
    def forward(self,x):
        x = x.mm(self.w)  #x.@(self.w)  矩阵乘法 wx
        return x + self.b.expand_as(x) #可以利用广播 直接 x+self.b

layer = Linear(4,3)
input = torch.randn(2,4) #(batch_size,in_features)
output = layer(input) #(batch_size,out_features) (2,3)
output

for name, parameter in layer.named_parameters():
    print(name, parameter) # w and b 模型参数都是变量。require_grad=True

可见，全连接层Linear的实现非常简单，其代码量不超过10行，但需注意以下几点：

1) 自定义层Linear必须继承nn.Module，并且在其构造函数中需调用nn.Module的构造函数，即super(Linear, self).__init__() 或nn.Module.__init__(self)，推荐使用第一种用法，尽管第二种写法更直观。

2) 在构造函数__init__中必须自己定义可学习的参数，并封装成Parameter，如在本例中我们把w和b封装成parameter。parameter是一种特殊的Tensor，但其默认需要求导（requires_grad = True），感兴趣的读者可以通过nn.Parameter??，查看Parameter类的源代码。

3) forward函数实现前向传播过程，其输入可以是一个或多个tensor（batch_size）。

4) 无需写反向传播函数，nn.Module能够利用autograd自动实现反向传播，这点比Function简单许多。

5) 使用时，直观上可将layer看成数学概念中的函数，调用layer(input)即可得到input对应的结果。它等价于layer.__call__(input)，在__call__函数中，主要调用的是 layer.forward(x)，另外还对钩子做了一些处理。所以在实际使用中应尽量使用layer(x)而不是使用layer.forward(x)，关于钩子技术将在下文讲解。

6) Module中的可学习参数可以通过named_parameters()或者parameters()返回迭代器，前者会给每个parameter都附上名字，使其更具有辨识度。

可见利用Module实现的全连接层，比利用Function实现的更为简单，因其不再需要写反向传播函数。Module能够自动检测到自己的Parameter，并将其作为学习参数。除了parameter之外，Module还包含子Module，主Module能够递归查找子Module中的parameter。下面再来看看稍微复杂一点的网络，多层感知机。

多层感知机的网络结构如下图所示，它由两个全连接层组成，采用sigmoid函数作为激活函数，图中没有画出。

class Perceptron(nn.Module):
    def __init__(self, in_features, hidden_features, out_features):
        nn.Module.__init__(self)#super(Perceptron, self).__init__()
        self.layer1 = Linear(in_features, hidden_features) # 此处的Linear是前面自定义的全连接层
        self.layer2 = Linear(hidden_features, out_features)
    def forward(self,x):
        x = self.layer1(x)
        x = torch.sigmoid(x)
        return self.layer2(x)

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

可见，即使是稍复杂的多层感知机，其实现依旧很简单。 构造函数__init__中，可利用前面自定义的Linear层(module)，作为当前module对象的一个子module，它的可学习参数，也会成为当前module的可学习参数。

module中parameter的命名规范：

1) 对于类似self.param_name = nn.Parameter(torch.randn(3, 4))，命名为param_name

2) 对于子Module中的parameter，会其名字之前加上当前Module的名字。如对于self.sub_module = SubModel()，SubModel中有个parameter的名字叫做param_name，那么二者拼接而成的parameter name 就是sub_module.param_name。

 

为方便用户使用，PyTorch实现了神经网络中绝大多数的layer，这些layer都继承于nn.Module，封装了可学习参数parameter，并实现了forward函数，且很多都专门针对GPU运算进行了CuDNN优化，其速度和性能都十分优异。本篇博客不准备对nn.Module中的所有层进行详细介绍，具体内容读者可参照官方文档http://pytorch.org/docs/nn.html或在IPython/Jupyter中使用nn.layer?来查看。阅读文档时应主要关注以下几点：

1）构造函数的参数，如nn.Linear(in_features, out_features, bias)，需关注这三个参数的作用。

2）属性、可学习参数和子module。如nn.Linear中有weight和bias两个可学习参数，不包含子module。

3）输入输出的形状，如nn.linear的输入形状是(N, input_features)，输出为(N，output_features)，N是batch_size。

这些自定义layer对输入形状都有假设：输入的不是单个数据，而是一个batch。输入只有一个数据，则必须调用tensor.unsqueeze(0) 或 tensor[None]将数据伪装成batch_size=1的batch。

下面将从应用层面出发，对一些常用的layer做简单介绍，更详细的用法请查看文档，这里只作概览参考。

目录

1. 常用神经网络层

2. 优化器

3. nn.functional

4. 初始化策略

5. nn和autograd的关系

6. nn.Module深入分析

7. 搭建ResNet

---

1. 常用神经网络层

• 图像相关层

图像相关层主要包括卷积层（Conv）、池化层（Pool）等，这些层在实际使用中可分为一维(1D)、二维(2D)、三维（3D），池化方式又分为平均池化（AvgPool）、最大值池化（MaxPool）、自适应池化（AdaptiveAvgPool）等。而卷积层除了常用的前向卷积之外，还有逆卷积（TransposeConv）。下面举例说明一些基础的使用。

from PIL import Image
from torchvision.transforms import ToTensor, ToPILImage
to_tensor = ToTensor() # img(numpy) -> tensor
to_pil = ToPILImage()
lena = Image.open('lena.png')
lena

# 输入是一个batch，这里batch_size＝1 (batch_size,channels,height,width)
input = to_tensor(lena).unsqueeze(0)  #灰度图 (1,1,height=200,width=200)
print(to_tensor(lena).unsqueeze(0).shape)
# 锐化卷积核
kernel = torch.ones(3, 3)/-9.
kernel[1][1] = 1
conv = nn.Conv2d(1, 1, (3, 3), 1, bias=False) #输入通道数，输出通道数，kenerl_size,stride,bias
#kernel_size可以传入3或(3,3) 二者等价
#stride 可以传入1或(1,1) 二者等价
conv.weight.data = kernel.view(1, 1, 3, 3) #自定义卷积核的参数 

out = conv(input) #(1,1,height',width') 输出图像通道数=卷积核数量
to_pil(out.data.squeeze(0)) #(1,height',width')

除了上述的使用，图像的卷积操作还有各种变体，具体可以参照此处动图https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md介绍。

池化层可以看作是一种特殊的卷积层，用来下采样。但池化层没有可学习参数。

#pool = nn.AvgPool2d(2,2) #大小为2*2 步长2*2
pool = nn.AvgPool2d((2,2),(2,2)) #二者等价
list(pool.parameters())

out = pool(input)
to_pil(out.data.squeeze(0))

除了卷积层和池化层，深度学习中还将常用到以下几个层：

1) Linear：全连接层。

2) BatchNorm：批规范化层，分为1D、2D和3D。除了标准的BatchNorm之外，还有在风格迁移中常用到的InstanceNorm层。

3) Dropout：dropout层，用来防止过拟合，同样分为1D、2D和3D。 下面通过例子来说明它们的使用。

# 输入 batch_size=2，输入特征数3
input = torch.randn(2, 3)
linear = nn.Linear(3, 4)
h = linear(input) #（2，4）
h

# BatchNorm()的参数是通道数 以上面的输出h(2,4)为例 我们对他沿0轴进行标准化 所以有4个通道
bn = nn.BatchNorm1d(4)
#每个通道都有一个标准差和均值
bn.weight.data = torch.o