企业官网建设流程全解析

1. 从零手搓一个PyTorch项目：一个老手的完整避坑指南

搞深度学习这几年，PyTorch几乎成了我每天都要打交道的工具。但说实话，我见过太多人——包括几年前的我自己——在环境配置、数据加载、模型训练、显存爆炸这些环节上反复栽跟头。这篇文章不是官方文档的复述，也不是那种“Hello World”级别的入门教程。我想把自己从零搭建一个完整PyTorch项目时踩过的坑、总结的经验、以及那些文档里不会写的细节，一次性讲清楚。

不管你是刚接触深度学习的学生，还是从其他框架转过来的工程师，只要你想用PyTorch做一个真正能跑起来、能复现、能扩展的项目，这篇内容应该能帮你省下不少时间。我会从项目结构设计开始，一路讲到训练调优和问题排查，每个环节都配上我实际用过的代码和参数。全文没有花哨的概念堆砌，只有能直接抄作业的实操方案。

2. 项目结构设计与环境搭建

2.1 为什么你的PyTorch项目需要一个规范目录

很多人写PyTorch代码，习惯把所有东西塞进一个.py文件里——模型定义、数据加载、训练循环、参数配置全混在一起。刚开始跑个小Demo没问题，但一旦项目稍微复杂一点，比如要换数据集、调模型结构、做消融实验，这种写法就会让你痛不欲生。我吃过这个亏：有一次想复现三个月前的一个实验，结果发现连当时用的学习率都找不到了，因为代码里到处是硬编码的数字。

一个规范的PyTorch项目目录应该长这样：

project/ ├── configs/ # 配置文件目录 │ └── default.yaml ├── data/ # 数据集存放 │ └── dataset.py # 数据加载与预处理 ├── models/ # 模型定义 │ └── network.py ├── utils/ # 工具函数 │ ├── logger.py │ └── metrics.py ├── train.py # 训练入口 ├── evaluate.py # 评估入口 ├── requirements.txt # 依赖清单 └── README.md

这个结构的好处在于：配置与代码分离。你把学习率、批次大小、模型层数这些超参数全部写进configs/default.yaml，训练脚本只负责读取配置并执行。这样做的好处是，你随时可以复制一份配置文件改几个参数，就能开启一组新实验，而且实验记录清清楚楚。

注意：不要用Python文件当配置文件。虽然config.py写起来很顺手，但YAML或JSON格式的配置文件更容易被其他工具解析，也方便你做参数扫描。

2.2 环境配置：版本匹配是最大的坑

PyTorch的环境配置有一个铁律：PyTorch版本、CUDA版本、显卡驱动版本，三者必须匹配。我见过太多人在这上面浪费时间——装完PyTorch发现torch.cuda.is_available()返回False，然后开始怀疑人生。

先确认你的显卡驱动支持的最高CUDA版本。在终端输入nvidia-smi，右上角会显示CUDA Version: XX.X。这个版本是你驱动能支持的最高CUDA版本，不是你必须安装的版本。比如显示CUDA Version: 12.4，你可以安装CUDA 11.8、12.1、12.4中的任何一个，只要不超过12.4就行。

然后去PyTorch官网找到对应的安装命令。这里有个经验：不要盲目追求最新版本。最新版PyTorch可能和你的其他依赖（比如某些计算机视觉库）存在兼容问题。我通常选择发布至少三个月以上的稳定版本。比如当前如果最新是2.4，我会优先考虑2.2或2.3。

安装命令示例（CUDA 11.8环境）：

pip install torch==2.2.0 torchvision==0.17.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118

安装完成后，用下面这段代码验证：

import torch print(torch.__version__) print(torch.cuda.is_available()) print(torch.cuda.get_device_name(0))

如果is_available()返回True，恭喜你，最难的一关过了。如果返回False，先检查CUDA版本是否匹配，再检查是否安装了CPU版本的PyTorch（有时候pip会默认装CPU版）。

2.3 依赖管理：requirements.txt的正确写法

很多人写requirements.txt就是一句pip freeze > requirements.txt，这其实是个坏习惯。pip freeze会把所有间接依赖都写进去，导致文件臃肿且难以维护。更好的做法是只写你直接使用的包，并指定版本范围：

torch>=2.0.0,<2.4.0 torchvision>=0.15.0 numpy>=1.24.0 pyyaml>=6.0 tqdm>=4.65.0 tensorboard>=2.13.0

