5 深度学习计算

5.1 层和块

块（block）可以描述单个层、由多个层组成的组件或整个模型本身。 块由类（class）表示。 它的任何子类都必须定义一个将其输入转换为输出的前向传播函数， 并且必须存储任何必需的参数。 注意，有些块不需要任何参数。 最后，为了计算梯度，块必须具有反向传播函数。总体来说，应该具有以下内容：

1. 将输入数据作为其前向传播函数的参数。
2. 通过前向传播函数来生成输出。请注意，输出的形状可能与输入的形状不同。
3. 计算其输出关于输入的梯度，可通过其反向传播函数进行访问。通常这是自动发生的。
4. 存储和访问前向传播计算所需的参数。
5. 根据需要初始化模型参数。

import torch
import torch.nn as nn
import torch.nn.functional as F


""" 5.1.1 自定义块 """


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)))


net = MLP()

""" 5.1.2 顺序块 """


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


net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))


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


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()


""" 5.1.4 混搭各种组合块 """


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())

5.2 参数管理

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

具体操作略。

5.3 延后初始化

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

例如: net = nn.Sequential(nn.LazyLinear(256), nn.ReLU(),nn.Linear(256,10))

5.4 自定义层

5.4.1 不含模型参数的自定义层

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

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

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

5.4.2 含模型参数的自定义层

class MyLinear(nn.Module):
    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)

net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))

5.5 读写文件

定期保存中间结果

5.5.1 读写张量

# 张量
x = torch.arange(4)
torch.save(x, 'x-file')
x2 = torch.load('x-file')

# 张量列表
y = torch.zeros(4)
torch.save([x, y],'x-files')
x2, y2 = torch.load('x-files')

# 从字符串映射到张量的字典
mydict = {'x': x, 'y': y}
torch.save(mydict, 'mydict')
mydict2 = torch.load('mydict')

5.5.2 读写模型参数

注意：仅保存模型参数而不是整个模型。

net = MLP()
X = torch.randn(size=(2, 20))
Y = net(X)

torch.save(net.state_dict(), 'mlp.params')
clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))

5.6 GPU计算

在PyTorch中，每个数组都有一个设备（device）， 我们通常将其称为环境（context）。

1. 默认情况下，所有变量和相关的计算都分配给CPU。
2. 计算的所有输入数据都必须在同一设备上，无论是CPU还是GPU。
3. 不经意地移动数据可能会显著降低性能。一个典型的错误如下：计算GPU上每个小批量的损失，并在命令行中将其报告给用户（或将其记录在NumPy ndarray中）时，将触发全局解释器锁，从而使所有GPU阻塞。最好是在GPU内存中为日志分配专门的空间，将小批量的损失累积到较大的日志中，只有在必要时才将整个日志移动到CPU进行打印或记录。

def try_gpu(i=0):
    """如果存在，则返回gpu(i)，否则返回cpu()"""
    if torch.cuda.device_count() >= i + 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')

def try_all_gpus():
    """返回所有可用的GPU，如果没有GPU，则返回[cpu(),]"""
    devices = [torch.device(f'cuda:{i}')
             for i in range(torch.cuda.device_count())]
    return devices if devices else [torch.device('cpu')]

# 张量
X = torch.ones(2, 3, device=try_gpu(0)) # GPU0 上创建张量
Y = torch.ones(2, 3, device=try_gpu(1)) # GPU1 上创建张量
# 如果要计算 X + Y，我们需要决定在哪里存储结果，不能简单的使用 X + Y
Z = X.cuda(1)
print(X + Y) # 异常
print(Z + Y) # 正常

# 模型
net = nn.Sequential(nn.Linear(3, 1))
net = net.to(device=try_gpu())

1. 拷贝操作要格外小心。根据经验，多个小操作比一个大操作糟糕得多，一次执行几个操作比代码中散布的许多单个操作要好得多。
2. 当打印张量或将张量转换为NumPy格式时， 如果数据不在CPU内存中，框架会首先将其复制到内存中， 这会导致额外的传输开销。