层和块(深度学习计算)

层和块

之前首次介绍神经网络时&＃xff0c;我们关注的是具有单一输出的线性模型。 在这里&＃xff0c;整个模型只有一个输出。 注意&＃xff0c;

$$单个神经网络\&＃61;⎩$$

⎨

⎧​&＃xff08;1&＃xff09;接受一些输入&＃xff08;2&＃xff09;生成相应的标量输出&＃xff08;3&＃xff09;具有一组相关参数&＃xff08;parameters&＃xff09;​

更新这些参数可以优化某目标函数。

然后&＃xff0c;当考虑具有多个输出的网络时&＃xff0c; 我们利用矢量化算法来描述整层神经元。 像单个神经元一样&＃xff0c;此层

$$⎩$$

⎨

⎧​&＃xff08;1&＃xff09;接受一组输入&＃xff08;2&＃xff09;生成相应的输出&＃xff08;3&＃xff09;由一组可调整参数描述。​

当我们使用softmax回归时&＃xff0c;一个单层本身就是模型。 然而&＃xff0c;即使我们随后引入了多层感知机&＃xff0c;我们仍然可以认为该模型保留了上面所说的基本架构。

对于多层感知机而言&＃xff0c;整个模型及其组成层都是这种架构。整个模型接受原始输入&＃xff08;特征&＃xff09;&＃xff0c;生成输出&＃xff08;预测&＃xff09;&＃xff0c; 并包含一些参数&＃xff08;所有组成层的参数集合&＃xff09;。 同样&＃xff0c;每个单独的层接收输入&＃xff08;由前一层提供&＃xff09;&＃xff0c; 生成输出&＃xff08;到下一层的输入&＃xff09;&＃xff0c;并且具有一组可调参数&＃xff0c; 这些参数根据从下一层反向传播的信号进行更新。

事实证明&＃xff0c;研究讨论 “比单个层大” 但 “比整个模型小” 的组件更有价值。 例如&＃xff0c;在计算机视觉中广泛流行的ResNet-152架构就有数百层&＃xff0c; 这些层是由层组&＃xff08;groups of layers&＃xff09;的重复模式组成。 这个ResNet架构赢得了2015年ImageNet和COCO计算机视觉比赛的识别和检测任务 [He et al., 2016a]。 目前ResNet架构仍然是许多视觉任务的首选架构。 在其他的领域&＃xff0c;如自然语言处理和语音&＃xff0c; 层组以各种重复模式排列的类似架构现在也是普遍存在。

为了实现这些复杂的网络&＃xff0c;我们引入了神经网络块的概念。 块&＃xff08;block&＃xff09;可以描述单个层、由多个层组成的组件或整个模型本身。 使用块进行抽象的一个好处是可以将一些块组合成更大的组件&＃xff0c; 这一过程通常是递归的&＃xff0c;如下图所示。 通过定义代码来按需生成任意复杂度的块&＃xff0c; 我们可以通过简洁的代码实现复杂的神经网络。

从编程的角度来看&＃xff0c;块由 类&＃xff08;class&＃xff09; 表示。 它的任何子类都必须定义一个将其输入转换为输出的前向传播函数&＃xff0c; 并且必须存储任何必需的参数。 注意&＃xff0c;有些块不需要任何参数。 最后&＃xff0c;为了计算梯度&＃xff0c;块必须具有反向传播函数。 在定义我们自己的块时&＃xff0c;由于自动微分提供了一些后端实现&＃xff0c;我们只需要考虑前向传播函数和必需的参数。

在构造自定义块之前&＃xff0c;我们先回顾一下多层感知机的代码。

下面的代码生成一个网络&＃xff0c;其中包含一个具有256个单元和ReLU激活函数的全连接隐藏层&＃xff0c; 然后是一个具有10个隐藏单元且不带激活函数的全连接输出层。

