深度学习计算

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

# 概念补充：
# 1) 层（layer）：神经网络中的基本计算单元，例如 Linear、ReLU。
#    每一层接收输入并产生输出，完成一次特定变换。
# 2) 块（block）：由一个或多个“层”按一定顺序组合成的更大功能模块。
#    例如可以把“Linear + ReLU”看成一个简单块；多个块再拼成完整模型。
# 3) 在 PyTorch 中，nn.Sequential 常用于把若干层/块按前向顺序串起来。

# 使用 nn.Sequential 按顺序堆叠网络层：
# 1) 输入层到隐藏层：20 -> 256
# 2) 激活函数：ReLU
# 3) 隐藏层到输出层：256 -> 10
# 这里每个 nn.Linear 或 nn.ReLU 都是“层”；
# 这 3 层组合在一起可以看作一个简单的前馈“块”。
net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))

# 构造一批随机输入数据：batch_size=2，每个样本有 20 个特征
X = torch.rand(size=(2, 20))

# 前向传播：将输入 X 送入网络，得到预测输出 Y
# 数据会按顺序依次流经这个块中的每一层。
Y = net(X)

# 打印输出张量（形状为 2x10，对应 2 个样本各自的 10 维输出）
print(Y)

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

class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        # args 里传进来的是一堆“层”（比如 Linear、ReLU 等）
        # 我们把这些层一个个取出来，按顺序保存起来
        for idx, module in enumerate(args):
            # module 是一个层（nn.Module 的子类实例）
            # self._modules 是 PyTorch 内部用来“注册子模块”的地方（类似一个字典）
            # 只有放到这里，PyTorch 才能自动管理参数、支持GPU、保存模型等
            self._modules[str(idx)] = module

    def forward(self, X):
        # 按照添加的顺序，把输入数据 X 依次传给每一层
        # 就像流水线一样：上一层输出 → 下一层输入
        for block in self._modules.values():
            X = block(X)  # 等价于：X = block.forward(X)
        return X  # 最终输出
    
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
Y = net(X)
print(Y)

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()

        # ===============================
        # 固定权重（不会参与训练）
        # ===============================
        # torch.rand((20, 20))：生成一个 20x20 的随机矩阵
        # requires_grad=False：表示这个张量不参与反向传播（不会被优化器更新）
        # 👉 作用：
        #   - 相当于一个“常量权重”
        #   - 可以理解为：固定的变换矩阵 / 规则矩阵 / 查表
        # 👉 注意：
        #   - 不会出现在 model.parameters() 中
        #   - optimizer 也不会更新它
        self.rand_weight = torch.rand((20, 20), requires_grad=False)

        # ===============================
        # 可训练的全连接层
        # ===============================
        # nn.Linear(20, 20)：
        #   输入维度 20 → 输出维度 20
        # 👉 内部包含：
        #   - weight（20x20）
        #   - bias（20）
        # 👉 这些参数是可训练的（requires_grad=True）
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        # ===============================
        # Step 1：第一次线性变换
        # ===============================
        # X shape: (batch_size, 20)
        # 输出: (batch_size, 20)
        # 👉 相当于：
        #   X = X @ W + b
        X = self.linear(X)

        # ===============================
        # Step 2：自定义计算（非标准层）
        # ===============================
        # torch.mm(X, self.rand_weight)：
        #   矩阵乘法（batch_size,20）×（20,20）→（batch_size,20）
        #
        # +1：
        #   给每个元素加常数偏置
        #
        # F.relu(...)：
        #   ReLU激活函数（负数变0）
        #
        # 👉 注意：
        #   - 这里没有使用 nn.Linear
        #   - 完全手写计算过程（更底层）
        # 👉 本质：
        #   X = ReLU(X @ 固定矩阵 + 常数)
        X = F.relu(torch.mm(X, self.rand_weight) + 1)

        # ===============================
        # Step 3：参数共享（重点）
        # ===============================
        # 再次使用同一个 linear 层
        #
        # 👉 说明：
        #   - 这里不是新的一层
        #   - 而是复用同一组参数（weight 和 bias）
        #
        # 👉 等价于：
        #   X = W(WX + b) + b
        #
        # 👉 应用场景：
        #   - RNN（循环使用同一权重）
        #   - 模型压缩（减少参数量）
        X = self.linear(X)

        # ===============================
        # Step 4：动态控制流（重点）
        # ===============================
        # X.abs().sum()：
        #   所有元素取绝对值再求和 → 一个标量
        #
        # while 循环：
        #   如果总和 > 1，就不断缩小
        #
        # 👉 作用：
        #   防止数值过大（类似归一化）
        #
        # 👉 关键点：
        #   - 这是“运行时逻辑”
        #   - 每次 forward 执行时动态决定循环次数
        #
        # 👉 为什么 PyTorch 可以？
        #   因为 forward 本质是 Python 代码（动态图）
        while X.abs().sum() > 1:
            X /= 2

        # ===============================
        # Step 5：输出标量
        # ===============================
        # 将所有元素求和，返回一个标量
        #
        # 👉 说明：
        #   - 最终输出不是向量，而是一个数
        #   - 常用于 loss-like 结构 或测试梯度
        return X.sum()

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

