深度学习入门(十七)深度学习计算——层和块
前言
核心内容来自博客链接1博客连接2希望大家多多支持作者
本文记录用,防止遗忘
深度学习计算——层和块
教材
之前首次介绍神经网络时,我们关注的是具有单一输出的线性模型。 在这里,整个模型只有一个输出。 注意,单个神经网络 (1)接受一些输入; (2)生成相应的标量输出; (3)具有一组相关参数(parameters),更新这些参数可以优化某目标函数。
然后,当考虑具有多个输出的网络时, 我们利用矢量化算法来描述整层神经元。 像单个神经元一样,层(1)接受一组输入, (2)生成相应的输出, (3)由一组可调整参数描述。 当我们使用softmax回归时,一个单层本身就是模型。 然而,即使我们随后引入了多层感知机,我们仍然可以认为该模型保留了上面所说的基本架构。
对于多层感知机而言,整个模型及其组成层都是这种架构。 整个模型接受原始输入(特征),生成输出(预测), 并包含一些参数(所有组成层的参数集合)。 同样,每个单独的层接收输入(由前一层提供), 生成输出(到下一层的输入),并且具有一组可调参数, 这些参数根据从下一层反向传播的信号进行更新。
事实证明,研究讨论“比单个层大”但“比整个模型小”的组件更有价值。 例如,在计算机视觉中广泛流行的ResNet-152架构就有数百层, 这些层是由层组(groups of layers)的重复模式组成。 这个ResNet架构赢得了2015年ImageNet和COCO计算机视觉比赛 的识别和检测任务 [He et al., 2016a]。 目前ResNet架构仍然是许多视觉任务的首选架构。 在其他的领域,如自然语言处理和语音, 层组以各种重复模式排列的类似架构现在也是普遍存在。
为了实现这些复杂的网络,我们引入了神经网络块的概念。 块(block)可以描述单个层、由多个层组成的组件或整个模型本身。 使用块进行抽象的一个好处是可以将一些块组合成更大的组件, 这一过程通常是递归的,如下图所示。 通过定义代码来按需生成任意复杂度的块, 我们可以通过简洁的代码实现复杂的神经网络。
从编程的角度来看,块由类(class)表示。 它的任何子类都必须定义一个将其输入转换为输出的前向传播函数, 并且必须存储任何必需的参数。 注意,有些块不需要任何参数。 最后,为了计算梯度,块必须具有反向传播函数。 在定义我们自己的块时,由于自动微分提供了一些后端实现,我们只需要考虑前向传播函数和必需的参数。
在构造自定义块之前,我们先回顾一下多层感知机的代码。 下面的代码生成一个网络,其中包含一个具有256个单元和ReLU激活函数的全连接隐藏层, 然后是一个具有10个隐藏单元且不带激活函数的全连接输出层。
import torch
from torch import nn
from torch.nn import functional as F
net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
X = torch.rand(2, 20)
net(X)
输出:
tensor([[-0.0027, -0.1434, -0.1546, -0.0132, -0.0526, -0.0805, 0.0701, -0.0266,
-0.3559, 0.0209],
[-0.0266, -0.0299, -0.1644, 0.0258, 0.0119, -0.0249, 0.0197, -0.1271,
-0.2947, -0.0362]], grad_fn=<AddmmBackward0>)
在这个例子中,我们通过实例化nn.Sequential
来构建我们的模型, 层的执行顺序是作为参数传递的。 简而言之,nn.Sequential
定义了一种特殊的Module
, 即在PyTorch中表示一个块的类, 它维护了一个由Module
组成的有序列表。 注意,两个全连接层都是Linear
类的实例, Linear
类本身就是Module
的子类。 另外,到目前为止,我们一直在通过net(X)
调用我们的模型来获得模型的输出。 这实际上是net.__call__(X)
的简写。 这个前向传播函数非常简单: 它将列表中的每个块连接在一起,将每个块的输出作为下一个块的输入。
1 自定义块
要想直观地了解块是如何工作的,最简单的方法就是自己实现一个。 在实现我们自定义块之前,我们简要总结一下每个块必须提供的基本功能:
1、将输入数据作为其前向传播函数的参数。
2、通过前向传播函数来生成输出。请注意,输出的形状可能与输入的形状不同。例如,我们上面模型中的第一个全连接的层接收一个20维的输入,但是返回一个维度为256的输出。
3、计算其输出关于输入的梯度,可通过其反向传播函数进行访问。通常这是自动发生的。
4、存储和访问前向传播计算所需的参数。
5、根据需要初始化模型参数
在下面的代码片段中,我们从零开始编写一个块。 它包含一个多层感知机,其具有256个隐藏单元的隐藏层和一个10维输出层。 注意,下面的MLP
类继承了表示块的类。 我们的实现只需要提供我们自己的构造函数(Python中的__init__
函数)和前向传播函数。
Module
类是nn
模块里提供的一个模型构造类,是所有神经网络模块的基类,我们可以继承它来定义我们想要的模型。这里定义的MLP
类重载了Module
类的__init__
函数和forward
函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。
class MLP(nn.Module):
# 用模型参数声明层。这里,我们声明两个全连接的层
def __init__(self):
# 调用MLP的父类Module的构造函数来执行必要的初始化。
# 这样,在类实例化时也可以指定其他函数参数,例如模型参数params(稍后将介绍)
super().__init__()
self.hidden = nn.Linear(20, 256) # 隐藏层
self.out = nn.Linear(256, 10) # 输出层
# 定义模型的前向传播,即如何根据输入X返回所需的模型输出
def forward(self, X):
# 注意,这里我们使用ReLU的函数版本,其在nn.functional模块中定义。
return self.out(F.relu(self.hidden(X)))
我们首先看一下前向传播函数,它以X
作为输入, 计算带有激活函数的隐藏表示,并输出其未规范化的输出值。 在这个MLP
实现中,两个层都是实例变量。 要了解这为什么是合理的,可以想象实例化两个多层感知机(net1和net2), 并根据不同的数据对它们进行训练。 当然,我们希望它们学到两种不同的模型。
以上的MLP
类中无须定义反向传播函数。系统将通过自动求梯度而自动生成反向传播所需的backward
函数。
接着我们实例化多层感知机的层,然后在每次调用前向传播函数时调用这些层。 注意一些关键细节: 首先,我们定制的__init__
函数通过super().__init__()
调用父类的__init__
函数, 省去了重复编写模版代码的痛苦。 然后,我们实例化两个全连接层, 分别为self.hidden
和self.out
。 注意,除非我们实现一个新的运算符, 否则我们不必担心反向传播函数或参数初始化, 系统将自动生成这些。
我们来试一下这个函数:
net = MLP()
net(X)
输出:
tensor([[ 0.0485, 0.0470, 0.0624, -0.0909, 0.1269, 0.1685, 0.1925, 0.0550,
0.0284, -0.0801],
[ 0.0298, -0.0346, 0.0377, -0.0936, -0.0451, 0.1722, 0.1295, 0.0615,
0.0682, -0.0011]], grad_fn=<AddmmBackward0>)
我们可以实例化MLP
类得到模型变量net
。下面的代码初始化net
并传入输入数据X做一次前向计算。其中,net(X)
会调用MLP
继承自Module
类的__call__
函数,这个函数将调用MLP
类定义的forward
函数来完成前向计算。
X = torch.rand(2, 784)
net = MLP()
print(net)
net(X)
输出:
MLP(
(hidden): Linear(in_features=784, out_features=256, bias=True)
(act): ReLU()
(output): Linear(in_features=256, out_features=10, bias=True)
)
tensor([[-0.1798, -0.2253, 0.0206, -0.1067, -0.0889, 0.1818, -0.1474, 0.1845,
-0.1870, 0.1970],
[-0.1843, -0.1562, -0.0090, 0.0351, -0.1538, 0.0992, -0.0883, 0.0911,
-0.2293, 0.2360]], grad_fn=<ThAddmmBackward>)
注意,这里并没有将Module
类命名为Layer
(层)或者Model
(模型)之类的名字,这是因为该类是一个可供自由组建的部件。它的子类既可以是一个层(如PyTorch提供的Linear
类),又可以是一个模型(如这里定义的MLP类)
块的一个主要优点是它的多功能性。 我们可以子类化块以创建层(如全连接层的类)、 整个模型(如上面的MLP类)或具有中等复杂度的各种组件。 我们在接下来的章节中充分利用了这种多功能性, 比如在处理卷积神经网络时。
2 顺序块 Sequential类
现在我们可以更仔细地看看Sequential
类是如何工作的, 回想一下Sequential
的设计是为了把其他模块串起来。 为了构建我们自己的简化的MySequential
, 我们只需要定义两个关键函数:
1.一种将块逐个追加到列表中的函数。
2. 一种前向传播函数,用于将输入按追加块的顺序传递给块组成的“链条”。
当模型的前向计算为简单串联各个层的计算时,Sequential
类可以通过更加简单的方式定义模型。这正是Sequential
类的目的:它可以接收一个子模块的有序字典(OrderedDict
)或者一系列子模块作为参数来逐一添加Module
的实例,而模型的前向计算就是将这些实例按添加的顺序逐一计算。
下面的MySequential
类提供了与默认Sequential
类相同的功能。
class MySequential(nn.Module):
def __init__(self, *args):
super().__init__()
for idx, module in enumerate(args):
# 这里,module是Module子类的一个实例。我们把它保存在'Module'类的成员
# 变量_modules中。_module的类型是OrderedDict
self._modules[str(idx)] = module
def forward(self, X):
# OrderedDict保证了按照成员添加的顺序遍历它们
for block in self._modules.values():
X = block(X)
return X
class MySequential(nn.Module):
from collections import OrderedDict
def __init__(self, *args):
super(MySequential, self).__init__()
if len(args) == 1 and isinstance(args[0], OrderedDict): # 如果传入的是一个OrderedDict
for key, module in args[0].items():
self.add_module(key, module) # add_module方法会将module添加进self._modules(一个OrderedDict)
else: # 传入的是一些Module
for idx, module in enumerate(args):
self.add_module(str(idx), module)
def forward(self, input):
# self._modules返回一个 OrderedDict,保证会按照成员添加时的顺序遍历成员
for module in self._modules.values():
input = module(input)
return input
__init__
函数将每个模块逐个添加到有序字典_modules
中。 你可能会好奇为什么每个Module
都有一个_modules
属性? 以及为什么我们使用它而不是自己定义一个Python列表? 简而言之,_modules
的主要优点是: 在模块的参数初始化过程中, 系统知道在_modules
字典中查找需要初始化参数的子块。
当MySequential
的前向传播函数被调用时, 每个添加的块都按照它们被添加的顺序执行。 现在可以使用我们的MySequential
类重新实现多层感知机。
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
net(X)
输出:
tensor([[-0.0077, 0.0073, -0.1978, 0.0472, -0.0503, 0.0230, -0.3637, -0.0708,
0.1103, -0.0739],
[ 0.0431, -0.0212, -0.1294, 0.1650, 0.0585, -0.0102, -0.3153, -0.1349,
0.0603, -0.0431]], grad_fn=<AddmmBackward0>)
请注意,MySequential
的用法与之前为Sequential
类编写的代码相同
3 在前向传播函数中执行代码
Sequential
类使模型构造变得简单, 允许我们组合新的架构,而不必定义自己的类。 然而,并不是所有的架构都是简单的顺序架构。 当需要更强的灵活性时,我们需要定义自己的块。 例如,我们可能希望在前向传播函数中执行Python的控制流。 此外,我们可能希望执行任意的数学运算, 而不是简单地依赖预定义的神经网络层。
到目前为止, 我们网络中的所有操作都对网络的激活值及网络的参数起作用。 然而,有时我们可能希望合并既不是上一层的结果也不是可更新参数的项, 我们称之为常数参数(constant parameter)。 例如,我们需要一个计算函数
f
(
x
,
w
)
=
c
⋅
w
⊤
x
f(\mathbf{x},\mathbf{w}) = c \cdot \mathbf{w}^\top \mathbf{x}
f(x,w)=c⋅w⊤x的层, 其中
x
\mathbf{x}
x是输入,
w
\mathbf{w}
w是参数,
c
c
c是某个在优化过程中没有更新的指定常量。 因此我们实现了一个FixedHiddenMLP
类,如下所示:
class FixedHiddenMLP(nn.Module):
def __init__(self):
super().__init__()
# 不计算梯度的随机权重参数。因此其在训练期间保持不变
self.rand_weight = torch.rand((20, 20), requires_grad=False)
self.linear = nn.Linear(20, 20)
def forward(self, X):
X = self.linear(X)
# 使用创建的常量参数以及relu和mm函数
X = F.relu(torch.mm(X, self.rand_weight) + 1)
# 复用全连接层。这相当于两个全连接层共享参数
X = self.linear(X)
# 控制流
while X.abs().sum() > 1:
X /= 2
return X.sum()
在这个FixedHiddenMLP
模型中,我们实现了一个隐藏层, 其权重(self.rand_weight)在实例化时被随机初始化,之后为常量。 这个权重不是一个模型参数,因此它永远不会被反向传播更新。 然后,神经网络将这个固定层的输出通过一个全连接层。
注意,在返回输出之前,模型做了一些不寻常的事情: 它运行了一个while
循环,在
L
1
L_1
L1范数大于1的条件下, 将输出向量除以2,直到它满足条件为止。 最后,模型返回了X中所有项的和。 注意,此操作可能不会常用于在任何实际任务中, 我们只是向你展示如何将任意代码集成到神经网络计算的流程中。
net = FixedHiddenMLP()
net(X)
输出:
tensor(-0.0949, grad_fn=<SumBackward0>)
我们可以混合搭配各种组合块的方法。 在下面的例子中,我们以一些想到的方法嵌套块。
class NestMLP(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
nn.Linear(64, 32), nn.ReLU())
self.linear = nn.Linear(32, 16)
def forward(self, X):
return self.linear(self.net(X))
chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(X)
输出:
tensor(-0.1322, grad_fn=<SumBackward0>)
4 效率
你可能会开始担心操作效率的问题。 毕竟,我们在一个高性能的深度学习库中进行了大量的字典查找、 代码执行和许多其他的Python代码。 Python的问题全局解释器锁 是众所周知的。 在深度学习环境中,我们担心速度极快的GPU可能要等到CPU运行Python代码后才能运行另一个作业。
5 ModuleList类
ModuleList
接收一个子模块的列表作为输入,然后也可以类似List
那样进行append
和extend
操作:
net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # # 类似List的append操作
print(net[-1]) # 类似List的索引访问
print(net)
# net(torch.zeros(1, 784)) # 会报NotImplementedError
输出:
Linear(in_features=256, out_features=10, bias=True)
ModuleList(
(0): Linear(in_features=784, out_features=256, bias=True)
(1): ReLU()
(2): Linear(in_features=256, out_features=10, bias=True)
)
既然Sequential
和ModuleList
都可以进行列表化构造网络,那二者区别是什么呢。ModuleList
仅仅是一个储存各种模块的列表,这些模块之间没有联系也没有顺序(所以不用保证相邻层的输入输出维度匹配),而且没有实现forward
功能需要自己实现,所以上面执行net(torch.zeros(1, 784))
会报NotImplementedError
;而Sequential
内的模块需要按照顺序排列,要保证相邻层的输入输出大小相匹配,内部forward
功能已经实现。
ModuleList
的出现只是让网络定义前向传播时更加灵活,见下面官网的例子。
class MyModule(nn.Module):
def __init__(self):
super(MyModule, self).__init__()
self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])
def forward(self, x):
# ModuleList can act as an iterable, or be indexed using ints
for i, l in enumerate(self.linears):
x = self.linears[i // 2](x) + l(x)
return x
另外,ModuleList
不同于一般的Python的list
,加入到ModuleList
里面的所有模块的参数会被自动添加到整个网络中,下面看一个例子对比一下。
class Module_ModuleList(nn.Module):
def __init__(self):
super(Module_ModuleList, self).__init__()
self.linears = nn.ModuleList([nn.Linear(10, 10)])
class Module_List(nn.Module):
def __init__(self):
super(Module_List, self).__init__()
self.linears = [nn.Linear(10, 10)]
net1 = Module_ModuleList()
net2 = Module_List()
print("net1:")
for p in net1.parameters():
print(p.size())
print("net2:")
for p in net2.parameters():
print(p)
输出:
net1:
torch.Size([10, 10])
torch.Size([10])
net2:
6 ModuleDict类
ModuleDict
接收一个子模块的字典作为输入, 然后也可以类似字典那样进行添加访问操作:
net = nn.ModuleDict({
'linear': nn.Linear(784, 256),
'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 添加
print(net['linear']) # 访问
print(net.output)
print(net)
# net(torch.zeros(1, 784)) # 会报NotImplementedError
输出:
Linear(in_features=784, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)
ModuleDict(
(act): ReLU()
(linear): Linear(in_features=784, out_features=256, bias=True)
(output): Linear(in_features=256, out_features=10, bias=True)
)
和ModuleList
一样,ModuleDict
实例仅仅是存放了一些模块的字典,并没有定义forward
函数需要自己定义。同样,ModuleDict
也与Python的Dict
有所不同,ModuleDict
里的所有模块的参数会被自动添加到整个网络中。
7 构造复杂的模型
虽然上面介绍的这些类可以使模型构造更加简单,且不需要定义forward
函数,但直接继承Module
类可以极大地拓展模型构造的灵活性。下面我们构造一个稍微复杂点的网络FancyMLP
。在这个网络中,我们通过get_constant
函数创建训练中不被迭代的参数,即常数参数。在前向计算中,除了使用创建的常数参数外,我们还使用Tensor
的函数和Python
的控制流,并多次调用相同的层。
class FancyMLP(nn.Module):
def __init__(self, **kwargs):
super(FancyMLP, self).__init__(**kwargs)
self.rand_weight = torch.rand((20, 20), requires_grad=False) # 不可训练参数(常数参数)
self.linear = nn.Linear(20, 20)
def forward(self, x):
x = self.linear(x)
# 使用创建的常数参数,以及nn.functional中的relu函数和mm函数
x = nn.functional.relu(torch.mm(x, self.rand_weight.data) + 1)
# 复用全连接层。等价于两个全连接层共享参数
x = self.linear(x)
# 控制流,这里我们需要调用item函数来返回标量进行比较
while x.norm().item() > 1:
x /= 2
if x.norm().item() < 0.8:
x *= 10
return x.sum()
在这个FancyMLP
模型中,我们使用了常数权重rand_weight
(注意它不是可训练模型参数)、做了矩阵乘法操作(torch.mm
)并重复使用了相同的Linear
层。下面我们来测试该模型的前向计算。
X = torch.rand(2, 20)
net = FancyMLP()
print(net)
net(X)
输出:
FancyMLP(
(linear): Linear(in_features=20, out_features=20, bias=True)
)
tensor(0.8432, grad_fn=<SumBackward0>)
因为FancyMLP
和Sequential
类都是Module
类的子类,所以我们可以嵌套调用它们。
class NestMLP(nn.Module):
def __init__(self, **kwargs):
super(NestMLP, self).__init__(**kwargs)
self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU())
def forward(self, x):
return self.net(x)
net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP())
X = torch.rand(2, 40)
print(net)
net(X)
输出:
Sequential(
(0): NestMLP(
(net): Sequential(
(0): Linear(in_features=40, out_features=30, bias=True)
(1): ReLU()
)
)
(1): Linear(in_features=30, out_features=20, bias=True)
(2): FancyMLP(
(linear): Linear(in_features=20, out_features=20, bias=True)
)
)
tensor(14.4908, grad_fn=<SumBackward0>)
8 小结
一个块可以由许多层组成;一个块可以由许多块组成。
块可以包含代码。
块负责大量的内部处理,包括参数初始化和反向传播。
层和块的顺序连接由Sequential块处理。