这样写的好处是，别人拿到你的项目后，pip install -r requirements.txt不会因为某个间接依赖的版本冲突而失败。另外，我强烈建议用虚拟环境——conda或venv都行。别在系统Python里直接装PyTorch，否则以后多个项目之间版本打架，你会非常头疼。

3. 数据加载与预处理的核心细节

3.1 Dataset和DataLoader：看似简单，坑最多

PyTorch的Dataset和DataLoader是数据管道的核心。表面上看，你只需要继承Dataset类，实现__len__和__getitem__两个方法就行。但实际用起来，有几个细节直接决定了你的训练效率。

第一个坑是数据加载速度。如果你的__getitem__里做了复杂的图像增强（比如随机裁剪、颜色抖动、旋转），而num_workers又设成了0，那么GPU大部分时间都在等CPU送数据。解决办法很简单：把num_workers设成4或8（根据你的CPU核心数），让多个进程并行加载数据。

from torch.utils.data import DataLoader train_loader = DataLoader( dataset=train_dataset, batch_size=32, shuffle=True, num_workers=8, pin_memory=True, drop_last=True )

这里pin_memory=True的作用是把数据加载到锁页内存中，从而加快CPU到GPU的传输速度。drop_last=True则是丢弃最后一个不完整的批次，避免批次大小不一致导致的训练不稳定。

第二个坑是数据增强的随机性。如果你在__getitem__里用了random.random()，但没有设置随机种子，那么每次运行实验的结果都会不一样。复现实验时，你需要在训练脚本开头固定所有随机种子：

import random import numpy as np import torch def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False

注意，cudnn.deterministic = True会降低一点训练速度，但能保证结果可复现。如果你更在意速度，可以设为False，但就要接受每次结果有微小差异。

3.2 自定义数据集：一个图像分类的完整示例

假设你要做一个图像分类任务，数据集结构是每个类别一个文件夹。下面是我常用的Dataset写法：

import os from PIL import Image from torch.utils.data import Dataset import torchvision.transforms as T class ImageFolderDataset(Dataset): def __init__(self, root_dir, transform=None): self.root_dir = root_dir self.transform = transform self.samples = [] self.classes = sorted(os.listdir(root_dir)) self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)} for cls in self.classes: cls_dir = os.path.join(root_dir, cls) for fname in os.listdir(cls_dir): if fname.lower().endswith(('.jpg', '.jpeg', '.png')): self.samples.append((os.path.join(cls_dir, fname), self.class_to_idx[cls])) def __len__(self): return len(self.samples) def __getitem__(self, idx): img_path, label = self.samples[idx] image = Image.open(img_path).convert('RGB') if self.transform: image = self.transform(image) return image, label

这个写法有几个值得注意的地方。第一，self.samples在初始化时就构建好了，而不是在__getitem__里动态扫描目录，这样能避免每个epoch都做一次文件系统遍历。第二，Image.open之后立刻convert('RGB')，防止有些图片是RGBA或灰度图导致后续transform报错。第三，类别索引用sorted保证顺序一致，否则不同机器上跑出来的类别映射可能不同。

3.3 数据增强策略：别过度，也别偷懒

数据增强是提升模型泛化能力最便宜的手段。但增强策略的选择要看任务。对于自然图像分类，我常用的组合是：

