PyTorch3

自动微分：

自动微分模块torch.autograd负责自动计算张量操作的梯度，具有自动求导功能。自动微分模块是构成神经网络训练的必要模块，可以实现网络权重参数的更新，使得反向传播算法的实现变得简单而高效。

张量：

Torch中一切皆为张量，属性requires_grad决定是否对其进行梯度计算。默认是 False，如需计算梯度则设置为True。

计算图：

torch.autograd通过创建一个动态计算图来跟踪张量的操作，每个张量是计算图中的一个节点，节点之间的操作构成图的边。

反向传播：

使用tensor.backward()方法执行反向传播，从而计算张量的梯度。这个过程会自动计算每个张量对损失函数的梯度。

梯度：

计算得到的梯度通过tensor.grad访问，这些梯度用于优化模型参数，以最小化损失函数。

标量梯度计算：

import torch
def test001():
    # 1. 创建张量：必须为浮点类型
    x = torch.tensor(7.0, requires_grad=True, dtype=torch.float32)
    # 2. 操作张量
    y = x**2 + 2 * x + 7
    # 3. 计算梯度，也就是反向传播
    y.backward()
    # 4. 读取梯度值
    # 结果：tensor(16.)
    print(x.grad)
if __name__ == "__main__":
    test001()

向量梯度计算：

import torch
def test002():
    # 1. 创建张量：必须为浮点类型
    x = torch.tensor([1.0, 2.0, 5.3], requires_grad=True)
    # 2. 操作张量
    y = x**2 + 2 * x + 7
    # 3. 需要变为标量：求和或者求均值都可以
    # z = y.sum()
    z = y.mean()
    # 4. 计算梯度，也就是反向传播
    z.backward()
    # 5. 读取梯度值
    print(x.grad)
if __name__ == "__main__":
    test002()

多标量梯度计算：

import torch
def test003():
    # 1. 创建两个标量
    x1 = torch.tensor(5.0, requires_grad=True, dtype=torch.float64)
    x2 = torch.tensor(3.0, requires_grad=True, dtype=torch.float64)
    # 2. 构建运算公式
    y = x1**2 + 2 * x2 + 7   
    # 3. 计算梯度，也就是反向传播
    y.backward()    
    # 4. 读取梯度值
    print(x1.grad, x2.grad)
if __name__ == "__main__":
    test003()

多向量梯度计算：

import torch
def test004():
    # 1. 创建两个向量
    x1 = torch.tensor([5.0, 6.0, 7.5], requires_grad=True)
    x2 = torch.tensor([3.0, 5.2, 6.4], requires_grad=True)
    # 2. 构建运算公式
    y = x1**2 + 2 * x2 + 7
    # 3. 向量构建
    # z = y.sum()
    z = y.mean()
    # 4. 计算梯度，也就是反向传播
    z.backward()
    # 5. 读取梯度值
    print(x1.grad, x2.grad)
if __name__ == "__main__":
    test004()

控制梯度计算：

梯度计算是有性能开销的，有些时候我们只是简单的运算，并不需要梯度

import torch
def test001():
    x = torch.tensor(10.5, requires_grad=True)
    print(x.requires_grad)  # True
    # 1. 默认y的requires_grad=True
    y = x**2 + 2 * x + 3
    print(y.requires_grad)  # True
    # 2. 如果不需要y计算梯度-with进行上下文管理
    with torch.no_grad():
        y = x**2 + 2 * x + 3
    print(y.requires_grad)  # False
    # 3. 如果不需要y计算梯度-使用装饰器
    @torch.no_grad()
    def y_fn(x):
        return x**2 + 2 * x + 3
    y = y_fn(x)
    print(y.requires_grad)  # False
    # 4. 如果不需要y计算梯度-全局设置，需要谨慎
    torch.set_grad_enabled(False)
    y = x**2 + 2 * x + 3
    print(y.requires_grad)  # False
if __name__ == "__main__":
    test001()

累计梯度：

默认情况下，当我们重复对一个自变量进行梯度计算时，梯度是累加的

