当前位置：首页 > news >正文

PyTorch 2.5实战教程：10个核心API详解，轻松搭建你的第一个AI模型

news 2026/8/7 9:52:53

PyTorch 2.5实战教程：10个核心API详解，轻松搭建你的第一个AI模型

1. 学习目标与前置准备

1.1 本教程能带给你什么

通过这篇教程，你将掌握PyTorch 2.5中最核心的10个API使用方法，并能够独立完成一个简单AI模型的搭建和训练。我们将从最基础的张量操作开始，逐步深入到神经网络构建、训练流程等实战内容。

1.2 环境准备

确保你已经安装好PyTorch 2.5环境。如果你使用CSDN星图镜像，可以直接获取预配置好的PyTorch-CUDA环境：

# 验证安装 import torch print(torch.__version__) # 应该输出2.5.x print(torch.cuda.is_available()) # 检查GPU是否可用

2. 核心API详解与实战

2.1 张量操作基础

2.1.1 张量创建与属性

张量(Tensor)是PyTorch中最基本的数据结构，类似于NumPy数组但支持GPU加速：

# 创建张量的多种方式 data = [[1, 2], [3, 4]] x = torch.tensor(data) # 从Python列表创建 zeros = torch.zeros(2, 3) # 2行3列的全零张量 rand = torch.rand(2, 2) # 2x2的随机张量(0-1均匀分布) # 查看张量属性 print(x.shape) # 输出: torch.Size([2, 2]) print(x.dtype) # 输出: torch.int64 print(x.device) # 输出: cpu 或 cuda:0

2.1.2 张量运算

PyTorch支持丰富的数学运算，这些运算会自动广播(broadcast)：

a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) # 基本运算 print(a + b) # 逐元素相加 print(a * b) # 逐元素相乘 print(torch.matmul(a, b)) # 点积运算 # 变形操作 c = torch.arange(6) print(c.view(2, 3)) # 改变形状为2x3 print(c.reshape(3, 2)) # 另一种变形方式

2.2 自动微分机制

2.2.1 梯度计算基础

PyTorch的autograd包提供了自动微分功能：

# 需要计算梯度的张量 x = torch.tensor(2.0, requires_grad=True) # 定义计算图 y = x ** 3 + 2 * x # 反向传播计算梯度 y.backward() print(x.grad) # 输出: dy/dx = 3x² + 2 = 14.0

2.2.2 梯度控制技巧

在实际训练中，我们需要精细控制梯度计算：

# 临时禁用梯度计算 with torch.no_grad(): y = x * 2 # 不会追踪计算历史 # 手动清空梯度 optimizer = torch.optim.SGD([x], lr=0.1) optimizer.zero_grad() # 清空之前的梯度

2.3 神经网络构建

2.3.1 定义网络结构

使用torch.nn模块可以方便地构建神经网络：

import torch.nn as nn import torch.nn.functional as F class SimpleNet(nn.Module): def __init__(self): super().__init__() self.fc1 = nn.Linear(784, 128) # 全连接层 self.fc2 = nn.Linear(128, 10) # 输出层 self.dropout = nn.Dropout(0.2) # Dropout层 def forward(self, x): x = F.relu(self.fc1(x)) x = self.dropout(x) x = self.fc2(x) return x model = SimpleNet() print(model)

2.3.2 损失函数与优化器

PyTorch提供了常见的损失函数和优化器：

criterion = nn.CrossEntropyLoss() # 交叉熵损失 optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Adam优化器

2.4 数据加载与处理

2.4.1 自定义数据集

使用Dataset和DataLoader高效加载数据：

from torch.utils.data import Dataset, DataLoader class MyDataset(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] # 示例使用 data = torch.randn(1000, 784) # 1000个样本，每个784维 labels = torch.randint(0, 10, (1000,)) # 1000个0-9的标签 dataset = MyDataset(data, labels) dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

2.4.2 数据增强

对于图像数据，可以使用torchvision.transforms：

from torchvision import transforms transform = transforms.Compose([ transforms.RandomHorizontalFlip(), # 随机水平翻转 transforms.ToTensor(), # 转为张量 transforms.Normalize((0.5,), (0.5,)) # 标准化 ])

2.5 模型训练完整流程

2.5.1 训练循环

一个完整的训练epoch包含以下步骤：

def train(model, dataloader, criterion, optimizer, device): model.train() # 设置为训练模式 total_loss = 0 for batch_idx, (data, target) in enumerate(dataloader): data, target = data.to(device), target.to(device) optimizer.zero_grad() # 清空梯度 output = model(data) # 前向传播 loss = criterion(output, target) # 计算损失 loss.backward() # 反向传播 optimizer.step() # 更新参数 total_loss += loss.item() return total_loss / len(dataloader)

2.5.2 验证循环

验证阶段不需要计算梯度：

def validate(model, dataloader, criterion, device): model.eval() # 设置为评估模式 total_loss = 0 correct = 0 with torch.no_grad(): for data, target in dataloader: data, target = data.to(device), target.to(device) output = model(data) total_loss += criterion(output, target).item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() accuracy = 100. * correct / len(dataloader.dataset) return total_loss / len(dataloader), accuracy

3. 完整案例：手写数字识别

3.1 数据集准备

使用经典的MNIST数据集：

from torchvision import datasets, transforms # 数据转换 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # 加载数据集 train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST('./data', train=False, transform=transform) # 创建数据加载器 train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

3.2 模型定义

定义一个简单的卷积神经网络：

class CNN(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 32, 3, 1) self.conv2 = nn.Conv2d(32, 64, 3, 1) self.dropout = nn.Dropout(0.5) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10) def forward(self, x): x = F.relu(self.conv1(x)) x = F.max_pool2d(x, 2) x = F.relu(self.conv2(x)) x = F.max_pool2d(x, 2) x = torch.flatten(x, 1) x = self.dropout(x) x = F.relu(self.fc1(x)) x = self.fc2(x) return x model = CNN().to(device) # 移动到GPU

3.3 训练与评估

运行完整的训练流程：

optimizer = torch.optim.Adam(model.parameters()) criterion = nn.CrossEntropyLoss() for epoch in range(1, 11): train_loss = train(model, train_loader, criterion, optimizer, device) val_loss, val_acc = validate(model, test_loader, criterion, device) print(f'Epoch {epoch}: Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.2f}%')