Pytorch torch 参考手册（一文讲透）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在深度学习领域，PyTorch 是一个不可或缺的框架，其灵活性和高效性使其成为开发者和研究者的首选工具。对于编程初学者和中级开发者而言，掌握 PyTorch 的核心功能和使用方法，是构建神经网络模型、处理数据、优化算法的基础。本文以“PyTorch torch 参考手册”为主题，系统性地梳理 PyTorch 的关键知识点，通过形象的比喻、代码示例和实战案例，帮助读者逐步深入理解这一框架的核心机制。

一、PyTorch 基础概念：从张量到自动求导

1.1 张量（Tensor）：PyTorch 的核心数据结构

张量是什么？
张量可以理解为多维数组的容器，是 PyTorch 的核心数据结构。它类似于 NumPy 的 ndarray，但支持 GPU 加速和自动求导（Autograd）。例如，一个二维张量可以看作一个表格，而三维张量则是一个“书本”——每一层是一个二维表格。

创建张量的示例：

import torch  

tensor = torch.rand(2, 3)  
print(tensor)  

numpy_array = [[1, 2], [3, 4]]  
tensor_from_array = torch.tensor(numpy_array)  
print(tensor_from_array)

1.2 自动求导（Autograd）：梯度计算的魔法

自动求导如何工作？
想象你正在攀爬一座山，每一步的方向和速度（梯度）决定了你能否最快到达山顶。PyTorch 的自动求导机制就像一个“导航仪”，自动计算模型参数的梯度，帮助优化器调整参数以最小化损失函数。

代码示例：计算简单函数的梯度

x = torch.tensor(2.0, requires_grad=True)  
y = x ** 2 + 3 * x  
y.backward()  # 计算梯度  
print(f"dy/dx = {x.grad}")  # 输出 dy/dx = 7.0（因为导数为 2x+3）

1.3 神经网络模块（Module）：积木式模型构建

PyTorch 的 torch.nn 模块提供了一套类似“乐高积木”的组件，如全连接层、卷积层等。通过组合这些模块，可以快速搭建复杂的神经网络。

简单模型构建示例：

import torch.nn as nn  

class SimpleNet(nn.Module):  
    def __init__(self):  
        super(SimpleNet, self).__init__()  
        self.layer = nn.Sequential(  
            nn.Linear(784, 128),  # 输入层到隐藏层  
            nn.ReLU(),            # 激活函数  
            nn.Linear(128, 10)    # 隐藏层到输出层  
        )  

    def forward(self, x):  
        return self.layer(x)  

model = SimpleNet()  
print(model)

二、PyTorch 核心功能详解

2.1 张量操作：像搭积木一样处理数据

张量操作的常见场景：

• 形状变换：例如，将一个二维张量展平为一维，类似于把一本书拆成一页页的纸张。
• 数学运算：加减乘除、矩阵乘法（torch.matmul）、点积等，支持广播机制。
• 索引与切片：灵活提取或修改张量的子集，如 tensor[:, 1:3]。

示例：矩阵乘法与广播机制

a = torch.tensor([[1, 2], [3, 4]])  # 2x2  
b = torch.tensor([[5], [6]])        # 2x1  
result = a * b                     # 广播后相乘，结果为 2x2  
print(result)  

2.2 数据加载与预处理：构建高效的流水线

数据加载的核心步骤：

1. 数据集定义：继承 torch.utils.data.Dataset，实现 __getitem__ 和 __len__。
2. 数据加载器：使用 DataLoader 批量加载数据，支持多进程加速。

示例：自定义数据集与 DataLoader

from torch.utils.data import Dataset, DataLoader  

class CustomDataset(Dataset):  
    def __init__(self, data, labels):  
        self.data = data  
        self.labels = labels  

    def __len__(self):  
        return len(self.data)  

    def __getitem__(self, idx):  
        return self.data[idx], self.labels[idx]  

dataset = CustomDataset(...)  
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)  

2.3 模型训练与优化：让模型“学会”预测

训练流程的四大要素：

1. 损失函数（Loss Function）：衡量模型预测与真实值的差距（如交叉熵损失 nn.CrossEntropyLoss）。
2. 优化器（Optimizer）：根据梯度更新参数（如 Adam、SGD）。
3. 前向传播（Forward Pass）：模型计算预测值。
4. 反向传播（Backward Pass）：计算梯度并更新参数。