import torch
def test002():
    # 1. 创建张量：必须为浮点类型
    x = torch.tensor([1.0, 2.0, 5.3], requires_grad=True)
    # 2. 累计梯度：每次计算都会累计梯度
    for i in range(3):
        y = x**2 + 2 * x + 7
        z = y.mean()
        z.backward()
        print(x.grad)
if __name__ == "__main__":
    test002()

梯度清零：

大多数情况下是不需要梯度累加的,反向传播之前可以先对梯度进行清零

import torch
def test002():
    # 1. 创建张量：必须为浮点类型
    x = torch.tensor([1.0, 2.0, 5.3], requires_grad=True)
    # 2. 累计梯度：每次计算都会累计梯度
    for i in range(3):
        y = x**2 + 2 * x + 7
        z = y.mean()
        # 2.1 反向传播之前先对梯度进行清零
        if x.grad is not None:
            x.grad.zero_()            
        z.backward()
        print(x.grad)
if __name__ == "__main__":
    test002()

叶子结点：

当requires_grad=True时，在调用numpy转换为ndarray时会报如下错误：

RuntimeError: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.

 detach()产生的张量是作为叶子结点存在的，并且该张量和原张量共享数据，只是该张量不需要计算梯度。

import torch
def test001():
    x = torch.tensor([1, 2, 3], requires_grad=True, dtype=torch.float32)
    x_np = x.detach()
    print("是两个东西：", id(x), id(x_np))
    print("数据是共享的：", id(x.data), id(x_np.data))    
    # 修改其中一个张量的值
    x_np[1:] = 100
    print(x, x_np)
if __name__ == "__main__":
    test001()

模型训练：

 完整的模型训练如下：

import math
import random
import torch
import numpy as np
from sklearn.datasets import make_regression
import pandas as pd
def build_dataset():
    """
    使用 sklearn 的 make_regression 方法来构建一个模拟的回归数据集。
    make_regression 方法的参数解释:
    - n_samples: 生成的样本数量，决定了数据集的规模。
    - n_features: 生成的特征数量，决定了数据维度。
    - noise: 添加到目标变量的噪声标准差，用于模拟真实世界数据的不完美。
    - coef: 如果为 True, 会返回生成数据的真实系数，用于了解特征与目标变量间的真实关系。
    - random_state: 随机数生成的种子，确保在多次运行中能够复现相同的结果。
    返回:
    - X: 生成的特征矩阵。
    - y: 生成的目标变量。
    - coef: 如果在调用时 coef 参数为 True，则还会返回真实系数。
    """
    noise = random.randint(1, 3)
    bias = 14.5
    X, y, coef = make_regression(
        n_samples=1000, n_features=5, bias=bias, noise=noise, coef=True, random_state=0
    )
    # 数据转换为张量
    X = torch.tensor(X, dtype=torch.float32)
    y = torch.tensor(y, dtype=torch.float32)
    coef = torch.tensor(coef, dtype=torch.float32)
    bias = torch.tensor(bias, dtype=torch.float32)
    return X, y, coef, bias
def data_loader(x, y, batch_size=16):
    """
    将数据集转换为迭代器，以便在训练过程中进行批量处理。
    """
    # 获取样本数量
    num_samples = x.shape[0]
    # 构建数据索引
    indices = list(range(num_samples))
    # 打乱数据顺序
    random.shuffle(indices)
    # 计算总的批次数量：向上取整
    num_batches = math.ceil(num_samples / batch_size)
    for i in range(num_batches):
        start = i * batch_size
        end = min((i + 1) * batch_size, num_samples)
        # 开始切片数据
        train_X = x[indices[start:end]]
        train_y = y[indices[start:end]]
        # 异步响应数据集
        yield train_X, train_y
# 构建模型函数：权重参数和偏执参数
# 初始化参数
def initialize_params(n_features):
    # 随机初始化权重w，并将偏置b初始化为0
    w = torch.randn(n_features, requires_grad=True, dtype=torch.float32)
    b = torch.tensor(0.0, requires_grad=True, dtype=torch.float32)
    return w, b
def linear_regression(x, w, b):
    return torch.matmul(x, w) + b
# 构建模型函数：损失函数和优化器
def mean_squared_error(y_pred, y_true):
    return torch.mean((y_pred - y_true) ** 2)
