PyTorch 神经网络基础

PyTorch 神经网络基础0. 环境介绍环境使用 Kaggle 里免费建立的 Notebook教程使用李沐老师的动手学深度学习网站和视频讲解小技巧：当遇到函数看不懂的时候可以按 Shift+Tab 查看函数详解。1. 层和块1.0 概述多层感知机模型接受原始输入（特征），生成输出（预测），并包含一些参数（所有组成层的参数集合）。同样，每个单独的层接收输入（由前一层提供），生成输出（到

哇咔咔负负得正

777人浏览 · 2022-04-19 20:29:52

哇咔咔负负得正 · 2022-04-19 20:29:52 发布

PyTorch 神经网络基础

0. 环境介绍

环境使用 Kaggle 里免费建立的 Notebook

教程使用李沐老师的动手学深度学习网站和视频讲解

小技巧：当遇到函数看不懂的时候可以按 Shift+Tab 查看函数详解。

1. 层和块

1.0 概述

多层感知机模型接受原始输入（特征），生成输出（预测），并包含一些参数（所有组成层的参数集合）。同样，每个单独的层接收输入（由前一层提供），生成输出（到下一层的输入），并且具有一组可调参数，这些参数根据从下一层反向传播的信号进行更新。
块（block）可以描述单个层、由多个层组成的组件或整个模型本身。从编程的角度来看，块由类（class）表示。它的任何子类都必须定义一个将其输入转换为输出的前向传播函数，并且必须存储任何必需的参数。

多个层构成一个块，多个块组成一个模型。
在这里插入图片描述

import torch
from torch import nn
# functional 定义了一些函数
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 构造模型，nn.Sequential 定义了一种特殊的 Module，即在PyTorch 中表示一个块的类，它维护了一个由 Module 组成的有序列表。层的执行顺序是作为参数传递的。两个全连接层都是 Linear 类的实例， Linear 是 Module 的子类。

1.1 自定义块

每个块需要实现的功能：

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

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

在这里插入图片描述
重写 forward 函数。

1.2 定义顺序块 `Sequential`

自定义 Sequential 模块需要的功能：

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

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

self._modules 是父类属性，属性类型是 OrderedDict() 有序字典。
当 MySequential 的前向传播函数被调用时，每个添加的块都按照它们被添加的顺序执行。现在可以使用我们的 MySequential 类重新实现多层感知机。

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

在这里插入图片描述

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

Sequential 类使模型构造变得简单，允许我们组合新的架构，而不必定义自己的类。然而，并不是所有的架构都是简单的顺序架构。当需要更强的灵活性时，我们需要定义自己的块。例如，我们可能希望在前向传播函数中执行 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)
        # 控制流
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()

设置 requires_grad=False，意味着这个权重不是一个模型参数，因此它永远不会被反向传播更新。

net = FixedHiddenMLP()
net(X)

在这里插入图片描述

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

在这里插入图片描述

2. 参数管理

2.0 概述

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

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)

在这里插入图片描述

2.1 参数访问

2.1.1 访问特定层的参数

print(net[2].state_dict())

在这里插入图片描述
net[2] 取到的就是第 $2$ （从 $0$ 开始）个层 nn.Linear(8, 1) 的参数 $w$ 和 $b$ 。

2.1.2 目标参数

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

在这里插入图片描述
由于还没有调用反向传播，所以参数的梯度处于初始状态。

net[2].weight.grad == None

在这里插入图片描述

2.1.3 一次性访问所有参数

当我们需要对所有参数执行操作时，逐个访问它们可能会很麻烦。当我们处理更复杂的块（例如，嵌套块）时，情况可能会变得特别复杂，因为我们需要递归整个树来提取每个子块的参数。

访问第 $0$ 个全连接层的参数和访问所有层：

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

在这里插入图片描述

2.1.4 访问特定参数的另一种方法

访问第 $2$ 个层的偏移的数值：

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

在这里插入图片描述

2.1.5 从嵌套块收集参数

将多个块相互嵌套：

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)

在这里插入图片描述
可以像通过嵌套列表索引一样访问它们，访问第 $0$ 个主要的块中、第 $1$ 个子块的第 $0$ 层的偏置项：

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]

在这里插入图片描述
apply 函数的作用是将传入的函数应用到指定的 module 上。

将所有参数初始化为给定的常数，比如初始化为 $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]

在这里插入图片描述
对某些块应用不同的初始化方法。使用 Xavier 初始化方法初始化第 $0$ 个神经网络层，然后将第 $2$ 个神经网络层初始化为常量值 $42$ ：

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])
print(net[2].weight.data)

在这里插入图片描述

2.2.2 自定义初始化

有时，深度学习框架没有提供我们需要的初始化方法。使用以下的分布为任意权重参数 $w$ 定义初始化方法：
$\begin{aligned} w \sim \begin{cases} U(5, 10) & \text{ 可能性 } \frac{1}{4} \\ 0 & \text{ 可能性 } \frac{1}{2} \\ U(-10, -5) & \text{ 可能性 } \frac{1}{4} \end{cases} \end{aligned}$

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

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

在这里插入图片描述
还可以直接设置参数：

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

在这里插入图片描述

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

在这里插入图片描述
第 $2$ 个和第 $4$ 个神经网络层的参数是绑定的。它们不仅值相等，而且由相同的张量表示。因此，如果我们改变其中一个参数，另一个参数也会改变。

Q：那么当参数绑定时，梯度会发生什么情况？
A：由于模型参数包含梯度，因此在反向传播期间第 $2$ 个神经网络层和第 $4$ 个神经网络层的梯度会加在一起。

来自教材的 Q&A：
共享参数通常可以节省内存，并在以下方面具有特定的好处：

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

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

测试一下：

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

在这里插入图片描述
将层作为组件合并到更复杂的模型中：

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

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

在这里插入图片描述
理论上应该是均值为 $0$ ，但是浮点是因为存储精度会有一点误差。

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)

自定义参数需要使用 nn.Parameter 函数。

linear = MyLinear(5, 3)
linear.weight

在这里插入图片描述
使用自定义层直接执行前向传播计算：

linear(torch.rand(2, 5))

在这里插入图片描述

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

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

在这里插入图片描述

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

load 加载数据：

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

在这里插入图片描述

4.2 加载和保存模型参数

深度学习框架提供了内置函数来保存和加载整个网络。需要注意的一个重要细节是，这将保存模型的参数而不是保存整个模型。例如，如果我们有一个 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()

在这里插入图片描述
eval 表示进入测试模式，不会更新权重。
详见：https://blog.csdn.net/qq_38410428/article/details/101102075

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

Y_clone = clone(X)
Y_clone == Y

在这里插入图片描述

5. Q&A

Q：Pytorch 默认权值初始化方式是什么：
A：kaiming 初始化。

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

一文读懂AI大模型核心术语：从参数到Agent的完整指南

2048 AI社区

结合AI大模型的本地知识库搭建方法总结，大模型入门到精通，收藏这篇就足够了！

2048 AI社区

Paint API之—— Xfermode与PorterDuff详解(三)

本文详解Android中PorterDuff的18种混合模式，包括ADD、CLEAR、DARKEN等，通过公式解析Alpha通道和颜色通道的计算方式。每种模式都配有组合逻辑、处理方式和效果示例说明，如ADD模式会使颜色叠加变亮，CLEAR模式会完全透明化等。文中还提供了与WebView、Socket集成的实战场景，帮助开发者系统掌握PorterDuff混合模式的应用。