print(net[2].state_dict())  # 打印输出层(第二层)的参数字典

# 访问输出层的偏置参数（bias），它是一个 nn.Parameter 对象，包含了参数值和梯度信息
print(type(net[2].bias))
# 打印 bias 参数的值（一个张量），以及它的数据部分（不包含梯度信息）
print(net[2].bias)
# 直接访问 bias 参数的值（一个张量），这是我们在训练过程中需要更新的参数
print(net[2].bias.data)

print(net[2].bias.grad)  # 打印 bias 参数的梯度信息，初始时为 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('\n模型所有参数详细信息:')
for name, param in net.named_parameters():
	print(f'参数名: {name}')
	print(f'参数形状: {tuple(param.shape)}')
	print(f'是否需要梯度: {param.requires_grad}')
	print(f'参数值:\n{param.data}')
	print('-' * 60)

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)

print(rgnet[0][1][0].bias.data)  # 访问第一个 block 中第二层的 bias 参数值

# 参数初始化：默认情况下，nn.Linear 的权重参数是根据某种分布随机初始化的。我们可以自定义初始化方法来改变这些参数的初始值。
def init_normal(m):
    if type(m) == nn.Linear:
        # 对于 nn.Linear 层，我们使用正态分布来初始化权重参数，均值为 0，标准差为 0.01
        nn.init.normal_(m.weight, mean=0, std=0.01)
        # 将偏置参数初始化为 0
        nn.init.zeros_(m.bias)
# 这里我们使用 net.apply() 方法来递归地将 init_normal 函数应用到 net 中的每一个子模块（层）。
# 这样，net 中所有的 nn.Linear 层的权重和偏置都会按照我们定义的方式进行初始化。
net.apply(init_normal)
print(net[0].weight.data[0], net[0].bias.data[0])

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

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

# 将 CenteredLayer 嵌入到一个更大的网络中，看看它的效果
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())

# 生成一个随机输入张量，形状为 (4, 8)，表示 4 个样本，每个样本有 8 个特征
X = torch.rand(size=(4, 8))
print('输入 X 的均值:', X.mean().item())  # 打印输入张量的均值，看看它是否接近于 0.5（因为是均匀分布）
Y = net(X)

# 打印输出张量 Y 的均值，看看 CenteredLayer 是否成功地将输出中心化了
print('输出 Y 的均值:', Y.mean().item()) # 输出应该接近于 0，因为 CenteredLayer 的作用就是将输入减去其均值，使输出的均值为 0

class MyLinear(nn.Module):
    def __init__(self, in_units, units):
        super().__init__()
        # 在 MyLinear 的构造函数中，我们定义了两个参数：weight 和 bias。
        # 这两个参数都是 nn.Parameter 对象，这意味着它们是模型的可训练参数，会在训练过程中被优化器更新。
        self.weight = nn.Parameter(torch.randn(in_units, units))
        self.bias = nn.Parameter(torch.randn(units,))

    def forward(self, X):
        # 在 MyLinear 的前向传播函数中，我们使用 torch.matmul 来计算输入 X 与权重矩阵 self.weight 的矩阵乘积，然后加上偏置 self.bias。
        linear = torch.matmul(X, self.weight.data) + self.bias.data
        # 最后，我们使用 ReLU 激活函数对线性变换的结果进行非线性处理，返回激活后的输出。
        return F.relu(linear)

# 现在我们创建一个 MyLinear 层的实例，输入特征数为 5，输出特征数为 3
linner = MyLinear(5, 3)
print("权重矩阵的值:", linner.weight)
print("偏置向量的值:", linner.bias)

