九深度学习模型参数管理模型初始化读写（3.6日学习笔记1）

Posted 2023-03-09 小常在学习

参数管理

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

• 访问参数，用于调试、诊断和可视化；

• 参数初始化；

• 在不同模型组件间共享参数。

[参数访问]

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

print(net[2].state_dict())

OrderedDict([('weight', tensor([[ 0.3016, -0.1901, -0.1991, -0.1220, 0.1121, -0.1424, -0.3060, 0.3400]])), ('bias', tensor([-0.0291]))])

可以看到，这个全连接层包含两个参数，分别是该层的权重和偏置。两者都存储为单精度浮点数（float32）。

[目标参数]

下面的代码从第二个全连接层（即第三个神经网络层）提取偏置，

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

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

<class 'torch.nn.parameter.Parameter'>

Parameter containing:

tensor([-0.0291], requires_grad=True)

tensor([-0.0291])

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

net[2].weight.grad == None

True

[一次性访问所有参数]

访问第一个全连接层的参数和访问所有层。

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

这为我们提供了另一种访问网络参数的方式，如下所示。

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

tensor([-0.0291])

[从嵌套块收集参数]

让我们看看，如果我们将多个块相互嵌套，参数命名约定是如何工作的。

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

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)

tensor([[-0.3078],
        [-0.3078]], grad_fn=<AddmmBackward0>)

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

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

参数初始化

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

[内置初始化]

下面的代码将所有权重参数初始化为标准差为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.0128, -0.0141, 0.0062, 0.0028]), 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.3809, 0.5354, -0.4686, -0.2376])

tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

自定义层

我们可以用创造性的方式组合不同的层，从而设计出适用于各种任务的架构。例如，研究人员发明了专门用于处理图像、文本、序列数据和执行动态规划的层。有时我们会遇到或要自己发明一个现在在深度学习框架中还不存在的层。在这些情况下，必须构建自定义层。本节将展示如何构建自定义层。

不带参数的层

首先，我们(构造一个没有任何参数的自定义层)。下面的CenteredLayer类要从其输入中减去均值。

要构建它，我们只需继承基础层类并实现前向传播功能。

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

让我们向该层提供一些数据，验证它是否能按预期工作。

layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))

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

现在，我们可以[将层作为组件合并到更复杂的模型中]。

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

作为额外的健全性检查，我们可以在向该网络发送随机数据后，检查均值是否为0。

由于我们处理的是浮点数，因为存储精度的原因，我们仍然可能会看到一个非常小的非零数。

Y = net(torch.rand(4, 8))
Y.mean()

tensor(-1.3970e-09, grad_fn= )

[带参数的层]

继续定义具有参数的层，这些参数可以通过训练进行调整。我们可以使用内置函数来创建参数，这些函数提供一些基本的管理功能。比如管理访问、初始化、共享、保存和加载模型参数。这样做的好处之一是：我们不需要为每个自定义层编写自定义的序列化程序。下面实现自定义版本的全连接层。

该层需要两个参数，一个用于表示权重，另一个用于表示偏置项。

此外，使用修正线性单元作为激活函数。

该层需要输入参数：in_units和units，分别表示输入数和输出数。

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([[ 1.9094, -0.8244, -1.6846],
        [ 0.6850,  0.8366, -1.3837],
        [ 0.0289,  2.0976,  1.3855],
        [-0.8574, -0.3557, -0.4109],
        [ 2.2963, -1.3008,  1.2173]], requires_grad=True)

我们可以[使用自定义层直接执行前向传播计算]。

linear(torch.rand(2, 5))

tensor([[0.0984, 0.5687, 2.8316],
        [2.2558, 0.0000, 1.8880]])

我们还可以(使用自定义层构建模型)，就像使用内置的全连接层一样使用自定义层。

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

tensor([[7.5465],

tensor([[7.5465],     
        [4.6817]])

小结

• 我们可以通过基本层类设计自定义层。这允许我们定义灵活的新层，其行为与深度学习框架中的任何现有层不同。

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

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

读写文件

(加载和保存张量)

对于单个张量，可以直接调用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])

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

y = torch.zeros(4)
torch.save([x, y],'x-files')
x2, y2 = torch.load('x-files')
(x2, y2)

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

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

当我们要读取或写入模型中的所有权重时，这很方便。

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

[加载和保存模型参数]

深度学习框架提供了内置函数来保存和加载整个网络。需要注意的是这将保存模型的参数而不是保存整个模型。例如，有一个3层多层感知机，我们需要单独指定架构。因为模型本身可以包含任意代码，所以模型本身难以序列化。因此，为了恢复模型，我们需要用代码生成架构，然后从磁盘加载参数。

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)

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

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

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

这里我们不需要随机初始化模型参数，而是(直接读取文件中存储的参数。)

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

小结

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

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

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