import torch #引入torch
from torch import nn #引入神经网络
from torch.nn import functional as F #引入神经网络中的函数#定义神经网络模型&＃xff0c;其中包含一个隐藏层&＃xff0c;共有256个隐单元
net &＃61; nn.Sequential(nn.Linear(20,256), nn.ReLU(), nn.Linear(256,10))#生成均匀分布的数值&＃xff0c;其中torch.randn()生成的是标准正态分布
X &＃61; torch.rand(2, 20)
net(X) #输出神经网络预测的值


tensor([[ 0.0294, -0.0472, 0.2127, -0.0699, 0.2484, 0.1598, 0.0426, -0.2851,-0.2245, -0.1830],[-0.0524, -0.1220, 0.2092, 0.0616, 0.2616, 0.1025, -0.1069, -0.3397,-0.2035, -0.1531]], grad_fn&＃61;)


在这个例子中&＃xff0c;我们通过实例化nn.Sequential来构建我们的模型&＃xff0c; 层的执行顺序是作为参数传递的。 简而言之&＃xff0c;nn.Sequential定义了一种特殊的Module&＃xff0c; 即在PyTorch中表示一个块的类&＃xff0c; 它维护了一个由Module组成的有序列表。 注意&＃xff0c;两个全连接层都是Linear类的实例&＃xff0c; Linear类本身就是Module的子类。 另外&＃xff0c;到目前为止&＃xff0c;我们一直在通过net(X)调用我们的模型来获得模型的输出。 这实际上是net.__call__(X)的简写。 这个前向传播函数非常简单&＃xff1a; 它将列表中的每个块连接在一起&＃xff0c;将每个块的输出作为下一个块的输入。

自定义块

要想直观地了解块是如何工作的&＃xff0c;最简单的方法就是自己实现一个。 在实现我们自定义块之前&＃xff0c;我们简要总结一下每个块必须提供的基本功能&＃xff1a;

1、将输入数据作为其前向传播函数的参数。2、通过前向传播函数来生成输出。请注意&＃xff0c;输出的形状可能与输入的形状不同。例如&＃xff0c;我们上面模型中的第一个全连接的层接收一个20维的输入&＃xff0c;但是返回一个维度为256的输出。3、计算其输出关于输入的梯度&＃xff0c;可通过其反向传播函数进行访问。通常这是自动发生的。4、存储和访问前向传播计算所需的参数。5、根据需要初始化模型参数。


在下面的代码片段中&＃xff0c;我们从零开始编写一个块。 它包含一个多层感知机&＃xff0c;其具有256个隐藏单元的隐藏层和一个10维输出层。 注意&＃xff0c;下面的MLP类继承了表示块的类。 我们的实现只需要提供我们自己的构造函数&＃xff08;Python中的__init__函数&＃xff09;和前向传播函数。

class MLP(nn.Module):#用模型参数声明层。这里&＃xff0c;我们声明两个全连接层def __init__(self):# 调用MLP的父类Module的构造函数来执行必要的初始化# 这样&＃xff0c;在类实例化也可以指定其它函数参数&＃xff0c;例如模型参数params(稍后会介绍)super().__init__()self.hidden &＃61; nn.Linear(20, 256) #隐藏层self.out &＃61; nn.Linear(256, 10) #输出层#定义模型的前向传播&＃xff0c;即如何根据输入X返回所需的模型参数def forward(self, X):#注意&＃xff0c;这里我们使用ReLU的函数版本&＃xff0c;其在nn.functional模块中定义return self.out(F.relu(self.hidden(X)))

我们首先看一下前向传播函数&＃xff0c;它以X作为输入&＃xff0c; 计算带有激活函数的隐藏表示&＃xff0c;并输出其未规范化的输出值。 在这个MLP实现中&＃xff0c;两个层都是实例变量。 要了解这为什么是合理的&＃xff0c;可以想象实例化两个多层感知机&＃xff08;net1和net2&＃xff09;&＃xff0c; 并根据不同的数据对它们进行训练。 当然&＃xff0c;我们希望它们学到两种不同的模型。

