PyTorch 的核心操作可按「张量操作、模型构建、训练流程、数据处理、工具类」五大核心场景分类，覆盖从入门到实战的绝大多数高频用法，以下是带示例的详细整理：
一、张量（Tensor）核心操作（基础必备）
张量是 PyTorch 的基础数据结构，类似 NumPy 数组但支持 GPU 加速，以下是高频操作：
1. 张量创建
python
import torch
# 基础创建
x = torch.tensor([1, 2, 3]) # 从列表创建
x = torch.zeros((3, 4)) # 全0张量（形状(3,4)）
x = torch.ones((2, 2)) # 全1张量
x = torch.rand((2, 3)) # 0-1均匀分布随机张量
x = torch.randn((2, 3)) # 标准正态分布随机张量
x = torch.arange(0, 10, 2) # 等差数列（0,2,4,6,8）
x = torch.eye(3) # 单位矩阵（3×3）
x = torch.from_numpy(np.array([1,2,3])) # 从NumPy数组转换
# 设备指定（CPU/GPU）
x = torch.tensor([1,2,3], device="cuda") # 直接创建在GPU
x = x.to("cpu") # 转移到CPU
2. 张量属性与形状操作
python
x = torch.rand((2, 3, 4))
# 核心属性
print(x.shape) # 形状 → torch.Size([2,3,4])
print(x.dtype) # 数据类型 → torch.float32
print(x.device) # 设备 → cpu/cuda:0
print(x.numel()) # 元素总数 → 2×3×4=24
# 形状修改（高频）
x = x.reshape(2, 12) # 重塑形状（需元素总数匹配）
x = x.view(6, 4) # 视图（与原张量共享内存，更快）
x = x.unsqueeze(1) # 增加维度 → (2,1,12)
x = x.squeeze(1) # 压缩维度（仅压缩长度为1的维度）
x = x.transpose(0, 1) # 维度交换（0和1维互换）
x = x.permute(1, 0) # 多维度重排（更灵活）
3. 张量运算（算术/逻辑）
python
a = torch.tensor([1,2,3])
b = torch.tensor([4,5,6])
# 算术运算（支持广播）
c = a + b # 逐元素加 → [5,7,9]
c = a * b # 逐元素乘 → [4,10,18]
c = torch.matmul(a, b) # 矩阵乘法（点积）→ 1×4+2×5+3×6=32
c = a @ b # 矩阵乘法简写（等价于matmul）
c = torch.mean(a) # 均值 → 2.0
c = torch.max(a) # 最大值 → 3
c = torch.argmax(a)# 最大值索引 → 2
c = a.sum() # 求和 → 6
# 逻辑运算
mask = a > 2 # 逐元素判断 → [False,False,True]
c = a[mask] # 按掩码索引 → [3]
4. 张量索引与切片（类似NumPy）
python
x = torch.rand((3, 4))
# 基础索引
print(x[0]) # 第0行 → (4,)
print(x[0, 1]) # 第0行第1列 → 标量
print(x[:, 1]) # 所有行的第1列 → (3,)
print(x[1:3, :2]) # 第1-2行，第0-1列 → (2,2)
# 高级索引
indices = torch.tensor([0, 2])
print(x[indices]) # 按索引取行 → (2,4)
5. 梯度相关（反向传播必备）
python
x = torch.tensor([1.0, 2.0], requires_grad=True) # 开启梯度追踪
y = x.sum()
y.backward() # 反向传播计算梯度
print(x.grad) # 查看梯度 → [1.0, 1.0]
# 关闭梯度追踪（推理阶段）
with torch.no_grad():
z = x * 2
print(z.requires_grad) # False
二、模型构建与层操作（核心）
PyTorch 构建模型的核心是 nn.Module 基类，以下是高频操作：
1. 基础模型定义
python
import torch.nn as nn
# 定义自定义模型
class MyModel(nn.Module):
def __init__(self):
super().__init__()
# 定义层（高频内置层）
self.conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
self.relu = nn.ReLU()
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
self.fc = nn.Linear(in_features=16*16*16, out_features=10) # 全连接层
def forward(self, x):
# 前向传播（必须实现）
x = self.conv(x)
x = self.relu(x)
x = self.pool(x)
x = x.flatten() # 展平（等价于x.view(x.size(0), -1)）
x = self.fc(x)
return x
# 实例化模型
model = MyModel()
print(model) # 打印模型结构
2. 模型参数与设备配置
python
# 模型转移到GPU
if torch.cuda.is_available():
model = model.to("cuda")
# 查看模型参数
for name, param in model.named_parameters():
print(name, param.shape) # 输出参数名和形状（如conv.weight: (16,3,3,3)）
# 冻结部分层（微调时用）
for param in model.conv.parameters():
param.requires_grad = False # 关闭卷积层梯度更新
3. 模型保存与加载（实战必备）
python
# 保存模型（推荐保存状态字典，更灵活）
torch.save(model.state_dict(), "model.pth")
# 加载模型
model = MyModel()
model.load_state_dict(torch.load("model.pth"))
# 推理模式（禁用Dropout/BatchNorm等训练层）
model.eval()
三、训练流程操作（实战核心）
1. 损失函数与优化器
python
# 定义损失函数（高频）
criterion = nn.CrossEntropyLoss() # 分类任务
# criterion = nn.MSELoss() # 回归任务
# 定义优化器（高频）
import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9) # SGD
# optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam（更常用）
2. 单轮训练步骤
python
# 训练模式（启用Dropout/BatchNorm）
model.train()
# 单批次训练
for inputs, labels in dataloader:
# 数据转移到GPU
inputs, labels = inputs.to("cuda"), labels.to("cuda")
# 清零梯度（必须）
optimizer.zero_grad()
# 前向传播
outputs = model(inputs)
# 计算损失
loss = criterion(outputs, labels)
# 反向传播
loss.backward()
# 更新参数
optimizer.step()
# 打印损失
print(f"Loss: {loss.item():.4f}")
四、数据处理（DataLoader/Transforms）
1. 数据变换（Transforms）
python
from torchvision import transforms
# 定义变换管道（图像预处理高频）
transform = transforms.Compose([
transforms.Resize((32, 32)), # 调整尺寸
transforms.ToTensor(), # 转为张量（0-1范围）
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # 归一化
])
2. 数据加载（DataLoader）
python
from torch.utils.data import DataLoader, Dataset
# 自定义数据集（示例）
class MyDataset(Dataset):
def __init__(self, data, labels, transform=None):
self.data = data
self.labels = labels
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
x = self.data[idx]
y = self.labels[idx]
if self.transform:
x = self.transform(x)
return x, y
# 实例化数据集和DataLoader
dataset = MyDataset(data, labels, transform=transform)
dataloader = DataLoader(
dataset,
batch_size=32, # 批次大小
shuffle=True, # 训练集打乱
num_workers=4 # 多线程加载（加速）
)
# 遍历DataLoader
for batch_idx, (inputs, labels) in enumerate(dataloader):
pass
五、工具类高频操作
1. GPU 相关
python
# 查看GPU是否可用
print(torch.cuda.is_available()) # True/False
print(torch.cuda.device_count()) # GPU数量
print(torch.cuda.get_device_name(0)) # GPU名称
# 清空GPU缓存（解决显存溢出）
torch.cuda.empty_cache()
2. 张量与NumPy互转
python
# 张量 → NumPy
x = torch.tensor([1,2,3])
x_np = x.numpy() # CPU张量直接转，GPU张量需先转CPU
# NumPy → 张量
x = torch.from_numpy(x_np)
3. 随机种子（复现结果）
python
# 设置全局随机种子（保证实验可复现）
torch.manual_seed(42)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(42)
六、高频操作速记（刷题/实战）
| 场景 | 核心操作 |
|---|---|
| 张量基础 | tensor()/zeros()/rand()/reshape()/permute()/matmul() |
| 模型构建 | nn.Module/nn.Conv2d/nn.Linear/forward() |
| 训练流程 | model.train()/model.eval()/optimizer.zero_grad()/loss.backward() |
| 数据处理 | Dataset/DataLoader/transforms.Compose() |
| 模型保存加载 | torch.save()/load_state_dict() |
| GPU 加速 | to("cuda")/cuda.is_available()/empty_cache() |