train_transform = T.Compose([ T.RandomResizedCrop(224, scale=(0.8, 1.0)), T.RandomHorizontalFlip(p=0.5), T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

这里的Normalize参数是ImageNet的均值和标准差。如果你用的是预训练模型，必须用这套参数；如果是从零训练，可以用你自己数据集的统计值，但用ImageNet的参数通常也没问题。

注意：验证集和测试集绝对不要做随机增强。验证集只需要Resize、CenterCrop、ToTensor和Normalize。否则你的验证指标会波动很大，无法判断模型是否真的在进步。

还有一个容易忽略的点：RandomResizedCrop的scale参数。如果你的数据集里目标很小（比如遥感图像中的小物体），把scale下限设成0.8会导致目标被裁掉。这种情况下应该用更保守的RandomCrop或者干脆不做裁剪增强。

4. 模型定义与训练循环的实战要点

4.1 模型定义：继承nn.Module的正确姿势

PyTorch定义模型的标准方式是继承nn.Module，在__init__里声明所有层，在forward里定义前向传播。但有几个细节新手经常搞错。

第一，不要在forward里创建层。有些人图省事，在forward里直接写nn.Linear(...)，这样每次前向传播都会重新初始化权重，模型根本学不到东西。所有层必须在__init__里定义好。

第二，参数初始化。PyTorch有默认初始化，但有时候你需要手动干预。比如用Kaiming初始化配合ReLU激活函数：

import torch.nn as nn class SimpleCNN(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(2), ) self.classifier = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(128, num_classes) ) for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.zeros_(m.bias) elif isinstance(m, nn.Linear): nn.init.normal_(m.weight, 0, 0.01) nn.init.zeros_(m.bias) def forward(self, x): x = self.features(x) x = self.classifier(x) return x

AdaptiveAvgPool2d(1)是个很实用的层，它把任意空间尺寸的特征图压缩成1x1，这样你就不需要在forward里手动计算全连接层的输入维度了。换输入图像尺寸时也不用改模型结构。

4.2 训练循环：每个epoch到底该做什么

一个标准的训练循环包含以下步骤：前向传播、计算损失、反向传播、更新参数。但实际写起来，还需要处理学习率调度、梯度裁剪、日志记录、模型保存等事情。下面是我常用的训练循环模板：

def train_one_epoch(model, loader, optimizer, criterion, device, epoch, scaler=None): model.train() total_loss = 0 correct = 0 total = 0 for batch_idx, (images, labels) in enumerate(loader): images, labels = images.to(device), labels.to(device) optimizer.zero_grad() if scaler is not None: with torch.cuda.amp.autocast(): outputs = model(images) loss = criterion(outputs, labels) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() else: outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() total_loss += loss.item() * images.size(0) _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() avg_loss = total_loss / total acc = correct / total return avg_loss, acc

这里有几个关键点。optimizer.zero_grad()必须在loss.backward()之前调用，否则梯度会累加。loss.item()取的是标量值，不会影响计算图。scaler是混合精度训练的工具，后面会详细讲。

4.3 混合精度训练：省显存、提速度的利器

混合精度训练（AMP）是PyTorch 1.6之后引入的功能，它让部分计算用float16，部分用float32，从而减少显存占用并加速训练。用法很简单：

from torch.cuda.amp import GradScaler, autocast scaler = GradScaler() for epoch in range(num_epochs): for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() with autocast(): outputs = model(images) loss = criterion(outputs, labels) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

实测下来，AMP通常能减少30%到50%的显存占用，训练速度提升20%到30%。但要注意，autocast上下文里不要做需要float32精度的操作，比如softmax之后的log运算。另外，GradScaler会自动处理梯度缩放，防止float16下梯度下溢。

注意：如果你用了梯度裁剪，需要在scaler.step()之前先scaler.unscale_(optimizer)，然后再裁剪。顺序错了会导致裁剪失效。

5. 显存优化与性能调优

5.1 显存都去哪了：拆解显存占用的四大块

很多人看到CUDA out of memory就懵了，不知道显存被谁吃了。其实显存主要被四部分占用：模型参数、梯度、优化器状态、中间激活值。以一个ResNet-50为例，参数量约25M，float32下参数占100MB，梯度占100MB，如果用Adam优化器，优化器状态（动量和方差）占200MB。加起来才400MB，但实际训练时显存占用往往超过4GB。多出来的部分就是中间激活值。

中间激活值是前向传播过程中每一层的输出，它们需要保留到反向传播时计算梯度。批次越大、模型越深、特征图越大，激活值占的显存就越多。所以减小批次大小是解决显存不足最直接的方法，但批次太小又会影响BatchNorm的效果和训练稳定性。

5.2 梯度累积：小显存跑大批次

梯度累积的思路很简单：用小的批次跑多次前向和反向，把梯度累加起来，等累积到一定步数后再更新一次参数。这样等效于用大批次训练，但显存占用只取决于小批次。

accumulation_steps = 4 for i, (images, labels) in enumerate(train_loader): images, labels = images.to(device), labels.to(device) with autocast(): outputs = model(images) loss = criterion(outputs, labels) / accumulation_steps scaler.scale(loss).backward() if (i + 1) % accumulation_steps == 0: scaler.step(optimizer) scaler.update() optimizer.zero_grad()

注意loss要除以accumulation_steps，这样累加后的梯度才和真实大批次一致。另外，如果最后一个累积周期不完整，需要在训练循环结束后再执行一次scaler.step()。

5.3 其他省显存的技巧

除了梯度累积和AMP，还有几个实用的省显存方法。梯度检查点（torch.utils.checkpoint）用计算换显存，在前向传播时不保存中间激活值，反向传播时重新计算。适合显存极度紧张的情况，但会增加约30%的训练时间。

及时释放无用张量。Python的垃圾回收机制不会立即释放被引用的张量。如果你在训练循环里保留了某个中间变量（比如outputs），它会一直占着显存。养成习惯：不需要的张量用del删掉，或者用with torch.no_grad()包裹推理代码。

调整批次大小和图像尺寸。这是最直接的。把批次从32降到16，显存占用几乎减半。把输入从224x224降到128x128，激活值显存减少到原来的三分之一左右。

6. 常见问题与排查技巧实录

6.1 损失不下降：从数据到模型的排查清单

损失不下降是新手最常遇到的问题。我一般按以下顺序排查：

我遇到过一次特别隐蔽的情况：数据加载时用了ToTensor()，但没有做Normalize，导致输入像素值在0到1之间，而模型第一层是预训练的，期望输入是标准化后的。加上Normalize之后，损失立刻开始下降。

6.2 过拟合与欠拟合：判断和应对

训练集准确率很高但验证集准确率很低，这是过拟合。应对方法包括：增加数据增强、加Dropout层、加权重衰减、减小模型复杂度、早停。我通常先加数据增强和权重衰减，这两招成本最低。

训练集和验证集准确率都低，这是欠拟合。可能是模型太小、学习率太低、训练轮数不够。先试着把模型加深加宽，或者换用预训练模型微调。

还有一种情况是训练集准确率高、验证集准确率也高，但测试集准确率低。这通常是验证集和测试集分布不一致，或者验证集被“偷看”了太多次，导致你对验证集过拟合。解决办法是保留一个从不用于调参的测试集，只在最后评估时用一次。

6.3 显存溢出：从报错信息定位问题

CUDA out of memory报错通常会告诉你试图分配多少显存、当前已用多少、总共有多少。比如：

RuntimeError: CUDA out of memory. Tried to allocate 2.00 GiB (GPU 0; 11.91 GiB total capacity; 9.50 GiB already allocated; 1.20 GiB free; 9.80 GiB reserved in total by PyTorch)

如果already allocated接近总容量，说明你的模型和批次确实太大了。如果reserved远大于allocated，说明PyTorch缓存了很多未使用的显存，可以用torch.cuda.empty_cache()释放。但注意，empty_cache()只是释放缓存，不会释放正在使用的显存。

还有一个隐蔽的显存泄漏：在验证循环里没有用torch.no_grad()，导致计算图被保留。验证时不需要反向传播，一定要加上：

model.eval() with torch.no_grad(): for images, labels in val_loader: outputs = model(images) # ...

6.4 训练速度慢：从CPU到GPU的瓶颈分析

训练速度慢可能卡在三个地方：数据加载、前向传播、反向传播。先用torch.cuda.synchronize()配合time.time()测一下每个部分的时间。如果数据加载占了大部分时间，就增大num_workers、用pin_memory、把数据预处理提前做好。如果前向和反向慢，就检查是否用了AMP、批次是否太小、模型是否有不必要的计算。

我遇到过一次训练速度突然变慢的情况，排查后发现是num_workers设成了0，而数据增强里用了PIL的旋转操作，单进程根本跑不过来。改成8之后，训练速度直接翻倍。

7. 模型保存、加载与部署衔接

7.1 保存什么：state_dict还是整个模型

PyTorch保存模型有两种方式：保存整个模型对象（torch.save(model, path)）和只保存参数（torch.save(model.state_dict(), path)）。推荐只保存state_dict。原因是保存整个模型会把模型类的定义也序列化进去，如果以后你改了模型代码，加载旧模型就会报错。而state_dict只包含参数张量，与模型代码解耦。

保存时通常还要保存优化器状态和当前epoch，方便恢复训练：

checkpoint = { 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'best_acc': best_acc, } torch.save(checkpoint, f'checkpoint_epoch_{epoch}.pth')

加载时：

checkpoint = torch.load('checkpoint_epoch_10.pth', map_location='cpu') model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) start_epoch = checkpoint['epoch'] + 1

