PyTorch深度学习入门：从环境配置到模型部署完整指南

在实际深度学习项目开发中，PyTorch 已经成为大多数研究者和工程师的首选框架。它之所以能从众多框架中脱颖而出，关键在于其动态计算图的灵活性和与 Python 生态的无缝集成，让开发者能够像写普通 Python 代码一样构建和调试神经网络。对于刚接触深度学习的开发者来说，PyTorch 的学习曲线相对平缓，但要想真正掌握其核心机制并避免常见陷阱，需要系统性地理解从环境搭建到模型部署的完整链路。

本文将带您完成 PyTorch 的完整入门路径，重点解决新手最常遇到的环境配置、基础概念理解、代码实践和故障排查问题。无论您是准备开始第一个深度学习项目，还是希望系统梳理 PyTorch 知识体系，都可以按照本文的步骤构建坚实的实践基础。

1. 理解 PyTorch 的核心设计理念

1.1 为什么 PyTorch 适合深度学习入门

PyTorch 采用"Define-by-Run"的设计哲学，这意味着计算图是在代码执行过程中动态构建的。这种即时执行模式与 Python 的交互式特性完美契合，允许开发者在每一步操作后立即检查结果，大大降低了调试难度。相比之下，静态图框架需要先完整定义计算图再执行，虽然优化效率高，但调试体验较差。

PyTorch 的三层设计结构清晰易懂：

• 前端 Python API：提供直观的接口，让用户能够用熟悉的 Python 语法构建模型
• C++ 后端核心：处理高性能张量运算和自动微分计算
• 硬件加速层：通过 CUDA 接口利用 GPU 的并行计算能力

1.2 张量：PyTorch 的核心数据结构

张量是 PyTorch 中最基本的数据结构，可以看作是多维数组的扩展。理解张量的维度概念对后续学习至关重要：

import torch # 标量（0维张量） scalar = torch.tensor(3.14) print(f"标量: {scalar}, 形状: {scalar.shape}") # 向量（1维张量） vector = torch.tensor([1, 2, 3, 4, 5]) print(f"向量: {vector}, 形状: {vector.shape}") # 矩阵（2维张量） matrix = torch.tensor([[1, 2, 3], [4, 5, 6]]) print(f"矩阵: {matrix}, 形状: {matrix.shape}") # 3维张量（如批量图像数据） batch_tensor = torch.randn(32, 3, 224, 224) # 批量大小32, 3通道, 224x224图像 print(f"3维张量形状: {batch_tensor.shape}")

张量不仅存储数据，还跟踪计算历史，这是自动微分能够实现的基础。每个张量都有.grad属性存储梯度，以及.grad_fn属性指向创建该张量的函数。

1.3 动态计算图与自动微分

PyTorch 的自动微分系统 autograd 是框架的核心竞争力。当我们在张量上设置requires_grad=True时，PyTorch 会开始跟踪所有相关操作，构建一个动态计算图：

# 自动微分示例 x = torch.tensor(2.0, requires_grad=True) y = torch.tensor(3.0, requires_grad=True) # 前向计算 z = x**2 + y**3 + x*y print(f"z = {z}") # 反向传播计算梯度 z.backward() print(f"∂z/∂x = {x.grad}") # 2x + y = 2*2 + 3 = 7 print(f"∂z/∂y = {y.grad}") # 3y² + x = 3*9 + 2 = 29

这种自动微分机制让开发者能够专注于模型结构设计，而不用手动计算复杂的梯度公式。

2. 环境准备与安装配置

2.1 硬件和软件环境要求

在开始安装前，需要确认系统环境满足基本要求：

对于 GPU 版本，需要确认显卡支持 CUDA：

• NVIDIA 显卡，计算能力 3.5+
• 最新驱动版本
• CUDA Toolkit（版本需与 PyTorch 匹配）

2.2 使用 Conda 管理 PyTorch 环境

Anaconda 或 Miniconda 是管理 Python 环境的最佳选择，可以有效解决依赖冲突问题：

# 创建专用环境 conda create -n pytorch-env python=3.9 # 激活环境 conda activate pytorch-env # 安装基础数据科学包 conda install numpy pandas matplotlib jupyter

2.3 PyTorch 安装方法对比

PyTorch 提供多种安装方式，各有优缺点：

国内用户加速安装方案：

# 使用清华镜像源加速 pip 安装 pip install torch torchvision torchaudio -i https://pypi.tuna.tsinghua.edu.cn/simple # 或者使用 conda 清华镜像 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/ conda install pytorch torchvision

2.4 验证安装结果

