深度学习计算：层和块（笔记）

模型构造

回顾多层感知机，简单实现

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 相当于定义了一个特殊的Modle。任意的层和神经网络都应该是Modle的一个子类。

自定义块实现相同的功能
在实现我们⾃定义块之前，我们简要总结⼀下每个块必须提供的基本功能：

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

class MLP(nn.Module):         #要来继承modle里的函数

    # ⽤模型参数声明层。这⾥，我们声明两个全连接的层
    def __init__(self):        
        super().__init__()    #调用model的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)

顺序块的实现
Sequential的设计是为了把其他模块串起来。为了构建我们⾃⼰的简化的MySequential，我们只需要定义两个关键函数：

• ⼀种将块逐个追加到列表中的函数。
• ⼀种前向传播函数，⽤于将输⼊按追加块的顺序传递给块组成的“链条”。

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

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

Sequential类使模型构造变得简单，允许我们组合新的架构，而不必定义⾃⼰的类。然而，并不是所有的架构都是简单的顺序架构。当需要更强的灵活性时，我们需要定义⾃⼰的块。例如，我们可能希望在前向传播函数中执⾏ Python的控制流。此外，我们可能希望执⾏任意的数学运算，而不是简单地依赖预定义的神经⽹络层。

到⽬前为⽌，我们⽹络中的所有操作都对⽹络的激活值及⽹络的参数起作⽤。然而，有时我们可能希望合并 既不是上⼀层的结果也不是可更新参数的项，我们称之为常数参数 。例如，我们需要 ⼀个计算函数 的层，其中 x 是输⼊， w 是参数， c是某个在优化过程中没有更新的指定常量。因此我们实现了⼀个 FixedHiddenMLP 类，如下所⽰：

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

net = FixedHiddenMLP()
net(X)

在这个 FixedHiddenMLP模型中，我们实现了⼀个隐藏层，其权重（self.rand_weight）在实例化时被 随机初始化，之后为常量。这个权重不是⼀个模型参数，因此它永远不会被反向传播更新。然后，神经⽹络 将这个固定层的输出通过⼀个全连接层。注意，在返回输出之前，模型做了⼀些不寻常的事情：它运⾏了⼀个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)

参数管理

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

首先先关注只有单个隐藏层的多层感知机：

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)

#参数访问
print(net[2].state_dict())    #net[2],表示是访问nn.Linear(8, 1)的参数字典
#OrderedDict([('weight', tensor([[-0.2358, -0.2256, -0.1930, -0.0475, -0.0732, -0.3483, ,→ 0.0520, 0.1466]])), ('bias', tensor([-0.0579]))])

print(type(net[2].bias))    #
print(net[2].bias)          #tensor([-0.0579], requires_grad=True)
print(net[2].bias.data)     #tensor([-0.0579])

net[2].weight.grad          #访问梯度

#一次性访问所有参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])    #访问第一层所有参数
#('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
print(*[(name, param.shape) for name, param in net.named_parameters()])       #访问所有层所有参数
#('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    #访问指定层的偏置

从嵌套块收集参数

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)    #结果在198页

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

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

内置初始化

⾸先调⽤内置的初始化器。下⾯的代码将所有权重参数初始化为标准差为 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)     #这里的apply意思是对于net中的所有层遍历一遍括号内的函数，嵌套的model也会遍历
net[0].weight.data[0], net[0].bias.data[0]
#(tensor([ 0.0091, 0.0023, -0.0125, 0.0040]), 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.))

可以对不同的块采用不同的参数初始化方法：

def 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(xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])    #tensor([ 0.5587, 0.2209, -0.0744, 0.3801])
print(net[2].weight.data)       #tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

自定义初始化

有时，深度学习框架没有提供我们需要的初始化⽅法。在下⾯的例⼦中，我们使⽤以下的分布为任意权重参 数 w 定义初始化⽅法：

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的权重，不是就设置为0

net.apply(my_init)
net[0].weight[:2]    
#tensor([[-8.4986, 0.0000, -0.0000, -0.0000],[ 6.7884, 0.0000, -9.8570, -6.8247]], grad_fn=)

或者可以直接来暴力的操作：

net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]    #tensor([42., 1., 1., 1.])

参数绑定

有时我们希望在多个层间共享参数：我们可以定义⼀个稠密层，然后使⽤它的参数来设置另⼀个层的参数。（意思就是要两个参数一直都一致的层）

# 我们需要给共享层⼀个名称，以便可以引⽤它的参数
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])    #tensor([True, True, True, True, True, True, True, True])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同⼀个对象，⽽不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])    #tensor([True, True, True, True, True, True, True, True])

自定义层 

构造⼀个没有任何参数的⾃定义层。下⾯的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())

带参数的层

上我们知道了如何定义简单的层，下⾯我们继续定义具有参数的层，这些参数可以通过训练进⾏调整。我们可以使⽤内置函数来创建参数，这些函数提供⼀些基本的管理功能。⽐如管理访问、初始化、共享、保存和加载模型参数。这样做的好处之⼀是：我们不需要为每个⾃定义层编写⾃定义的序列化程序。

class MyLinear(nn.Module):
    def __init__(self, in_units, units):    #需要输入维度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)

linear = MyLinear(5, 3)
linear(torch.rand(2, 5))

#同样可以把自定义的层放入model
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))

读写文件

加载和保存张量

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

#由于两个实例具有相同的模型参数，在输⼊相同的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]])

---

李沐老师课程：跟李沐学AI的个人空间_哔哩哔哩_Bilibili

课程用到的书《动手学深度学习》：《动手学深度学习》：面向中文读者、能运行、可讨论