map_location='cpu'很重要。如果你在GPU上保存的模型，在CPU机器上加载时会报错。加上这个参数就能自动映射到CPU。

7.2 推理部署：从训练模式到评估模式

训练完成后，部署推理时要做三件事：model.eval()、torch.no_grad()、把输入数据放到正确的设备上。model.eval()会把Dropout和BatchNorm切换到推理模式，这对结果影响很大。我见过有人忘了加model.eval()，导致推理结果每次都不一样，排查了半天才发现是Dropout在作怪。

model.eval() with torch.no_grad(): for images in test_loader: images = images.to(device) outputs = model(images) probabilities = torch.softmax(outputs, dim=1) _, predicted = probabilities.max(1)

如果要做批量推理，还可以把多个样本拼成一个批次，充分利用GPU并行能力。但要注意批次大小不要超过显存限制。

7.3 模型导出：ONNX格式的注意事项

有时候你需要把PyTorch模型导出成ONNX格式，以便在其他推理引擎上运行。导出时需要提供一个示例输入：

dummy_input = torch.randn(1, 3, 224, 224).to(device) torch.onnx.export( model, dummy_input, 'model.onnx', input_names=['input'], output_names=['output'], dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}, opset_version=11 )

dynamic_axes参数让导出的模型支持动态批次大小。opset_version建议用11或更高，兼容性更好。导出后一定要用ONNX Runtime验证一下输出是否和PyTorch一致，有时候某些算子导出后会有数值差异。