安装完成后，需要验证 PyTorch 是否正确安装以及 GPU 是否可用：

import torch import torchvision print(f"PyTorch 版本: {torch.__version__}") print(f"Torchvision 版本: {torchvision.__version__}") print(f"CUDA 是否可用: {torch.cuda.is_available()}") if torch.cuda.is_available(): print(f"CUDA 版本: {torch.version.cuda}") print(f"GPU 设备名称: {torch.cuda.get_device_name(0)}") print(f"可用 GPU 数量: {torch.cuda.device_count()}") # 测试 GPU 张量运算 x = torch.randn(1000, 1000).cuda() y = torch.randn(1000, 1000).cuda() z = torch.matmul(x, y) print(f"GPU 矩阵乘法完成: {z.shape}")

2.5 常见安装问题排查

安装过程中可能遇到的问题及解决方案：

注意：如果遇到 CUDA 版本不匹配问题，需要查看 PyTorch 官网确认当前版本支持的 CUDA 版本，然后安装对应的 CUDA Toolkit。

3. PyTorch 基础编程实践

3.1 张量创建与基本操作

掌握张量的各种创建方式是使用 PyTorch 的基础：

import torch # 从列表创建 tensor_from_list = torch.tensor([[1, 2], [3, 4]]) print(f"从列表创建: {tensor_from_list}") # 特殊张量创建 zeros_tensor = torch.zeros(2, 3) # 全零张量 ones_tensor = torch.ones(2, 3) # 全一张量 random_tensor = torch.randn(2, 3) # 标准正态分布 eye_tensor = torch.eye(3) # 单位矩阵 print(f"零张量:\n{zeros_tensor}") print(f"随机张量:\n{random_tensor}") # 张量形状操作 original = torch.randn(2, 4) reshaped = original.reshape(4, 2) # 改变形状 flattened = original.flatten() # 展平 transposed = original.T # 转置 print(f"原始形状: {original.shape}") print(f"重塑后: {reshaped.shape}") print(f"展平后: {flattened.shape}")

3.2 张量运算与广播机制

PyTorch 支持丰富的数学运算，并具有类似 NumPy 的广播机制：

# 基本数学运算 a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) add_result = a + b # 逐元素加法 mul_result = a * b # 逐元素乘法 matmul_result = a @ b # 矩阵乘法（点积） print(f"加法: {add_result}") print(f"乘法: {mul_result}") print(f"点积: {matmul_result}") # 广播机制示例 matrix = torch.tensor([[1, 2, 3], [4, 5, 6]]) vector = torch.tensor([10, 20, 30]) # 向量会被广播到与矩阵相同的形状 broadcast_result = matrix + vector print(f"广播加法结果:\n{broadcast_result}") # 归约操作 tensor = torch.tensor([[1, 2, 3], [4, 5, 6]]) sum_all = tensor.sum() # 所有元素求和 sum_dim0 = tensor.sum(dim=0) # 沿第0维求和（列方向） mean_dim1 = tensor.mean(dim=1) # 沿第1维求平均（行方向） print(f"全局求和: {sum_all}") print(f"列方向求和: {sum_dim0}") print(f"行方向平均: {mean_dim1}")

3.3 自动微分实战：线性回归

通过一个完整的线性回归示例理解自动微分的工作流程：

import torch import matplotlib.pyplot as plt # 生成模拟数据 torch.manual_seed(42) # 设置随机种子保证可重复性 x = torch.linspace(0, 10, 100).reshape(-1, 1) true_w, true_b = 2.5, 1.0 y = true_w * x + true_b + torch.randn(x.size()) * 2 # 添加噪声 # 定义模型参数（需要梯度跟踪） w = torch.randn(1, requires_grad=True) b = torch.randn(1, requires_grad=True) # 训练参数 learning_rate = 0.01 epochs = 1000 # 训练过程 losses = [] for epoch in range(epochs): # 前向传播 y_pred = w * x + b loss = ((y_pred - y) ** 2).mean() # 均方误差 # 反向传播 loss.backward() # 梯度下降（不跟踪梯度操作） with torch.no_grad(): w -= learning_rate * w.grad b -= learning_rate * b.grad # 清零梯度 w.grad.zero_() b.grad.zero_() losses.append(loss.item()) if epoch % 100 == 0: print(f'Epoch {epoch}, Loss: {loss.item():.4f}') print(f'训练完成: w = {w.item():.3f}, b = {b.item():.3f}') print(f'真实值: w = {true_w}, b = {true_b}') # 可视化结果 plt.figure(figsize=(12, 4)) plt.subplot(1, 2, 1) plt.scatter(x.numpy(), y.numpy(), alpha=0.7, label='数据点') plt.plot(x.numpy(), (w.item() * x + b.item()).detach().numpy(), 'r-', label='拟合直线', linewidth=2) plt.xlabel('x') plt.ylabel('y') plt.legend() plt.title('线性回归拟合结果') plt.subplot(1, 2, 2) plt.plot(losses) plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('训练损失下降曲线') plt.tight_layout() plt.show()

