PyTorch 深度學習的十個核心概念
作者：小白PythonAI編程
本文介紹了 PyTorch 中的十個核心概念，通過這些概念的學習和實踐，你可以更好地理解和使用 PyTorch 構建和訓練深度學習模型。
深度學習是當前最熱門的技術之一，而 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 構建一個簡單的卷積神經網絡來識別手寫數字。
責任編輯：趙寧寧
來源：
小白PythonAI編程
