动手学深度学习——深度学习计算

1.层和块

块（block）可以描述单个层、由多个层组成的组件或整个模型本身。 使用块进行抽象的一个好处是可以将一些块组合成更大的组件， 这一过程通常是递归的。

从编程的角度来看，块由类（class）表示。 它的任何子类都必须定义一个将其输入转换为输出的前向传播函数， 并且必须存储任何必需的参数。 注意，有些块不需要任何参数。 最后，为了计算梯度，块必须具有反向传播函数。 

1.1.自定义块

每个块需要具有的功能：

• 将输入数据作为其前向传播函数的参数。

• 通过前向传播函数来生成输出。请注意，输出的形状可能与输入的形状不同。

• 计算其输出关于输入的梯度，可通过其反向传播函数进行访问。通常这是自动发生的。

• 存储和访问前向传播计算所需的参数。

• 根据需要初始化模型参数。

下列代码编写了一个块，包含一个多层感知机，其具有256个隐藏单元的隐藏层和一个10维输出层

class MLP(nn.Module):
    # 用模型参数声明层。这里，我们声明两个全连接的层
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
        super().__init__()   ##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()
net(X)

tensor([[-0.0419,  0.2186,  0.0312, -0.2167, -0.1177, -0.1725,  0.0376, -0.0993,
         -0.2211, -0.1211],
        [ 0.0885,  0.1977,  0.0043, -0.0847, -0.0167, -0.0598,  0.0552,  0.0811,
         -0.2774, -0.0877]], grad_fn=<AddmmBackward0>)

1.2.顺序块

为了构建我们自己的简化的MySequential， 我们只需要定义两个关键函数：

1. 一种将块逐个追加到列表中的函数；

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

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

class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        # enumerate枚举，返回的是元素以及对应的索引
        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


'''
_modules的主要优点是： 在模块的参数初始化过程中， 系统知道在_modules字典中查找需要初始化参数的子块。
'''

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

tensor([[-0.0117,  0.3210, -0.0771,  0.0658, -0.0453,  0.0855, -0.0872, -0.0926,
          0.0334, -0.1175],
        [-0.0229,  0.3216, -0.0257, -0.0009, -0.1657,  0.1508, -0.2042, -0.0137,
          0.0619, -0.1892]], grad_fn=<AddmmBackward0>)

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

并不是所有的架构都是简单的顺序架构。 当需要更强的灵活性时，我们需要定义自己的块。

例如，我们可能希望在前向传播函数中执行Python的控制流。 此外，我们可能希望执行任意的数学运算， 而不是简单地依赖预定义的神经网络层。

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)
        # 控制流
        # L1范数
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()

net = FixedHiddenMLP()
net(X)

tensor(-0.3308, grad_fn=<SumBackward0>)

注意，在返回输出之前，模型做了一些不寻常的事情： 它运行了一个while循环，在L1范数大于1的条件下， 将输出向量除以2，直到它满足条件为止。 最后，模型返回了X中所有项的和。

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

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.0676, grad_fn=<SumBackward0>)

1.4. 小结

• 一个块可以由许多层组成；一个块可以由许多块组成。

• 块负责大量的内部处理，包括参数初始化和反向传播。

2.参数管理

本节内容：

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

2.1. 参数访问

 当通过Sequential类定义模型时， 我们可以通过索引来访问模型的任意层。 

print(net[2].state_dict())

输出是一个字典形式，例如

OrderedDict([('weight', tensor([[ 0.2165, -0.0081,  0.3412, -0.2243, -0.1100, -0.0827, -0.2668, -0.1970]])), ('bias', tensor([-0.3073]))])

2.1.1. 目标参数

从第二个全连接层（即第三个神经网络层）提取偏置。

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

提取后返回的是一个参数类实例，并进一步访问该参数的值。

<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([0.1139], requires_grad=True)
tensor([0.1139])

2.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()])

('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))

2.1.3. 从嵌套块收集参数

 我们首先定义一个生成块的函数（可以说是“块工厂”），然后将这些块组合到更大的块中。

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)

设计了网络后，我们看看它是如何工作的。

print(rgnet)

Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)

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

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

2.2. 参数初始化

默认情况下，PyTorch会根据一个范围均匀地初始化权重和偏置矩阵， 这个范围是根据输入和输出维度计算出的。 PyTorch的nn.init模块提供了多种预置初始化方法。

2.2.1. 内置初始化

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

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]

(tensor([-0.0015, -0.0033, -0.0016,  0.0124]), tensor(0.))

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

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]

(tensor([1., 1., 1., 1.]), tensor(0.))

使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42。

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

net[0].apply(init_xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)

tensor([-0.0369,  0.1094, -0.1875, -0.4694])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

2.2.2. 自定义初始化

当深度学习框架没有提供我们需要的初始化方法，我们也可以自己定义。

2.3. 参数绑定

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

# 我们需要给共享层一个名称，以便可以引用它的参数
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])

这个例子表明第三个和第五个神经网络层的参数是绑定的。 它们不仅值相等，而且由相同的张量表示。

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

3.自定义层

3.1. 不带参数的层

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


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


#作为额外的健全性检查，我们可以在向该网络发送随机数据后，检查均值是否为0。
Y = net(torch.rand(4, 8))
Y.mean()

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

实例化MyLinear类并访问其模型参数。

linear = MyLinear(5, 3)
linear.weight

Parameter containing:
tensor([[-3.1779,  0.4942, -1.0605],
        [-1.7906,  0.8387,  0.5656],
        [-0.5630, -2.2477,  0.6385],
        [ 1.4229, -2.1085,  2.3715],
        [-0.5599,  0.5253,  0.7320]], requires_grad=True)

可以使用自定义层直接执行前向传播计算。我们还可以使用自定义层构建模型，就像使用内置的全连接层一样使用自定义层。

linear(torch.rand(2, 5))

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

4.3. 小结

• 我们可以通过基本层类设计我们所需要的自定义层。

• 层可以有局部参数，这些参数可以通过内置函数创建。

• 在自定义层定义完成后，我们就可以在任意环境和网络架构中调用该自定义层。

4.读写文件

4.1. 加载和保存张量

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

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

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

我们现在可以将存储在文件中的数据读回内存。

x2 = torch.load('x-file')
x2

tensor([0, 1, 2, 3])

我们可以写入或读取从字符串映射到张量的字典。 

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

{'x': tensor([0, 1, 2, 3]), 'y': tensor([0., 0., 0., 0.])}

4.2. 加载和保存模型参数

深度学习框架提供了内置函数来保存和加载整个网络。 需要注意的一个重要细节是，这将保存模型的参数而不是保存整个模型。

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

class MLP(nn.Module):
    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()
X = torch.randn(size=(2, 20))
Y = net(X)

torch.save(net.state_dict(), 'mlp.params')

为了恢复模型，我们实例化了原始多层感知机模型的一个备份。

model.load_state_dict存储了网络结构的名字和对应的参数

clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()

MLP(
  (hidden): Linear(in_features=20, out_features=256, bias=True)
  (output): Linear(in_features=256, out_features=10, bias=True)
)

由于两个实例具有相同的模型参数，在输入相同的X时， 两个实例的计算结果应该相同。 

Y_clone = clone(X)
Y_clone == Y

tensor([[True, True, True, True, True, True, True, True, True, True],
        [True, True, True, True, True, True, True, True, True, True]])

4.3. 小结

• save和load函数可用于张量对象的文件读写。

• 我们可以通过参数字典保存和加载网络的全部参数。

• 保存架构必须在代码中完成，而不是在参数中完成。