深度学习计算（深度学习-李沐-学习笔记）

于 2025-07-27 16:18:44 发布
阅读量817 收藏 16
点赞数 21
CC 4.0 BY-SA版权
分类专栏： 深度学习 文章标签： 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyeolhada/article/details/149686168

层和块

单一输出的线性模型：单个神经网络 （1）接受一些输入； （2）生成相应的标量输出； （3）具有一组相关 参数（parameters），更新这些参数可以优化某目标函数。

多个输出的网络：像单个神经元一样，层（1）接受一组输入， （2）生成相应的输出， （3）由一组可调整参数描述。 当我们使用softmax回归时，一个单层本身就是模型。 

多层感知机：整个模型及其组成层都是这种架构。 整个模型接受原始输入（特征），生成输出（预测）， 并包含一些参数（所有组成层的参数集合）。  同样，每个单独的层接收输入（由前一层提供）， 生成输出（到下一层的输入），并且具有一组可调参数， 这些参数根据从下一层反向传播的信号进行更新。

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

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

下面的代码生成一个网络，其中包含一个具有256个单元和ReLU激活函数的全连接隐藏层， 然后是一个具有10个隐藏单元且不带激活函数的全连接输出层。

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

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

# 定义网络
net = nn.Sequential(
    nn.Linear(20, 256),  # 全连接层，输入维度20，输出维度256
    nn.ReLU(),           # ReLU激活函数
    nn.Linear(256, 10)   # 输出层，输出维度10（不带激活函数）
)

# 创建一个形状为(2, 20)的输入张量
X = torch.rand(2, 20)

# 打印输出
print(net(X))

自定义块

实现我们自定义块之前，我们简要总结一下每个块必须提供的基本功能。

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

  2. 通过前向传播函数来生成输出。请注意，输出的形状可能与输入的形状不同。例如，我们上面模型中的第一个全连接的层接收一个20维的输入，但是返回一个维度为256的输出。

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

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

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

# 自定义块：一个多层感知机，其具有256个隐藏单元的隐藏层和一个10维输出层
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()
print(net(X))

顺序块

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

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

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

# 顺序块
# __init__函数将每个模块逐个添加到有序字典_modules中
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))
print(net(X))

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

有时我们可能希望合并既不是上一层的结果也不是可更新参数的项， 我们称之为常数参数（constant parameter）。

# 在前向传播函数中执行代码
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()
# print(net(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)

小结

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

  • 块可以包含代码。

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

  • 层和块的顺序连接由Sequential块处理。

参数管理

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

# 目标参数
# 从第二个全连接层（即第三个神经网络层）提取偏置， 
# 提取后返回的是一个参数类实例，并进一步访问该参数的值
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)

# 还可以访问每个参数的梯度
print(net[2].weight.grad == None)

# 一次性访问所有参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])

# 提供了另一种访问网络参数的方式
print(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)

# 访问第一个主要的块中、第二个子块的第一层的偏置项
rgnet[0][1][0].bias.data

# 参数初始化
# 默认情况下，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]

# 还可以将所有参数初始化为给定的常数，比如初始化为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初始化方法初始化第一个神经网络层， 
# 然后将第三个神经网络层初始化为常量值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)

# 自定义初始化
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[: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])

延后初始化

  • 我们定义了网络架构，但没有指定输入维度。

  • 我们添加层时没有指定前一层的输出维度。

  • 我们在初始化参数时，甚至没有足够的信息来确定模型应该包含多少参数。

框架的延后初始化（defers initialization）， 即直到数据第一次通过模型传递时，框架才会动态地推断出每个层的大小。

在以后，当使用卷积神经网络时， 由于输入维度（即图像的分辨率）将影响每个后续层的维数， 有了该技术将更加方便。 现在我们在编写代码时无须知道维度是什么就可以设置参数， 这种能力可以大大简化定义和修改模型的任务。

自定义层

深度学习成功背后的一个因素是神经网络的灵活性： 我们可以用创造性的方式组合不同的层，从而设计出适用于各种任务的架构。 

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

# 不带参数的层:
# CenteredLayer类要从其输入中减去均值。 
# 要构建它，我们只需继承基础层类并实现前向传播功能
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())

# 向该网络发送随机数据后，检查均值是否为0
Y = net(torch.rand(4, 8))
Y.mean()

# 带参数的层:
# 自定义版本的全连接层
# 该层需要两个参数，一个用于表示权重，另一个用于表示偏置项
# 使用修正线性单元作为激活函数
# 该层需要输入参数：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

# 可以使用自定义层直接执行前向传播计算
linear(torch.rand(2, 5))

# 还可以使用自定义层构建模型
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

# (1)加载和保存张量

# 对于单个张量直接调用load和save函数读写
x = torch.arange(4)
torch.save(x, 'x-file') # save要求将要保存的变量作为输入

# 将存储在文件中的数据读回内存
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

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

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

小结

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

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

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

GPU

下载NVIDIA驱动和CUDA 并按照提示设置适当的路径。 当这些准备工作完成，就可以使用nvidia-smi命令来查看显卡信息。

计算设备

在PyTorch中，CPU和GPU可以用torch.device('cpu') 和torch.device('cuda')表示。 应该注意的是，cpu设备意味着所有物理CPU和内存， 这意味着PyTorch的计算将尝试使用所有CPU核心。 然而，gpu设备只代表一个卡和相应的显存。 如果有多个GPU，我们使用torch.device(f'cuda:{i}') 来表示第块GPU（i从0开始）。 另外，cuda:0和cuda是等价的。

import torch
from torch import nn

torch.device('cpu'), torch.device('cuda'), torch.device('cuda:1')

# 可以查询可用gpu的数量
torch.cuda.device_count()

# 定义了两个方便的函数， 
# 这两个函数允许我们在不存在所需所有GPU的情况下运行代码
def try_gpu(i=0):  #@save
    """如果存在，则返回gpu(i)，否则返回cpu()"""
    if torch.cuda.device_count() >= i + 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')

def try_all_gpus():  #@save
    """返回所有可用的GPU，如果没有GPU，则返回[cpu(),]"""
    devices = [torch.device(f'cuda:{i}')
             for i in range(torch.cuda.device_count())]
    return devices if devices else [torch.device('cpu')]

try_gpu(), try_gpu(10), try_all_gpus()

# 张量与GPU
# 可以查询张量所在的设备。 
# 默认情况下，张量是在CPU上创建的。
x = torch.tensor([1, 2, 3])
x.device
# 无论何时我们要对多个项进行操作， 它们都必须在同一个设备上

# 存储在GPU上
X = torch.ones(2, 3, device=try_gpu())
X

# 在第二个GPU上创建一个随机张量
Y = torch.rand(2, 3, device=try_gpu(1))
Y

# 复制
Z = X.cuda(1)
print(X)
print(Z)

# 数据在同一个GPU上（Z和Y都在），我们可以将它们相加
Y + Z

# 假设变量Z已经存在于第二个GPU上。 如果我们还是调用Z.cuda(1)会发生什么？
#  它将返回Z，而不会复制并分配新内存。
Z.cuda(1) is Z # true

# 神经网络与GPU
# 神经网络模型可以指定设备
# 下面将模型参数放在GPU上
net = nn.Sequential(nn.Linear(3, 1))
net = net.to(device=try_gpu())

# 当输入为GPU上的张量时，模型将在同一GPU上计算结果
net(X)

# 确认模型参数存储在同一个GPU上
net[0].weight.data.device # device(type='cuda', index=0)

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值