这个示例完整展示了 PyTorch 训练流程的关键步骤：前向计算、损失计算、反向传播、参数更新。

4. 神经网络模块与模型构建

4.1 使用 nn.Module 构建自定义网络

torch.nn.Module是所有神经网络模块的基类，提供了模块化构建网络的能力：

import torch import torch.nn as nn import torch.nn.functional as F class SimpleNN(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(SimpleNN, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) # 全连接层1 self.fc2 = nn.Linear(hidden_size, hidden_size) # 全连接层2 self.fc3 = nn.Linear(hidden_size, output_size) # 输出层 self.dropout = nn.Dropout(0.2) # Dropout 层 def forward(self, x): x = F.relu(self.fc1(x)) # 激活函数 x = self.dropout(x) # Dropout 正则化 x = F.relu(self.fc2(x)) x = self.fc3(x) return x # 实例化模型 model = SimpleNN(input_size=784, hidden_size=128, output_size=10) print(model) # 查看模型参数 for name, param in model.named_parameters(): print(f"{name}: {param.shape}")

4.2 常用神经网络层详解

PyTorch 提供了丰富的神经网络层，适应不同的任务需求：

# 卷积层示例（用于图像处理） conv_layer = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1) # 循环层示例（用于序列数据） lstm_layer = nn.LSTM(input_size=100, hidden_size=256, num_layers=2, batch_first=True) # 归一化层 batch_norm = nn.BatchNorm2d(64) # 批归一化 layer_norm = nn.LayerNorm(128) # 层归一化 # 池化层 max_pool = nn.MaxPool2d(kernel_size=2, stride=2) # 最大池化 avg_pool = nn.AdaptiveAvgPool2d((1, 1)) # 自适应平均池化 # 测试卷积层 input_image = torch.randn(32, 3, 224, 224) # 批量大小32, 3通道, 224x224 output = conv_layer(input_image) print(f"卷积输入形状: {input_image.shape}") print(f"卷积输出形状: {output.shape}")

4.3 损失函数与优化器选择

不同的任务需要匹配相应的损失函数和优化器：

# 常用损失函数 criterion_classification = nn.CrossEntropyLoss() # 多分类问题 criterion_regression = nn.MSELoss() # 回归问题 criterion_binary = nn.BCEWithLogitsLoss() # 二分类问题 # 常用优化器 optimizer_sgd = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) optimizer_adam = torch.optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999)) optimizer_rmsprop = torch.optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99) # 学习率调度器 scheduler_step = torch.optim.lr_scheduler.StepLR(optimizer_adam, step_size=30, gamma=0.1) scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer_adam, T_max=100)

4.4 完整训练流程实现

下面是一个完整的图像分类训练示例：

import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset from sklearn.datasets import load_digits from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler import numpy as np # 准备数据（手写数字识别） digits = load_digits() X, y = digits.data, digits.target # 数据预处理 scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # 划分训练测试集 X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, test_size=0.2, random_state=42, stratify=y ) # 转换为 PyTorch 张量 X_train_tensor = torch.FloatTensor(X_train) y_train_tensor = torch.LongTensor(y_train) X_test_tensor = torch.FloatTensor(X_test) y_test_tensor = torch.LongTensor(y_test) # 创建数据加载器 train_dataset = TensorDataset(X_train_tensor, y_train_tensor) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) # 定义模型 class DigitClassifier(nn.Module): def __init__(self, input_size, hidden_size, num_classes): super(DigitClassifier, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size // 2) self.fc3 = nn.Linear(hidden_size // 2, num_classes) self.dropout = nn.Dropout(0.3) self.bn1 = nn.BatchNorm1d(hidden_size) self.bn2 = nn.BatchNorm1d(hidden_size // 2) def forward(self, x): x = F.relu(self.bn1(self.fc1(x))) x = self.dropout(x) x = F.relu(self.bn2(self.fc2(x))) x = self.fc3(x) return x model = DigitClassifier(input_size=64, hidden_size=128, num_classes=10) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 训练循环 def train_model(model, train_loader, criterion, optimizer, epochs=100): model.train() train_losses = [] train_accuracies = [] for epoch in range(epochs): running_loss = 0.0 correct = 0 total = 0 for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() # 前向传播 output = model(data) loss = criterion(output, target) # 反向传播 loss.backward() optimizer.step() # 统计信息 running_loss += loss.item() _, predicted = torch.max(output.data, 1) total += target.size(0) correct += (predicted == target).sum().item() epoch_loss = running_loss / len(train_loader) epoch_accuracy = 100 * correct / total train_losses.append(epoch_loss) train_accuracies.append(epoch_accuracy) if epoch % 20 == 0: print(f'Epoch {epoch}/{epochs}, Loss: {epoch_loss:.4f}, Accuracy: {epoch_accuracy:.2f}%') return train_losses, train_accuracies # 执行训练 losses, accuracies = train_model(model, train_loader, criterion, optimizer, epochs=100) # 模型评估 def evaluate_model(model, X_test, y_test): model.eval() with torch.no_grad(): outputs = model(X_test) _, predicted = torch.max(outputs, 1) accuracy = (predicted == y_test).sum().item() / y_test.size(0) * 100 return accuracy test_accuracy = evaluate_model(model, X_test_tensor, y_test_tensor) print(f'测试集准确率: {test_accuracy:.2f}%')

5. 数据集处理与模型验证

5.1 自定义数据集类

PyTorch 的Dataset和DataLoader类提供了高效的数据处理管道：

from torch.utils.data import Dataset, DataLoader from PIL import Image import os import pandas as pd class CustomImageDataset(Dataset): def __init__(self, annotations_file, img_dir, transform=None): """ 自定义数据集类 Args: annotations_file: 标注文件路径 img_dir: 图像目录路径 transform: 数据预处理变换 """ self.img_labels = pd.read_csv(annotations_file) self.img_dir = img_dir self.transform = transform def __len__(self): return len(self.img_labels) def __getitem__(self, idx): img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0]) image = Image.open(img_path) label = self.img_labels.iloc[idx, 1] if self.transform: image = self.transform(image) return image, label # 数据增强变换 from torchvision import transforms train_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(0.5), transforms.RandomRotation(10), transforms.ColorJitter(brightness=0.2, contrast=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

