动手学深度学习-16

敖炜 Lv5
  2023-08-19 14:03:02 2023-08-19 14:03:02 创建   2024-04-19 09:28:28 2024-04-19 09:28:28 更新      5.2k 字  19 分钟  

PyTorch神经网络基础

层和块

  1. 事实证明，研究讨论“比单个层大”但“比整个模型小”的组件更有价值。

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

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

  4. 先回顾一下多层感知机

    1
    2
    3
    4
    5
    6
    7
    8
    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)

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

自定义块

  1. 每个块必须提供的基本功能：

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

  2. 从零开始编写一个块

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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)))

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

顺序块

  1. Sequential的设计是为了把其他模块串起来。为了构建我们自己的简化的MySequential，我们只需要定义两个关键函数：

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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

__init__函数将每个模块逐个添加到有序字典_modules中。_modules的主要优点是：在模块的参数初始化过程中，
系统知道在_modules字典中查找需要初始化参数的子块。

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

Sequential类使模型构造变得简单，允许我们组合新的架构，而不必定义自己的类。然而，并不是所有的架构都是简单的顺序架构。当需要更强的灵活性时，我们需要定义自己的块。例如，我们可能希望在前向传播函数中执行Python的控制流。此外，我们可能希望执行任意的数学运算，而不是简单地依赖预定义的神经网络层。到目前为止，我们网络中的所有操作都对网络的激活值及网络的参数起作用。然而，有时我们可能希望合并既不是上一层的结果也不是可更新参数的项，我们称之为常数参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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()

我们可以混合搭配各种组合块的方法

1
2
3
4
5
6
7
8
9
10
11
12
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)

效率

Python的问题全局解释器锁 是众所周知的。在深度学习环境中，我们担心速度极快的GPU可能要等到CPU运行Python代码后才能运行另一个作业。

小结

  • 一个块可以由许多层组成；一个块可以由许多块组成。
  • 块可以包含代码。
  • 块负责大量的内部处理，包括参数初始化和反向传播。
  • 层和块的顺序连接由Sequential块处理。

参数管理

在选择了架构并设置了超参数后，我们就进入了训练阶段。 此时，我们的目标是找到使损失函数最小化的模型参数值。 经过训练后，我们将需要使用这些参数来做出未来的预测。 此外，有时我们希望提取参数，以便在其他环境中复用它们， 将模型保存下来，以便它可以在其他软件中执行， 或者为了获得科学的理解而进行检查。

在这里，将介绍以下内容：

  • 访问参数，用于调试、诊断和可视化
  • 参数初始化
  • 在不同模型组件间共享参数

参数访问

我们从已有模型中访问参数。 当通过Sequential类定义模型时， 我们可以通过索引来访问模型的任意层。 这就像模型是一个列表一样，每层的参数都在其属性中。 如下所示，我们可以检查第二个全连接层的参数。

1
print(net[2].state_dict())

输出的结果告诉我们一些重要的事情： 首先，这个全连接层包含两个参数，分别是该层的权重和偏置。 两者都存储为单精度浮点数（float32）。 注意，参数名称允许唯一标识每个参数，即使在包含数百个层的网络中也是如此。

目标参数

每个参数都表示为参数类的一个实例。要对参数执行任何操作，首先我们需要访问底层的数值。 有几种方法可以做到这一点。有些比较简单，而另一些则比较通用。 下面的代码从第二个全连接层（即第三个神经网络层）提取偏置， 提取后返回的是一个参数类实例，并进一步访问该参数的值。

1
2
3
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)

参数是复合的对象，包含值、梯度和额外信息。 这就是我们需要显式参数值的原因。 除了值之外，我们还可以访问每个参数的梯度。 在上面这个网络中，由于我们还没有调用反向传播，所以参数的梯度处于初始状态。

一次性访问所有参数

当我们需要对所有参数执行操作时，逐个访问它们可能会很麻烦。 当我们处理更复杂的块（例如，嵌套块）时，情况可能会变得特别复杂， 因为我们需要递归整个树来提取每个子块的参数。 下面，我们将通过演示来比较访问第一个全连接层的参数和访问所有层。

1
2
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])

也有另一种访问网络参数的方式

1
net.state_dict()['2.bias'].data

从嵌套块收集参数

将多个块相互嵌套，参数命名约定的工作方式。我们首先定义一个生成块的函数（可以说是“块工厂”），然后将这些块组合到更大的块中。

1
2
3
4
5
6
7
8
9
10
11
12
13
def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())

def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在这里嵌套
        net.add_module(f'block {i}', block1())
    return net

rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)

看看它是如何工作的

1
print(rgnet)

因为层是分层嵌套的，所以我们也可以像通过嵌套列表索引一样访问它们。 下面，我们访问第一个主要的块中、第二个子块的第一层的偏置项。

1
rgnet[0][1][0].bias.data

参数初始化