# 优化器（SGD，手动实现）
def sgd(w, b, dw, db, learning_rate, batch_size):
    w.data -= learning_rate * dw.data / batch_size
    b.data -= learning_rate * db.data / batch_size
    return w, b
# 训练函数
def train():
    # 1. 构建数据集
    X, y, coef, bias = build_dataset()
    # 2. 初始化模型参数
    w, b = initialize_params(X.shape[1])
    # 3. 定义训练参数
    learning_rate = 0.01
    epochs = 120
    batch_size = 16
    # 4. 开始训练
    for epoch in range(epochs):
        epoch_loss = 0
        num_batches = 0
        for train_X, train_y in data_loader(X, y, batch_size):
            num_batches += 1
            # 5. 前向传播
            y_pred = linear_regression(train_X, w, b)
            # 6. 计算损失
            loss = mean_squared_error(y_pred, train_y)
            # 9. 梯度清零
            if w.grad is not None:
                w.grad.zero_()
            if b.grad is not None:
                b.grad.zero_()
            # 7. 反向传播：会自动计算梯度
            loss.backward()
            # 8. 更新参数
            w, b = sgd(w, b, w.grad, b.grad, learning_rate, batch_size)
            # 10. 训练批次及损失率
            epoch_loss += loss.item()
        print(f"Epoch: {epoch}, Loss: {epoch_loss / num_batches}")
    return coef, bias, w, b
if __name__ == "__main__":
    coef, bias, w, b = train()
    print(f"真实系数: {coef}")
    print(f"预测系数: {w}")
    print(f"真实偏置: {bias}")
    print(f"预测偏置: {b}")

模型定义组件：

官方文档：torch.nn — PyTorch 2.5 documentation

损失函数组件：

PyTorch已内置多种损失函数，在构建神经网络时随用随取！

import torch
import torch.nn as nn
def test001():
    criterion = nn.MSELoss()
    # 真实值
    y_true = torch.randn(5, 3)
    # 预测值
    y_pred = torch.randn(5, 3, requires_grad=True)
    print(criterion(y_true, y_pred))
if __name__ == "__main__":
    test001()

线性层组件：

import torch
import torch.nn as nn
def test002():
    model = nn.Linear(20, 60)
    input = torch.randn(128, 20)
    output = model(input)
    print(output.size())
if __name__ == "__main__":
    test002()

优化器方法：

import torch
import torch.nn as nn
import torch.optim as optim
# 优化方法SGD的学习
def test003():
    model = nn.Linear(20, 60)
    criterion = nn.MSELoss()
    # 优化器：更新模型参数
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    input = torch.randn(128, 20)
    output = model(input)
    # 计算损失及反向传播
    loss = criterion(output, torch.randn(128, 60))
    # 梯度清零
    optimizer.zero_grad()
    # 反向传播
    loss.backward()
    # 更新模型参数
    optimizer.step()
if __name__ == "__main__":
    test003()

加载Excel数据集：

import torch
from torch.utils.data import Dataset, DataLoader
import pandas as pd
class MyExcelDataset(Dataset):
    def __init__(self, filename):
        # 使用pandas读取excel
        df = pd.read_excel(filename)
        # 数据处理根据具体情况去做，没有固定的思路
        # 你也可以不处理，直接根据下标取你要的数据
        # 数据处理：删除NAN的列
        df = df.dropna(axis=1, how="all")
        # 将数据转换为DataFrame
        df = pd.DataFrame(df)
        # 删除原有的表头，并重命名列名为英文
        df.columns = [
            "zubie",
            "student_id",
            "name",
            "expression",
            "ppt",
            "answer",
            "present",
            "defense",
            "comments",
        ]
        # 删除列name和comments
        df = df.drop(["zubie","student_id", "name", "comments"], axis=1)
        # 转换为tensor
        data = torch.tensor(df.values)
        self.data = data[:, :-1]
        self.label = data[:, -1]
        self.len = len(self.data)
    def __len__(self):
        return self.len
    def __getitem__(self, index):
        idx = min(max(index, 0), self.len - 1)
        return self.data[idx], self.label[idx]