# 生成一个随机输入张量，形状为 (2, 5)，表示 2 个样本，每个样本有 5 个特征
X = torch.rand(size=(2, 5))
# 将输入张量 X 送入 MyLinear 层，得到输出张量 Y
print('输入 X 的形状:', X.shape)  # 打印输入张量的形状，应该是 (2, 5)
print("输入 X 的值:", X)
Y = linner(X)
print('输出 Y 的形状:', Y.shape)  # 打印输出张量的形状，应该是 (2, 3)
print("输出 Y 的值:", Y)

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

x = torch.arange(4.0)
print(x)
torch.save(x, 'x-file')  # 将张量 x 保存到文件 'x-file' 中

x2 = torch.load('x-file')  # 从文件 'x-file' 中加载张量，赋值给 x2
print(x2)

y = torch.zeros(4)
torch.save([x, y], 'x-file')  # 将张量列表 [x, y] 保存到文件 'x-y-file' 中
x2, y2 = torch.load('x-file')  # 从文件 'x-y-file' 中加载张量列表，分别赋值给 x2 和 y2
print(x2, y2)

mydict = {'x': x, 'y': y}
torch.save(mydict, 'mydict-file')  # 将字典 mydict 保存到文件 'mydict-file' 中
mydict2 = torch.load('mydict-file')
print(mydict2)

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(20, 256)
        self.out = nn.Linear(256, 10)

    def forward(self, X):
        # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
        return self.out(F.relu(self.hidden(X)))

net = MLP()
X = torch.rand(size=(2, 20))
Y = net(X)
print("输出 Y 的值:", Y)
torch.save(net.state_dict(), 'mlp.params')  # 将模型 net 的参数字典（state_dict）保存到文件 'mlp.params' 中
clone = MLP()  # 创建一个新的 MLP 实例
clone.load_state_dict(torch.load('mlp.params'))  # 从文件 'mlp.params` 中加载参数到 clone 模型中
clone.eval()  # 将 clone 模型设置为评估模式（如果模型中有 dropout 或 batchnorm 层，这一步很重要）
Y_clone = clone(X)  # 使用 clone 模型对输入 X 进行前向传播，得到输出 Y_clone
print("克隆模型的输出 Y_clone 的值:", Y_clone)
print(Y_clone == Y)  # 打印比较 clone 模型的输出 Y_clone 与原模型的输出 Y 是否相等，应该是 True，因为它们使用了相同的参数

import torch
from torch import nn

torch.device('cpu')  # 返回当前可用的设备（CPU 或 GPU），如果没有 GPU 可用，则返回 CPU
torch.device('cuda')  # 返回当前可用的设备（CPU 或 GPU），如果有多个 GPU，默认使用第一个 GPU（cuda:0）
torch.device('cuda:0')  # 返回当前可用的设备（CPU 或 GPU），指定使用第一个 GPU（cuda:0）
torch.device('cuda:1')  # 返回当前可用的设备（CPU 或 GPU），指定使用第二个 GPU（cuda:1）

print(torch.cuda.is_available())  # 检查当前系统是否有可用的 GPU，如果有则返回 True，否则返回 False
print(torch.cuda.device_count())  # 返回当前系统中可用的 GPU 数量

def try_gpu(i=0):
    if torch.cuda.device_count() >= i + 1:  # 检查是否有足够的 GPU 可用
        return torch.device(f'cuda:{i}')  # 返回指定 GPU 的设备对象
    return torch.device('cpu')  # 如果没有足够的 GPU 可用，则返回 CPU 设备对象

def try_all_gpus():
    # 创建一个包含所有可用 GPU 设备对象的列表
    devices = [torch.device(f'cuda:{i}') for i in range(torch.cuda.device_count())]
    # 如果没有 GPU 可用，则返回包含 CPU 设备对象的列表
    return devices if devices else [torch.device('cpu')]

print(try_gpu())  # 尝试获取第一个 GPU 设备，如果没有则返回 CPU 设备
print(try_all_gpus())  # 获取所有可用 GPU 设备的列表，如果没有则返回包含 CPU 设备的列表

x = torch.tensor([1.0, 2.0, 3.0])  # 创建一个包含三个元素的张量，数据类型为 float
print(x.device)  # 返回张量 x 所在的设备，默认情况下是 CPU

# 将张量 x 移动到 GPU 设备上（如果有可用的 GPU），否则保持在 CPU 上
X = torch.rand(size=(2, 3), device=try_gpu())
print(X.device)
Y = torch.rand(size=(2, 3), device=try_gpu(1))
print(Y.device)

Z = x.cuda(0)  # 将张量 x 移动到默认 GPU 设备上（如果有可用的 GPU），否则保持在 CPU 上
print(Z.device)