5.2 交叉验证与模型选择

对于小数据集，交叉验证是评估模型性能的重要方法：

from sklearn.model_selection import KFold import numpy as np def cross_validation(model_class, X, y, n_splits=5, epochs=50): kfold = KFold(n_splits=n_splits, shuffle=True, random_state=42) fold_accuracies = [] for fold, (train_idx, val_idx) in enumerate(kfold.split(X)): print(f'Fold {fold + 1}/{n_splits}') # 划分训练验证集 X_train, X_val = X[train_idx], X[val_idx] y_train, y_val = y[train_idx], y[val_idx] # 转换为张量 X_train_tensor = torch.FloatTensor(X_train) y_train_tensor = torch.LongTensor(y_train) X_val_tensor = torch.FloatTensor(X_val) y_val_tensor = torch.LongTensor(y_val) # 创建数据加载器 train_dataset = TensorDataset(X_train_tensor, y_train_tensor) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) # 初始化模型和优化器 model = model_class(input_size=64, hidden_size=128, num_classes=10) optimizer = optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() # 训练模型 for epoch in range(epochs): model.train() for data, target in train_loader: optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() # 验证模型 model.eval() with torch.no_grad(): val_output = model(X_val_tensor) _, predicted = torch.max(val_output, 1) accuracy = (predicted == y_val_tensor).sum().item() / len(val_idx) * 100 fold_accuracies.append(accuracy) print(f'Fold {fold + 1} 准确率: {accuracy:.2f}%') print(f'平均准确率: {np.mean(fold_accuracies):.2f}% ± {np.std(fold_accuracies):.2f}%') return fold_accuracies # 执行交叉验证 accuracies = cross_validation(DigitClassifier, X_scaled, y)

5.3 模型保存与加载

正确的模型保存和加载对于项目持久化至关重要：

# 保存整个模型 torch.save(model, 'complete_model.pth') # 只保存模型参数（推荐方式） torch.save(model.state_dict(), 'model_weights.pth') # 保存检查点（包含优化器状态等） checkpoint = { 'epoch': 100, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'loss': losses[-1], 'accuracy': accuracies[-1] } torch.save(checkpoint, 'checkpoint.pth') # 加载模型 # 方式1：加载完整模型 loaded_model = torch.load('complete_model.pth') # 方式2：加载参数到模型结构 model = DigitClassifier(input_size=64, hidden_size=128, num_classes=10) model.load_state_dict(torch.load('model_weights.pth')) model.eval() # 设置为评估模式 # 方式3：从检查点恢复训练 checkpoint = torch.load('checkpoint.pth') model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) start_epoch = checkpoint['epoch']