def test001():
    excel_path = r"./test.xlsx"
    dataset = MyExcelDataset(excel_path)
    dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
    for i, (data, label) in enumerate(dataloader):
        print(i, data, label)
if __name__ == "__main__":
    test001()

数据增强：

数据增强是提高模型泛化能力（鲁棒性）的一种有效方法，尤其在图像分类、目标检测等任务中。数据增强可以模拟更多的训练样本，从而减少过拟合风险。

from PIL import Image
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import torch
from torchvision.transforms import v2
plt.rcParams["savefig.bbox"] = "tight"
torch.manual_seed(0)
orig_img = Image.open("./origin.jpg")
def plot(imgs, title, with_orig=True, row_title=None, **imshow_kwargs):
    if not isinstance(imgs[0], list):
        # Make a 2d grid even if there's just 1 row
        imgs = [imgs]
    num_rows = len(imgs)
    num_cols = len(imgs[0]) + with_orig
    fig, axs = plt.subplots(nrows=num_rows, ncols=num_cols, squeeze=False)
    plt.title(title)
    for row_idx, row in enumerate(imgs):
        row = [orig_img] + row if with_orig else row
        for col_idx, img in enumerate(row):
            ax = axs[row_idx, col_idx]
            ax.imshow(np.asarray(img), **imshow_kwargs)
            ax.set(xticklabels=[], yticklabels=[], xticks=[], yticks=[])
    if with_orig:
        axs[0, 0].set(title="Original image")
        axs[0, 0].title.set_size(8)
    if row_title is not None:
        for row_idx in range(num_rows):
            axs[row_idx, 0].set(ylabel=row_title[row_idx])
    plt.tight_layout()
    plt.show()
# 边缘填充
padded_imgs = [v2.Pad(padding=padding)(orig_img) for padding in (3, 10, 30, 50)]
plot([orig_img] + padded_imgs, "v2.Pad")
# 大小调整
resized_imgs = [v2.Resize(size=size)(orig_img) for size in (30, 50, 100, orig_img.size)]
plot([orig_img] + resized_imgs, "v2.Resize")
# 中心裁剪
center_crops = [
    v2.CenterCrop(size=size)(orig_img) for size in (30, 50, 100, orig_img.size)
]
plot([orig_img] + center_crops, "v2.CenterCrop")
# 周边裁剪
(top_left, top_right, bottom_left, bottom_right, center) = v2.FiveCrop(size=(100, 100))(
    orig_img
)
plot(
    [orig_img] + [top_left, top_right, bottom_left, bottom_right, center], "v2.FiveCrop"
)

模型的保存和加载：

训练一个模型通常需要大量的数据、时间和计算资源。通过保存训练好的模型，可以满足后续的模型部署、模型更新、迁移学习、训练恢复等各种业务需要求。

import torch
import torch.nn as nn
import torch.optim as optim
import pickle
class MyModle(nn.Module):
    def __init__(self, input_size, output_size):
        super(MyModle, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, output_size)

    def forward(self, x):
        x = self.fc1(x)
        x = self.fc2(x)
        output = self.fc3(x)
        return output
def test003():
    model = MyModle(input_size=128, output_size=32)
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    # 自己构建要存储的模型参数
    save_dict = {
        "init_params": {
            "input_size": 128,  # 输入特征数
            "output_size": 32,  # 输出特征数
        },
        "accuracy": 0.99,  # 模型准确率
        "model_state_dict": model.state_dict(),
        "optimizer_state_dict": optimizer.state_dict(),
    }
    torch.save(save_dict, "model_dict.pth")
def test004():
    save_dict = torch.load("model_dict.pth")
    model = MyModle(
        input_size=save_dict["init_params"]["input_size"],
        output_size=save_dict["init_params"]["output_size"],
    )
    # 初始化模型参数
    model.load_state_dict(save_dict["model_state_dict"])
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    # 初始化优化器参数
    optimizer.load_state_dict(save_dict["optimizer_state_dict"])
    # 打印模型信息
    print(save_dict["accuracy"])
    print(model)
if __name__ == "__main__":
    test003()
    test004()