8. 一些让我少走弯路的经验之谈

8.1 日志和可视化：别等出问题才后悔

我从项目一开始就会加上TensorBoard或WandB的日志记录。记录的内容包括：训练损失、验证损失、学习率、梯度范数、每层权重分布。这些信息在排查问题时非常有用。比如梯度范数突然变大，说明可能遇到了梯度爆炸；权重分布逐渐偏向某个值，说明模型可能在退化。

from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter('runs/experiment_1') writer.add_scalar('Loss/train', train_loss, epoch) writer.add_scalar('Loss/val', val_loss, epoch) writer.add_scalar('Accuracy/val', val_acc, epoch) writer.add_histogram('Weights/fc', model.classifier[2].weight, epoch)

8.2 随机种子的正确设置方式

前面提过设置随机种子，但有一个细节：DataLoader的worker_init_fn。当num_workers > 0时，每个worker进程有自己的随机状态，如果不设置，数据增强的随机性在不同worker之间会不一致。解决办法是：

def worker_init_fn(worker_id): np.random.seed(42 + worker_id) random.seed(42 + worker_id) train_loader = DataLoader( dataset, batch_size=32, num_workers=8, worker_init_fn=worker_init_fn )

这样每个worker的随机种子是确定的，实验可复现性大大提升。

8.3 学习率调度：什么时候该降，降多少

学习率调度对最终精度影响很大。我常用的策略是余弦退火配合热重启，或者简单的阶梯下降。以阶梯下降为例：

scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

每30个epoch把学习率乘以0.1。但要注意，scheduler.step()的调用位置。在PyTorch 1.1之后，如果每个epoch调用一次，应该放在epoch循环的末尾，而不是批次循环里。如果每个批次调用一次，则放在批次循环里。搞错了会导致学习率下降过快或过慢。

我个人的经验是：先用一个较大的学习率（比如1e-2）跑几个epoch，观察损失下降情况。如果损失震荡厉害，就降到1e-3；如果损失下降太慢，就升到3e-2。找到合适的初始学习率后，再配合余弦退火慢慢降到1e-6左右。

8.4 多卡训练：DataParallel还是DistributedDataParallel

如果你有多张显卡，可以用nn.DataParallel快速实现多卡训练，只需要一行代码：

model = nn.DataParallel(model)

但DataParallel的效率不高，因为它是单进程多线程，主卡负载重。更好的选择是DistributedDataParallel（DDP），它用多进程，每张卡一个进程，效率更高。但DDP的配置稍复杂，需要设置init_process_group、DistributedSampler等。如果只是做实验，DataParallel够用了；如果要长时间训练大模型，建议直接上DDP。

注意：用DataParallel保存模型时，state_dict的键会多一个module.前缀。加载时需要用model.module.state_dict()或者手动去掉前缀。

8.5 一个容易被忽略的细节：BatchNorm的同步问题

多卡训练时，如果用了DataParallel，每张卡上的BatchNorm是独立计算的，这会导致批次统计量不准确。SyncBatchNorm可以解决这个问题，它会在所有卡之间同步均值和方差。用法：

model = nn.SyncBatchNorm.convert_sync_batchnorm(model) model = nn.parallel.DistributedDataParallel(model)