注意：保存模型时要注意 PyTorch 版本兼容性。不同版本的 PyTorch 保存的模型可能无法互相加载。

6. 高级特性与性能优化

6.1 GPU 加速与多 GPU 训练

充分利用 GPU 可以大幅提升训练速度：

# 检查 GPU 可用性 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'使用设备: {device}') # 将模型和数据移动到 GPU model = model.to(device) # 多 GPU 数据并行 if torch.cuda.device_count() > 1: print(f'使用 {torch.cuda.device_count()} 个 GPU') model = nn.DataParallel(model) # 自定义训练循环中的设备移动 def train_with_gpu(model, train_loader, criterion, optimizer, device): 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() # 内存优化技巧 torch.cuda.empty_cache() # 清空 GPU 缓存 # 梯度累积（模拟大批次训练） accumulation_steps = 4 for i, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) output = model(data) loss = criterion(output, target) / accumulation_steps loss.backward() if (i + 1) % accumulation_steps == 0: optimizer.step() optimizer.zero_grad()

6.2 混合精度训练

混合精度训练可以显著减少显存占用并提升训练速度：

from torch.cuda.amp import autocast, GradScaler # 初始化梯度缩放器 scaler = GradScaler() def train_with_amp(model, train_loader, criterion, optimizer, device): model.train() for data, target in train_loader: data, target = data.to(device), target.to(device) optimizer.zero_grad() # 使用自动混合精度 with autocast(): output = model(data) loss = criterion(output, target) # 缩放损失并反向传播 scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

6.3 模型推理优化

生产环境中需要考虑模型的推理性能：

# 模型量化（降低精度减少模型大小） model_quantized = torch.quantization.quantize_dynamic( model, {nn.Linear}, dtype=torch.qint8 ) # TorchScript 优化（提高推理速度） model.eval() example_input = torch.randn(1, 64) traced_script_module = torch.jit.trace(model, example_input) traced_script_module.save("traced_model.pt") # ONNX 导出（跨框架部署） dummy_input = torch.randn(1, 64) torch.onnx.export(model, dummy_input, "model.onnx", input_names=['input'], output_names=['output'], dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}})

7. 常见问题与解决方案

7.1 梯度相关问题排查

梯度问题是训练过程中最常见的难点：

# 梯度裁剪示例 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # 检查梯度流 def check_gradients(model): for name, param in model.named_parameters(): if param.grad is not None: grad_mean = param.grad.abs().mean().item() print(f'{name}: 梯度均值 = {grad_mean:.6f}') else: print(f'{name}: 梯度为 None') # 在训练循环中调用 check_gradients(model)

7.2 内存管理优化

显存不足是 GPU 训练中的常见问题：

# 监控 GPU 内存使用 def monitor_gpu_memory(): if torch.cuda.is_available(): allocated = torch.cuda.memory_allocated() / 1024**3 # GB cached = torch.cuda.memory_reserved() / 1024**3 # GB print(f'已分配显存: {allocated:.2f} GB') print(f'缓存显存: {cached:.2f} GB') # 减少批大小 # 使用梯度累积 # 使用混合精度训练 # 及时释放不需要的张量 del tensor # 删除大张量 torch.cuda.empty_cache() # 清空缓存

7.3 调试技巧与最佳实践

有效的调试可以节省大量开发时间：

# 使用 torch.autograd.gradcheck 验证梯度计算 from torch.autograd import gradcheck input = torch.randn(2, 3, dtype=torch.double, requires_grad=True) test = gradcheck(lambda x: x**2, input, eps=1e-6, atol=1e-4) print(f'梯度检查: {test}') # 使用钩子监控中间层输出 def hook_fn(module, input, output): print(f'{module.__class__.__name__} 输出形状: {output.shape}') # 注册钩子 handle = model.fc1.register_forward_hook(hook_fn) # 执行前向传播后移除钩子 output = model(torch.randn(1, 64)) handle.remove()

通过系统学习 PyTorch 的核心概念、实践方法和调试技巧，您已经建立了坚实的深度学习开发基础。实际项目中最重要的不是记住所有 API，而是理解框架的设计哲学和问题解决思路。建议从小的项目开始，逐步积累经验，在解决真实问题的过程中深化对 PyTorch 的理解。