深度学习是当前最热门的技术之一，而 PyTorch 是一个非常受欢迎的深度学习框架。 今天，我们将深入探讨 PyTorch 中的 10 个核心概念，帮助你更好地理解和使用这个强大的工具。 张量（Tensor）张量是 PyTorch 中最基本的数据结构，类似于 NumPy 的数组，但可以在 GPU 上运行，从而加速计算。
深度学习是当前最热门的技术之一，而 PyTorch 是一个非常受欢迎的深度学习框架。今天，我们将深入探讨 PyTorch 中的 10 个核心概念，帮助你更好地理解和使用这个强大的工具。
1. 张量（Tensor）
张量是 PyTorch 中最基本的数据结构，类似于 NumPy 的数组，但可以在 GPU 上运行，从而加速计算。
复制
import torch # 创建一个 2x3 的张量 tensor = torch.tensor([[1, 2, 3], [4, 5, 6]]) print(tensor)
输出：
复制
tensor([[1, 2, 3],
[4, 5, 6]])2. 自动求导（Autograd）
自动求导是 PyTorch 的一大亮点，它允许我们自动计算梯度，从而简化了反向传播的过程。
复制
# 创建一个需要求导的张量 x = torch.tensor([2.0], requires_grad=True) # 定义一个函数 y = x^2 y = x ** 2 # 计算梯度 y.backward() # 输出梯度 print(x.grad)
输出：
复制
tensor([4.])
3. 动态计算图
PyTorch 使用动态计算图，这意味着每次前向传播时都会重新构建计算图，这使得模型更加灵活。
复制
# 动态计算图示例
x = torch.tensor([1.0], requires_grad=True)
y = x * 2
for _ in range(3):
y = y * x
y.backward()
print(x.grad)输出：
复制
tensor([16.])
4. 模型定义（nn.Module）
nn.Module 是 PyTorch 中定义模型的基本类。通过继承 nn.Module，我们可以轻松地构建复杂的神经网络。
复制
import torch.nn as nn
class SimpleModel(nn.Module):
def __init__(self):
super(SimpleModel, self).__init__()
self.linear = nn.Linear(1, 1)
def forward(self, x):
return self.linear(x)
model = SimpleModel()
print(model)输出：
复制
SimpleModel( (linear): Linear(in_features=1, out_features=1, bias=True) )
5. 损失函数（Loss Function）
损失函数用于衡量模型预测值与真实值之间的差异。常见的损失函数包括均方误差（MSE）和交叉熵损失（CrossEntropyLoss）。
复制
criterion = nn.MSELoss() # 假设的预测值和真实值 y_pred = torch.tensor([1.0]) y_true = torch.tensor([2.0]) loss = criterion(y_pred, y_true) print(loss)
输出：
复制
tensor(1.)
6. 优化器（Optimizer）
优化器用于更新模型参数，以最小化损失函数。常见的优化器包括 SGD（随机梯度下降）和 Adam。
复制
optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 清除梯度 optimizer.zero_grad() # 计算损失 loss = criterion(model(torch.tensor([1.0])), torch.tensor([2.0])) # 反向传播 loss.backward() # 更新参数 optimizer.step()
7. 数据加载（DataLoader）
DataLoader 用于加载和预处理数据，支持批量加载和多线程处理。
复制
from torch.utils.data import DataLoader, TensorDataset
# 创建数据集
data = TensorDataset(torch.tensor([[1.0], [2.0], [3.0]]), torch.tensor([[2.0], [4.0], [6.0]]))
# 创建 DataLoader
dataloader = DataLoader(data, batch_size=2, shuffle=True)
# 迭代数据
for inputs, targets in dataloader:
print(inputs, targets)输出：
复制
tensor([[2.],
[1.]]) tensor([[4.],
[2.]])
tensor([[3.]]) tensor([[6.]])8. 模型保存与加载
保存和加载模型是非常重要的操作，可以方便地在不同阶段恢复训练或部署模型。
复制
# 保存模型 torch.save(model.state_dict(), 'model.pth') # 加载模型
9. 转换（Transforms）
转换用于对数据进行预处理，如归一化、裁剪等。常用的库有 torchvision.transforms。
复制
from torchvision import transforms
# 定义转换
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 应用转换
image = transform(image)10. GPU 支持
PyTorch 支持 GPU 计算，可以通过简单的 API 将数据和模型转移到 GPU 上。
复制
# 检查是否有可用的 GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 将模型和数据转移到 GPU
model.to(device)
inputs = inputs.to(device)
targets = targets.to(device)
# 在 GPU 上进行前向传播
outputs = model(inputs)实战案例：手写数字识别
假设我们要构建一个简单的卷积神经网络（CNN）来识别手写数字。我们将使用 MNIST 数据集进行训练和测试。
复制
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 定义模型
class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
self.fc1 = nn.Linear(16 * 14 * 14, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = x.view(-1, 16 * 14 * 14)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
# 数据预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 加载数据集
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
# 初始化模型、损失函数和优化器
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练模型
num_epochs = 5
for epoch in range(num_epochs):
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
# 测试模型
model.eval()
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_loader:
inputs, labels = inputs.to(device), labels.to(device)
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f'Accuracy: {100 * correct / total:.2f}%')总结
本文介绍了 PyTorch 中的 10 个核心概念，包括张量、自动求导、动态计算图、模型定义、损失函数、优化器、数据加载、模型保存与加载、转换和 GPU 支持。通过这些概念的学习和实践，你可以更好地理解和使用 PyTorch 构建和训练深度学习模型。最后，我们还通过一个实战案例展示了如何使用 PyTorch 构建一个简单的卷积神经网络来识别手写数字。