接着我们实例化多层感知机的层&＃xff0c;然后在每次调用前向传播函数时调用这些层。 注意一些关键细节&＃xff1a; 首先&＃xff0c;我们定制的__init__函数通过super().__init__() 调用父类的__init__函数&＃xff0c; 省去了重复编写模版代码的痛苦。 然后&＃xff0c;我们实例化两个全连接层&＃xff0c; 分别为self.hidden和self.out。 注意&＃xff0c;除非我们实现一个新的运算符&＃xff0c; 否则我们不必担心反向传播函数或参数初始化&＃xff0c; 系统将自动生成这些。

net &＃61; MLP()
net(X)


tensor([[ 0.3524, -0.0080, 0.0731, 0.1084, 0.0454, 0.1718, 0.0725, -0.3134,0.1652, -0.2138],[ 0.2220, 0.0433, 0.0600, 0.1555, 0.0924, 0.2730, 0.0395, -0.5403,0.2354, -0.2894]], grad_fn&＃61;)


块的一个主要优点是它的多功能性。 我们可以子类化块以创建层&＃xff08;如全连接层的类&＃xff09;、 整个模型&＃xff08;如上面的MLP类&＃xff09;或具有中等复杂度的各种组件。 我们在接下来的章节中充分利用了这种多功能性&＃xff0c; 比如在处理卷积神经网络时。

顺序块

现在我们可以更仔细地看看Sequential类是如何工作的&＃xff0c; 回想一下Sequential的设计是为了把其他模块串起来。 为了构建我们自己的简化的MySequential&＃xff0c; 我们只需要定义两个关键函数&＃xff1a;

1、一种将块逐个追加到列表中的函数。2、一种前向传播函数&＃xff0c;用于将输入按追加块的顺序传递给块组成的“链条”。


下面的MySequential类提供了与默认Sequential类相同的功能。

#定义顺序块&＃xff0c;用以存储神经网络
class MySequential(nn.Module):#定义类的初始化函数def __init__(self, *args):super().__init__() #调用父类的初始化函数#通过循环不断地向顺序块中添加神经网络for idx, module in enumerate(args):#这里&＃xff0c; module是Module子类的一个实例。我们把它保存在&＃39;Module&＃39;类的成员#变量_modules中。_module的类型是OrderedDictself._modules[str(idx)] &＃61; module#定义前向传播函数def forward(self, X):#OrderedDict保证了按照成员添加地顺序遍历它们for block in self._modules.values():X &＃61; block(X) #顺序地调用X进入神经网络return X


__init__函数将每个模块逐个添加到有序字典_modules中。 你可能会好奇为什么每个Module都有一个_modules属性&＃xff1f; 以及为什么我们使用它而不是自己定义一个Python列表&＃xff1f; 简而言之&＃xff0c;_modules的主要优点是&＃xff1a; 在模块的参数初始化过程中&＃xff0c; 系统知道在_modules字典中查找需要初始化参数的子块。

当MySequential的前向传播函数被调用时&＃xff0c; 每个添加的块都按照它们被添加的顺序执行。 现在可以使用我们的MySequential类重新实现多层感知机。

#实例化顺序块对象
net &＃61; MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))net(X)


tensor([[-0.1506, 0.1624, -0.1427, 0.0080, -0.1948, 0.0842, 0.1825, 0.1821,-0.1700, 0.1438],[-0.1944, 0.1550, -0.1231, 0.0146, -0.1227, -0.0500, 0.2044, 0.1428,-0.2641, -0.0220]], grad_fn&＃61;)


请注意&＃xff0c;MySequential的用法与之前为Sequential类编写的代码相同。

在前向传播函数中执行代码

Sequential类使模型构造变得简单&＃xff0c; 允许我们组合新的架构&＃xff0c;而不必定义自己的类。 然而&＃xff0c;并不是所有的架构都是简单的顺序架构。 当需要更强的灵活性时&＃xff0c;我们需要定义自己的块。 例如&＃xff0c;我们可能希望在前向传播函数中执行Python的控制流。 此外&＃xff0c;我们可能希望执行任意的数学运算&＃xff0c; 而不是简单地依赖预定义的神经网络层。