示例：完整训练循环

criterion = nn.CrossEntropyLoss()  
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  

for epoch in range(10):  
    for inputs, labels in dataloader:  
        optimizer.zero_grad()          # 清空梯度  
        outputs = model(inputs)        # 前向传播  
        loss = criterion(outputs, labels)  
        loss.backward()                # 反向传播  
        optimizer.step()               # 更新参数  

三、高级技巧与最佳实践

3.1 GPU 加速：让训练“快如闪电”

如何利用 GPU？
通过 tensor.to(device) 将张量和模型移动到 GPU，例如：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  
model = model.to(device)  
tensor = tensor.to(device)  

3.2 自定义损失函数与激活函数：灵活应对复杂场景

案例：自定义平滑 L1 损失函数

class SmoothL1Loss(nn.Module):  
    def __init__(self, beta=1.0):  
        super(SmoothL1Loss, self).__init__()  
        self.beta = beta  

    def forward(self, pred, target):  
        diff = torch.abs(pred - target)  
        loss = torch.where(diff < self.beta, 0.5 * diff ** 2 / self.beta, diff - 0.5 / self.beta)  
        return loss.mean()  

3.3 模型保存与加载：持久化训练成果

如何保存和恢复模型？

torch.save(model.state_dict(), "model.pth")  

model = SimpleNet()  
model.load_state_dict(torch.load("model.pth"))  
model.eval()  # 切换为推理模式

四、实战案例：从零开始构建手写数字识别模型

4.1 数据准备：使用 MNIST 数据集

from torchvision import datasets, transforms  

transform = transforms.Compose([  
    transforms.ToTensor(),  
    transforms.Normalize((0.1307,), (0.3081,))  
])  

train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)  
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform)  

4.2 模型定义与训练

class MNISTNet(nn.Module):  
    def __init__(self):  
        super(MNISTNet, self).__init__()  
        self.conv = nn.Sequential(  
            nn.Conv2d(1, 32, kernel_size=3, padding=1),  
            nn.ReLU(),  
            nn.MaxPool2d(2),  
            nn.Conv2d(32, 64, kernel_size=3, padding=1),  
            nn.ReLU(),  
            nn.MaxPool2d(2)  
        )  
        self.fc = nn.Linear(64 * 7 * 7, 10)  

    def forward(self, x):  
        x = self.conv(x)  
        x = x.view(x.size(0), -1)  
        return self.fc(x)  

model = MNISTNet().to(device)  
criterion = nn.CrossEntropyLoss()  
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  

4.3 训练与评估

for epoch in range(10):  
    # 训练循环  
    model.train()  
    for batch_idx, (data, target) in enumerate(train_loader):  
        data, target = data.to(device), target.to(device)  
        optimizer.zero_grad()  
        output = model(data)  
        loss = criterion(output, target)  
        loss.backward()  
        optimizer.step()  

    # 验证循环  
    model.eval()  
    with torch.no_grad():  
        correct = 0  
        for data, target in test_loader:  
            data, target = data.to(device), target.to(device)  
            output = model(data)  
            pred = output.argmax(dim=1)  
            correct += pred.eq(target.view_as(pred)).sum().item()  
        print(f"Epoch {epoch+1}, Accuracy: {correct/len(test_dataset):.4f}")  

结论

本文通过系统性地讲解 PyTorch 的核心概念、功能和高级技巧，并结合实战案例，帮助读者逐步掌握这一框架的使用方法。无论是张量操作、自动求导，还是模型构建与训练，PyTorch 的灵活性和高效性使其成为深度学习开发的首选工具。

对于初学者，建议从简单任务（如线性回归或 MNIST 分类）入手，逐步深入复杂模型（如卷积神经网络或 Transformer）。通过持续实践和参考手册中的 API 文档，开发者可以快速提升技能，并应对实际项目中的挑战。记住，PyTorch 的核心逻辑并不复杂，关键在于理解“数据流动”和“梯度更新”的本质——就像学会驾驶一辆车，需要熟悉油门、方向盘和刹车的位置与作用。

希望本文能成为你的“PyTorch torch 参考手册”，在深度学习的探索之路上助你一臂之力！