但SyncBatchNorm只支持DDP，不支持DataParallel。而且它会增加通信开销，小批次下可能得不偿失。

9. 从实验到产品：一些工程化建议

9.1 配置管理：别让超参数散落各处

我见过太多项目把学习率写在训练脚本里、批次大小写在数据加载里、模型层数写在模型定义里。改一个参数要翻三个文件。用argparse或yaml统一管理配置：

import yaml import argparse parser = argparse.ArgumentParser() parser.add_argument('--config', type=str, default='configs/default.yaml') args = parser.parse_args() with open(args.config, 'r') as f: config = yaml.safe_load(f) lr = config['training']['learning_rate'] batch_size = config['training']['batch_size']

这样你可以为每组实验保存一个配置文件，实验记录清晰可查。

9.2 断点续训：训练中断了怎么办

长时间训练最怕中断。除了定期保存checkpoint，还要在训练脚本开头加上恢复逻辑：

if os.path.exists('checkpoint_latest.pth'): checkpoint = torch.load('checkpoint_latest.pth') model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) start_epoch = checkpoint['epoch'] + 1 else: start_epoch = 0

保存checkpoint时，除了按epoch保存，还要保存一个checkpoint_latest.pth，每次覆盖。这样即使训练中断，也能从最近一次恢复。

9.3 代码版本管理：Git和实验记录

用Git管理代码是基本操作，但很多人忽略了实验记录。我建议每次跑实验时，在日志文件里记录当前Git commit hash、配置文件内容、以及关键的超参数。这样以后回头看某个结果时，能准确知道当时用的什么代码和参数。

import subprocess def get_git_hash(): try: return subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD']).decode().strip() except: return 'unknown' git_hash = get_git_hash() writer.add_text('Config/git_hash', git_hash, 0)

这个习惯看起来麻烦，但当你需要复现三个月前的一个实验结果时，会感谢自己当初多写了这几行代码。

9.4 模型版本管理：别用final_v2_真正最终版.pth

模型文件命名是个看似小事但很影响效率的问题。我见过有人用model_final.pth、model_final_v2.pth、model_final_真正最终版.pth这种命名，过两天自己都分不清哪个是哪个。建议用结构化的命名方式：

checkpoints/ ├── resnet50_lr0.01_bs32_epoch50_acc0.923.pth ├── resnet50_lr0.001_bs64_epoch80_acc0.941.pth └── efficientnet_lr0.005_bs32_epoch60_acc0.935.pth

文件名里包含模型结构、学习率、批次大小、训练轮数、验证精度。这样一眼就能看出每个模型的配置和性能，不用打开文件猜。

10. 最后分享几个我常用的调试小技巧

第一个技巧：用一个小批次过拟合。当你怀疑模型或数据有问题时，拿一个批次（比如8张图）反复训练，看损失能不能降到接近0。如果连一个批次都过拟合不了，那肯定是代码有bug，而不是模型不够强。这个技巧帮我定位过无数次问题。

第二个技巧：打印中间张量的形状和范围。在forward里加几行print(x.shape, x.min(), x.max())，能快速发现维度不匹配或数值异常。但记得调试完要删掉，否则训练时刷屏。

第三个技巧：用torch.autograd.set_detect_anomaly(True)定位反向传播中的NaN。如果损失突然变成NaN，加上这行代码，PyTorch会告诉你具体是哪一步产生的NaN。虽然会拖慢训练速度，但排查问题时非常有用。

第四个技巧：验证集指标波动大时，检查BatchNorm的momentum。默认的momentum=0.1在批次较小时可能导致统计量不稳定。可以试着降到0.01，或者改用GroupNorm。

第五个技巧：学习率预热。训练初期用很小的学习率，然后线性增加到设定值，能有效避免初期震荡。特别是用大批次训练时，预热几乎必不可少。PyTorch没有内置的预热调度器，但可以自己写一个简单的：

def warmup_lr(optimizer, warmup_steps, base_lr): def lr_lambda(step): if step < warmup_steps: return step / warmup_steps return 1.0 return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

这些技巧都是我在实际项目中反复验证过的，不一定适用于所有场景，但大多数情况下能帮你少走弯路。PyTorch的生态很丰富，工具也很多，但核心的东西就那么些。把数据管道、训练循环、显存管理这三块吃透，大部分项目都能顺利跑起来。剩下的就是根据具体任务调参和优化了。