深度学习框架提供默认随机初始化， 也允许我们创建自定义初始化方法， 满足我们通过其他规则实现初始化权重。
默认情况下，PyTorch会根据一个范围均匀地初始化权重和偏置矩阵， 这个范围是根据输入和输出维度计算出的。 PyTorch的nn.init模块提供了多种预置初始化方法。

内置初始化

下面的代码将所有权重参数初始化为标准差为0.01的高斯随机变量， 且将偏置参数设置为0。

1
2
3
4
5
6
def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, mean=0, std=0.01)
        nn.init.zeros_(m.bias)
net.apply(init_normal)
net[0].weight.data[0], net[0].bias.data[0]

可以将所有参数初始化为给定的常数，比如初始化为1

1
2
3
4
5
6
7
def init_constant(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)

net.apply(init_constant)
net[0].weight.data[0], net[0],bias.data[0]

还可以对某些块应用不同的初始化方法。下面我们使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42。

1
2
3
4
5
6
7
8
9
10
def init_xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)

def init_42(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 43)

net[0].apply(init_xavier)
net[2].apply(init_42)

自定义初始化

有时，深度学习框架没有提供我们需要的初始化方法。我们实现一个my_init函数来应用到net

1
2
3
4
5
6
7
8
9
10
11
def my_init(m):
    if type(m) == nn.Linear:
        print("Init", *[(name, param.shape)
        for name, param in m.named_parameters()][0])

        nn.init.uniform_(m.weight, -10, 10)

        m.weight.data *= m.weight.data.abs >= 5

net.apply(my_init)
net[0].weight[:2]

我们始终可以直接设置参数

1
2
3
net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]

参数绑定

有时我们希望在多个层间共享参数： 我们可以定义一个稠密层，然后使用它的参数来设置另一个层的参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 我们需要给共享层一个名称，以便可以引用它的参数
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                    shared, nn.ReLU(),
                    shared, nn.ReLU(),
                    nn.Linear(8,1))

net(X)
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])

net[2].weight.data[0, 0] = 100
# 确保它们实际上是同一个对象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])

当参数绑定时，由于模型参数包含梯度，因此在反向传播期间第二个隐藏层 （即第三个神经网络层）和第三个隐藏层（即第五个神经网络层）的梯度会加在一起

小结

  • 我们有几种方法可以访问、初始化和绑定模型参数。
  • 我们可以使用自定义初始化方法。

延后初始化

到目前为止，我们忽略了建立网络时需要做的以下这些事情：

  • 我们定义了网络架构，但没有指定输入维度。
  • 我们添加层时没有指定前一层的输出维度。
  • 我们在初始化参数时，甚至没有足够的信息来确定模型应该包含多少参数。

深度学习框架无法判断网络的输入维度是什么，是框架的延后初始化（defers initialization），即直到数据第一次通过模型传递时，框架才会动态地推断出每个层的大小。

在以后，当使用卷积神经网络时， 由于输入维度（即图像的分辨率）将影响每个后续层的维数， 有了该技术将更加方便。 现在我们在编写代码时无须知道维度是什么就可以设置参数， 这种能力可以大大简化定义和修改模型的任务。 接下来，我们将更深入地研究初始化机制。

实例化网络

首先实例化一个多层感知机

1
net = nn.Sequential(nn.LazyLinear(256), nn.ReLU(), nn.LazyLinear(10))

此时，因为输入维数是未知的，所以网络不可能知道输入层权重的维数。 因此，框架尚未初始化任何参数，我们通过尝试访问以下参数进行确认。

1
net[0].weight

接下来让我们将数据通过网络，最终使框架初始化参数。

1
2
3
4
X = torch.rand(2, 20)
net(X)

net[0].weight.shape

一旦我们知道输入维数是20，框架可以通过代入值20来识别第一层权重矩阵的形状。 识别出第一层的形状后，框架处理第二层，依此类推，直到所有形状都已知为止。 注意，在这种情况下，只有第一层需要延迟初始化，但是框架仍是按顺序初始化的。 等到知道了所有的参数形状，框架就可以初始化参数。

小结

  • 延后初始化使框架能够自动推断参数形状，使修改模型架构变得容易，避免了一些常见的错误。
  • 我们可以通过模型传递数据，使框架最终初始化参数。

自定义层

深度学习成功背后的一个因素是神经网络的灵活性： 我们可以用创造性的方式组合不同的层，从而设计出适用于各种任务的架构。有时我们会遇到或要自己发明一个现在在深度学习框架中还不存在的层。 在这些情况下，必须构建自定义层。

不带参数的层

首先，构造一个没有任何参数的自定义层。下面的CenteredLayer类要从其输入中减去均值。 要构建它，我们只需继承基础层类并实现前向传播功能。

1
2
3
4
5
6
7
8
9
10
import torch
import torch.nn.functional as F
from troch as nn

class CenteredLayer(nn.Moudle):
    def __init__(self):
        super().__init__()

    def forward(self, X):
        return X - X.mean()

