《动手深度学习》5.2. 参数管理&5.4自定义层&5.5读写文件

最新推荐文章于 2024-07-25 17:49:34 发布

abccd女士

最新推荐文章于 2024-07-25 17:49:34 发布

阅读量463

点赞数

分类专栏：动手深度学习文章标签：深度学习人工智能神经网络

本文链接：https://blog.csdn.net/qq_43797820/article/details/127108110

版权

动手深度学习专栏收录该内容

20 篇文章 8 订阅

订阅专栏

5.2. 参数管理&&5.4 自定义层&&5.5读写文件

5.2 参数管理
5.4 自定义层
- - 不带参数的层
  - 带参数的层
5.5读写文件
- - 加载和保存张量
  - 加载和保存模型参数

5.2 参数管理

内容大纲

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

以简单的多层感知机为例：

import torch
from torch import nn

net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)

参数访问

索引某一层&访问参数state_dict()

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

print(net[2].state_dict())

net[2]： 通过索引net[2]来访问最后一层nn.Linear(8,1)

state_dict()： state代表了网络层的参数W和b, 并以dict格式给出。

访问目标参数

eg: 提取bias:net[2].bias.data

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

Parameter 是复合的对象，包含值data、梯度grad和额外信息。
除了值之外，我们还可以访问每个参数的梯度(.grad)。 net[2].weight.grad

一次性访问所有参数

比较下面两行代码：分别是只访问第一个全连接层的参数 vs 访问所有层。

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

由于ReLU层不包含参数，so无输出net[1]对应的输出。

另一种访问网络参数的方式：先获取整个网络的参数，再按字典进行索引：net.state_dict()['2.bias'].data

从嵌套的块中收集参数

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

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)

上述代码生成了由4个block1()相连后再连接一个Linear(4,1)的网络。print看一下：print(rgnet)

因为层是分层嵌套的，所以我们也可以像通过嵌套列表索引一样访问它们。
rgnet[0][1][0].bias.data #访问第一个主要的块中、第二个子块(即block 1)的第一层的偏置项。

参数初始化

深度学习框架提供默认随机初始化，也允许我们创建自定义初始化方法，满足我们通过其他规则实现初始化权重。

内置初始化

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

将所有权重参数初始化为标准差为0.01的高斯随机变量，且将偏置参数设置为0。
下面用到的nn.init.normal_(), nn.init.zeros_()都是init中内置的方法

def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, mean=0, std=0.01)#下划线表示替换函数，将所得值直接替换掉原m.weight
        nn.init.zeros_(m.bias)
net.apply(init_normal)#apply表示 对net中所有层依次init_normal操作
net[0].weight.data[0], net[0].bias.data[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]

还可以对某些块应用不同的初始化方法——net[i].apply(不同方法)

例如，下面我们使用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)

自定义初始化

自定义init函数：

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 #>=优先, 绝对值>=5则与原data相乘后赋值，否则为0

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

甚至，直接给参数进行赋值

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

参数绑定/参数共享

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

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

这个例子表明第三个和第五个神经网络层的参数是绑定的。它们不仅值相等，而且由相同的张量表示。
因此，如果我们改变其中一个参数，另一个参数也会改变。
**梯度：**由于模型参数包含梯度，因此在反向传播期间第二个隐藏层（即第三个神经网络层）和第三个隐藏层（即第五个神经网络层）的梯度会加在一起。

共享参数的好处

通常可以节省内存，并在以下方面具有特定的好处：

对于图像识别中的CNN，共享参数使网络能够在图像中的任何地方而不是仅在某个区域中查找给定的功能。
对于RNN，它在序列的各个时间步之间共享参数，因此可以很好地推广到不同序列长度的示例。
对于自动编码器，编码器和解码器共享参数。在具有线性激活的单层自动编码器中，共享权重会在权重矩阵的不同隐藏层之间强制正交。

5.4 自定义层

不带参数的层

首先，构造一个没有任何参数的自定义层，下面的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]))

将层作为组件合并到更复杂的模型中。

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

带参数的层

用内置函数来创建参数，这些函数提供一些基本的管理功能：比如管理访问、初始化、共享、保存和加载模型参数。
接下来实现自定义版本的全连接层：需要两个参数w和b，ReLU为激活函数。需要输入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

执行前向传播计算，输入为2x5随机矩阵

linear(torch.rand(2, 5))

使用自定义层构建模型

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

5.5读写文件

当运行一个耗时较长的训练过程时，最佳的做法是定期保存中间结果

加载和保存张量

load和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

存储张量列表：

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

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

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

加载和保存模型参数

深度学习框架提供了内置函数来保存和加载整个网络。
这将保存模型的参数而不是保存整个模型。因此，为了恢复模型，我们需要用代码生成架构，然后从磁盘加载参数。

让我们从熟悉的多层感知机开始尝试一下。

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

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

Y_clone = clone(X)
Y_clone == Y

abccd女士

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
《动手深度学习》5.2. 参数管理&5.4自定义层&5.5读写文件

参数访问、初始化、参数共享；自定义层；存储模型中间结果
复制链接

扫一扫

专栏目录