到目前为止&＃xff0c; 我们网络中的所有操作都对网络的激活值及网络的参数起作用。

然而&＃xff0c;有时我们可能希望合并既不是上一层的结果也不是可更新参数的项&＃xff0c; 我们称之为常数参数&＃xff08;constant parameter&＃xff09;。 例如&＃xff0c;我们需要一个计算函数 $f(x, w) &＃61; c \cdot w^Tx $ 的层&＃xff0c; 其中 $x$ 是输入&＃xff0c; $w$ 是参数&＃xff0c; $c$ 是某个在优化过程中没有更新的指定常量。 因此我们实现了一个FixedHiddenMLP类&＃xff0c;如下所示&＃xff1a;

class FixedHiddenMLP(nn.Module):def __init__(self):super().__init__()#不计算梯度的随机权重参数。因此其在训练期间保持不变self.rand_weight &＃61; torch.rand((20,20), requires_grad&＃61;False)self.linear &＃61; nn.Linear(20,20)def forward(self, X):X &＃61; self.linear(X)#使用创建的常量参数以及relu和mm函数&＃39;X &＃61; F.relu(torch.mm(X, self.rand_weight) &＃43; 1)#复用全连接层。相当于两个全连接层共享参数X &＃61; self.linear(X)#控制流while X.abs().sum() > 1:X /&＃61; 2return X.sum()


在这个 FixedHiddenMLP 模型中&＃xff0c;我们实现了一个隐藏层&＃xff0c; 其权重&＃xff08;self.rand_weight&＃xff09;在实例化时被随机初始化&＃xff0c;之后为常量。 这个权重不是一个模型参数&＃xff0c;因此它永远不会被反向传播更新。 然后&＃xff0c;神经网络将这个固定层的输出通过一个全连接层。

注意&＃xff0c;在返回输出之前&＃xff0c;模型做了一些不寻常的事情&＃xff1a; 它运行了一个while循环&＃xff0c;在 L1L_1L1​ 范数大于 $1$ 的条件下&＃xff0c; 将输出向量除以 $2$ &＃xff0c;直到它满足条件为止。 最后&＃xff0c;模型返回了 $X$ 中所有项的和。 注意&＃xff0c;此操作可能不会常用于在任何实际任务中&＃xff0c; 我们只是向你展示如何将任意代码集成到神经网络计算的流程中。

net &＃61; FixedHiddenMLP()
X, net(X)


(tensor([[0.6002, 0.6970, 0.8435, 0.4162, 0.9259, 0.0152, 0.7891, 0.3840, 0.0942,0.0245, 0.0248, 0.6321, 0.7874, 0.8893, 0.2032, 0.3613, 0.3369, 0.3674,0.0578, 0.7056],[0.1072, 0.3630, 0.9294, 0.6267, 0.3761, 0.1347, 0.8899, 0.8383, 0.0328,0.2300, 0.5797, 0.6842, 0.9483, 0.9679, 0.5453, 0.3542, 0.9578, 0.6276,0.8556, 0.3014]]),tensor(0.3268, grad_fn&＃61;))


我们可以混合搭配各种组合块的方法。 在下面的例子中&＃xff0c;我们以一些想到的方法嵌套块。

class NestMLP(nn.Module):def __init__(self):super().__init__()self.net &＃61; nn.Sequential(nn.Linear(20, 64), nn.ReLU(),nn.Linear(64, 32), nn.ReLU())self.linear &＃61; nn.Linear(32, 16)def forward(self, X):return self.linear(self.net(X))chimera &＃61; nn.Sequential(NestMLP(), nn.Linear(16,20), FixedHiddenMLP())
chimera(X)


tensor(0.0353, grad_fn&＃61;)


小结

1. 一个块可以由许多层组成&＃xff1b;一个块可以由许多块组成。

2. 块可以包含代码。

3. 块负责大量的内部处理&＃xff0c;包括参数初始化和反向传播。

4. 层和块的顺序连接由Sequential块处理。