然后，我们可以将层作为组件合并到更复杂的模型中

1
2
3
layer = CenteredLayer()

net = nn.Sequential(nn.Linear(8, 128), layer)

带参数的层

我们可以使用内置函数来创建参数，这些函数提供一些基本的管理功能。 比如管理访问、初始化、共享、保存和加载模型参数。 这样做的好处之一是：我们不需要为每个自定义层编写自定义的序列化程序。 

1
2
3
4
5
6
7
8
9
class MyLinear(nn.Moudle):
    def __init__(self, in_units, units):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(in_units, units))
        self.bias = nn.Parameter(torch.randn(units, ))

    def forward(self, X):
        linear = torch.matmul(X, self.weight.data) + self.bias.data
        return F.relu(linear)

小结

  • 我们可以通过基本层类设计自定义层。这允许我们定义灵活的新层，其行为与深度学习框架中的任何现有层不同。
  • 在自定义层定义完成后，我们就可以在任意环境和网络架构中调用该自定义层。
  • 层可以有局部参数，这些参数可以通过内置函数创建。

读写文件

有时我们希望保存训练的模型， 以备将来在各种环境中使用（比如在部署中进行预测）。 此外，当运行一个耗时较长的训练过程时， 最佳的做法是定期保存中间结果， 以确保在服务器电源被不小心断掉时，我们不会损失几天的计算结果。 因此，现在是时候学习如何加载和存储权重向量和整个模型了

加载和保存张量

对于单个张量，我们可以直接调用load和save函数分别读写它们。 这两个函数都要求我们提供一个名称，save要求将要保存的变量作为输入。

1
2
3
4
5
6
import torch
from torch import nn
from torch.nn import functional as F

x = torch.arange(4)
torch.save(x, 'x-file')

将存储在文件中的数据读回内存

1
x2 = torch.load("x-file")

可以存储一个张量列表，然后把它们读回内存

1
2
3
y = torch.zeros(4)
torch.save([x, y], "x-files")
x2, y2 = torch.load("x-files")

可以写入或读取从字符串映射到张量的字典。当我们要读取或写入模型中的所有权重时，这很方便

1
2
3
mydict = {'x' : x, 'y' : y}
torch.save(mydict, 'mydict')
mydict2 = torch.load('mydict')

加载和保存模型参数

保存单个权重向量（或其他张量）确实有用， 但是如果我们想保存整个模型，并在以后加载它们， 单独保存每个向量则会变得很麻烦。 毕竟，我们可能有数百个参数散布在各处。 因此，深度学习框架提供了内置函数来保存和加载整个网络。 需要注意的一个重要细节是，这将保存模型的参数而不是保存整个模型。 例如，如果我们有一个3层多层感知机，我们需要单独指定架构。 因为模型本身可以包含任意代码，所以模型本身难以序列化。 因此，为了恢复模型，我们需要用代码生成架构， 然后从磁盘加载参数。 让我们从熟悉的多层感知机开始尝试一下。

** 网络的架构无法被存储

1
2
3
4
5
6
7
8
9
10
class MLP(nn.Moudle):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(20, 256)
        self.output = nn.Linear(256, 10)

    def forward(self, x):
        return self.output(F.relu(self.hidden(x)))

net = MLP()

将模型的参数存储在一个叫做“mlp.params”的文件中

1
torch.save(net.state_dict(), "mlp.params")

为了恢复模型，我们实例化了原始多层感知机模型的一个备份。这里我们不需要随机初始化模型参数，而是直接读取文件中存储的参数。

1
2
3
4
5
clone = MLP()

clone.load_state_dict(torch.load("mpl.params"))

clone.eval() # 将模型设置为评估模式。在评估模式下，模型会禁用一些特定的层，如随机失活层（dropout)和批量归一化(batchnorm)层中的计算，并确保模型在推理时保持一致性。

小结

  • save和load函数可用于张量对象的文件读写。
  • 我们可以通过参数字典保存和加载网络的全部参数。
  • 保存架构必须在代码中完成，而不是在参数中完成。

GPU

  • 标题: 动手学深度学习-16
  • 作者: 敖炜
  • 创建于 : 2023-08-19 14:03:02
  • 更新于 : 2024-04-19 09:28:28
  • 链接: https://ao-wei.github.io/2023/08/19/动手学深度学习-16/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
此页目录
动手学深度学习-16
  1. 层和块
    1. 自定义块
    2. 顺序块
    3. 在前向传播函数中执行代码
    4. 效率
    5. 小结
  2. 参数管理
    1. 参数访问
    2. 参数初始化
    3. 参数绑定
    4. 小结
  3. 延后初始化
    1. 实例化网络
    2. 小结
  4. 自定义层
    1. 不带参数的层
    2. 带参数的层
    3. 小结
  5. 读写文件
    1. 加载和保存张量
    2. 加载和保存模型参数
    3. 小结
  6. GPU