PyTorch统一训练模板：CNN与ViT图像分类模型工程化实战

学深度学习图像分类，最容易遇到的一个坑不是模型看不懂，而是每个模型对应一套独立的训练代码。上周还在用 torchvision 读 AlexNet，这周导师让换成 ResNet，网上找到的代码数据预处理是一套写法，训练循环又是另一种封装，能跑通但换个数据集就报错。你以为时间花在研究模型差异上，实际上全消耗在对齐数据、改训练逻辑、调试维度不匹配这些重复劳动里。

更扎心的是，模型定义本身通常只有几十行，真正的工程工作——数据管线、训练循环、验证与保存、部署导出——才是占据 80% 工作量的部分。把这部分做成一份统一模板，让 AlexNet、VGG、ResNet、ViT 共用同一条数据管道和同一个训练入口，才是从入门走向工程化的关键一步。

这篇文章会给你一份可直接运行的代码模板：用模型注册表统一创建四个模型，用同一套数据加载、训练、验证、保存逻辑，最后给出 ONNX 部署导出的通用路径。读完你可以把它当脚手架，替换成自己的数据集和网络结构，不必每个新模型都重新造轮子。文中代码基于 PyTorch 编写，整体思路与框架无关，TensorFlow 用户同样可以借鉴。

1. 先看清问题：为什么训练代码比模型定义更容易拖垮你

很多初学者误以为“读懂网络结构就能写训练代码”。实际上，一个分类任务的完整训练流程由以下部分组成：

• 数据读取与预处理（resize、归一化、增强策略）
• 模型实例化与权重初始化
• 损失函数、优化器、学习率调度器配置
• 训练循环（前向、反向、梯度更新、日志输出）
• 验证逻辑（关闭梯度、计算准确率）
• 模型保存与加载
• 部署导出（ONNX、TensorRT 等）

模型的网络结构只是其中一环，而且是最容易复用的一环。因为 torchvision 等库已经帮你实现了主流分类网络的完整定义，你需要改的往往只是最后的分类头。真正的差异集中在数据管线、训练策略和验证方式上——这些恰恰是网上代码质量最参差不齐的地方。

如果再叠加另一个现实因素：AlexNet 输入是 227×227，VGG 是 224×224，ResNet 和 ViT 也有各自的预处理习惯。每个模型对应一种数据增强组合，手写多个独立脚本必然是灾难。统一模板的价值就在这里：模型可以换，数据管线只有一份，训练验证循环只有一份，命令行参数切换即可。换模型从“改代码”变成“改参数”。

2. 四个模型的核心原理与演进脉络

要真正用好模板，得先理解这四个模型在解决什么问题，以及它们的特征表达方式有什么不同。这里不打算展开到论文逐行推导，而是抓住每个模型最关键的创新点。

2.1 CNN 的基本组件

卷积神经网络（CNN）的核心思想是用卷积核在图像上滑动，提取局部特征。卷积层负责特征提取，池化层负责下采样压缩空间尺寸，全连接层负责在最后做分类决策。相比全连接网络直接铺平成向量，CNN 保留了图像的二维空间结构，参数量也大幅减少。

2.2 AlexNet：深度学习登场的开山之作

AlexNet 在 2012 年 ImageNet 竞赛以巨大优势夺冠，让深度学习从此成为视觉领域的主流路线。它的核心贡献是：使用 ReLU 激活函数缓解梯度消失，使用 Dropout 抑制过拟合，并通过两块 GPU 并行训练来支撑更大的网络容量。结构上，它由 5 个卷积层和 3 个全连接层组成，输入尺寸为 227×227。

从今天的视角看，AlexNet 的结构不算复杂，但它证明了“更深更大的网络 + GPU 训练 + 正则化技巧”这套组合的威力。学习它的意义在于理解现代 CNN 的骨架雏形。

2.3 VGG：用 3×3 卷积把“深”做到极致

VGG 的核心判断很朴素：用多个 3×3 小卷积核堆叠，替代一个大的卷积核。两个 3×3 卷积的感受野等于一个 5×5 卷积，但参数量更少，且中间多了一次非线性变换，表达能力更强。VGG16 和 VGG19 在相当长一段时间里是特征提取的默认选择。

VGG 的问题也很明显：全连接层参数量巨大，一个 VGG16 的模型文件超过 500MB，训练和部署成本都不低。模板中保留它，是为了让你对比“结构简单直接”和“参数冗余严重”这两个工程现实。

2.4 ResNet：残差连接解决退化问题

按理说网络越深效果越好，但实验发现，当网络深到一定程度后，训练误差反而上升，这就是“退化问题”。ResNet 给出的解法是残差连接：让每个块学习输入与输出之间的残差，即输出 = 输入 + 卷积变换结果。

这个设计的物理意义很直接：即使新增的层没有学到有效特征，它至少可以学成恒等映射，让深层网络的性能不低于浅层网络。同时，跳跃连接让梯度可以更顺畅地回传到浅层，缓解了梯度消失。ResNet 让网络可以安全地堆到 50 层、101 层甚至更深，是 CNN 发展史上的关键转折。如今你看到的 ResNet18、ResNet50 几乎成了视觉任务的默认底座。

2.5 ViT：从 CNN 换成自注意力的路线切换

Vision Transformer（ViT）在 2020 年提出，把 NLP 领域的 Transformer 结构直接搬到图像上。做法是把图像切成固定大小的 patch，例如 16×16，每个 patch 展平后映射为 token 向量，再加上位置编码表示空间位置，最后送入 Transformer Encoder 用自注意力建模全局关系。

ViT 的特别之处在于，它一开始就没有依赖卷积的局部归纳偏置，而是完全靠数据学习哪些区域需要交互。代价是需要大量训练数据，在 ImageNet 这种规模的数据集上，ViT 才能发挥出超越 ResNet 的能力。如果数据量不够，ViT 的效果往往不如同规模的 CNN。

2.6 特征粒度视角：粗粒度与细粒度的不同处理方式

理解这四个模型，还可以从“特征粒度”的角度切入。CNN 的特征是逐层抽象的：浅层卷积感受野小，学到的是边缘、纹理这类细粒度特征；深层卷积感受野大，学到的是物体部件、语义类别这类粗粒度特征。ResNet 的残差连接还有一个隐性作用——保留浅层的细粒度细节，避免深层抽象过程中信息过度丢失。

ViT 的粒度逻辑完全不同。patch embedding 直接把图像切成 16×16 的块，每个 token 天然就是“粗粒度的局部区域”，自注意力再让这些 token 全局交互。它缺少了 CNN 那种逐层从细到粗的渐变过程。因此在实际项目中，检测任务常借助特征金字塔结构，例如 FPN，把高层粗粒度语义特征和低层细粒度位置特征融合使用；Transformer 模型也会额外设计多尺度模块来补足细粒度信息。位置编码则是 ViT 里补偿空间信息的关键手段——自注意力本身是不感知顺序的，没有位置编码，模型无法知道 patch 来自图像的哪个区域。

表格总结四个模型的核心差异：

3. 环境准备与实验约定

开始写代码前，先统一环境。本模板使用 PyTorch，因为它同时覆盖了模型库、数据加载和训练生态，是目前学习成本最低的深度学习框架。

3.1 版本与依赖

推荐环境如下：

• Python 3.8 及以上
• PyTorch 2.x（1.13 也可运行，新版 API 兼容性更好）
• torchvision（需与 PyTorch 版本匹配，用于加载 CIFAR-10 和预置模型）
• CUDA GPU 可选，没有 GPU 也能运行，只是训练时间会明显变长

安装命令：

pip install torch torchvision

如果需要 GPU 版本，请前往 PyTorch 官网根据你的 CUDA 版本生成安装命令。这里不写死具体命令，是因为不同机器的 CUDA 环境差异较大，写错反而会装不上。

3.2 数据集与目录组织

模板使用 CIFAR-10 作为演示数据集，原因是：它足够小，下载快，交叉验证方便，而且能直接验证数据管线是否正确。运行代码时，torchvision 会自动下载到本地，无需手工准备。

建议的项目目录结构如下：

image-classification-template/ ├── models.py # 模型注册表与模型工厂 ├── train.py # 统一训练脚本 ├── export_onnx.py # 部署导出脚本 ├── data/ # 数据集目录，自动创建 └── checkpoints/ # 模型权重保存目录，自动创建

把代码拆成独立文件，而不是把所有内容堆在一个脚本里，是为了后续扩展更舒服。模型、训练、导出各自的修改不会互相影响。

4. 统一训练模板的设计与实现

这一节是文章的核心。先把模板的整体设计讲清楚，再给出完整代码。设计上采用“模型注册表 + 统一训练循环”的模式，这是中小型项目里性价比最高的架构。

4.1 模型注册表：用一份代码管理多个模型

模型注册表的思路很简单：用一个字典保存模型名称和对应构建函数的映射关系，新增模型时只需要注册一个新函数，主程序不需要修改。

# 文件路径：models.py import torch.nn as nn import torchvision.models as models MODEL_REGISTRY = {} def register_model(name): def decorator(builder): MODEL_REGISTRY[name] = builder return builder return decorator @register_model("alexnet") def build_alexnet(num_classes): model = models.alexnet(weights=None) # AlexNet 最后一个分类层是 classifier[6] model.classifier[6] = nn.Linear(4096, num_classes) return model @register_model("vgg16") def build_vgg16(num_classes): model = models.vgg16(weights=None) model.classifier[6] = nn.Linear(4096, num_classes) return model @register_model("resnet18") def build_resnet18(num_classes): model = models.resnet18(weights=None) # ResNet 的分类头属性名为 fc model.fc = nn.Linear(model.fc.in_features, num_classes) return model @register_model("vit") def build_vit(num_classes): model = models.vit_b_16(weights=None) # 不同 torchvision 版本中 ViT 分类头属性名可能有差异 # 不确定时先 print(model) 查看结构，再决定替换哪一层 model.heads.head = nn.Linear(model.heads.head.in_features, num_classes) return model def build_model(name, num_classes=10): if name not in MODEL_REGISTRY: raise ValueError( f"Unsupported model: {name}, available: {list(MODEL_REGISTRY.keys())}" ) return MODEL_REGISTRY[name](num_classes)

这里需要注意一个现实问题：不同 torchvision 版本里，模型的分类头属性名并不完全相同。ResNet 是fc，AlexNet 和 VGG 是classifier[6]，ViT 在多数新版本里是heads.head。如果你使用的版本不同，运行后会报维度不匹配错误，此时先打印模型结构，再定位需要替换的分类层即可。这就是“注册表模式”的优势——问题被隔离在构建函数内部，不会污染训练代码。

4.2 数据加载：训练集与验证集的 transform 策略

训练集和验证集的数据处理策略必须不同。训练集需要随机裁剪、随机翻转等数据增强，验证集只需要统一 resize 和中心裁剪，保证评测结果稳定可复现。两者共享同一套 Normalize 参数，这是 ImageNet 预训练的标准均值标准差。

# 文件路径：train.py（第一部分，数据加载） import argparse import os import time import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision import datasets, transforms from models import build_model def get_transform(resize_size=224, train=True): if train: return transforms.Compose([ transforms.RandomResizedCrop(resize_size), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ]) return transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(resize_size), transforms.ToTensor(), transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ]) def load_data(batch_size=64, data_dir="./data"): train_ds = datasets.CIFAR10( root=data_dir, train=True, download=True, transform=get_transform(train=True), ) val_ds = datasets.CIFAR10( root=data_dir, train=False, download=True, transform=get_transform(train=False), ) train_loader = DataLoader( train_ds, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True, ) val_loader = DataLoader( val_ds, batch_size=batch_size, shuffle=False, num_workers=4, pin_memory=True, ) return train_loader, val_loader

CIFAR-10 原始图片尺寸是 32×32，而这里统一 resize 到 224×224，是为了让四个模型的输入尺寸保持一致。代价是训练速度变慢，但可以避免因输入尺寸不同带来的各种维度错误。如果你只想快速验证代码，可以把resize_size改成 64 或 128，模板依然能运行，只是精度会有变化。

4.3 训练循环与验证逻辑

训练循环是所有模型共用的，包含前向传播、计算损失、反向传播、参数更新四个步骤。验证时关闭梯度，只统计损失和准确率，防止 BatchNorm 等层的行为被验证过程影响。

# 文件路径：train.py（第二部分，训练与验证） def train_one_epoch(model, loader, criterion, optimizer, device): model.train() total_loss, correct, total = 0.0, 0, 0 for images, labels in loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() total_loss += loss.item() * images.size(0) _, preds = torch.max(outputs, 1) correct += (preds == labels).sum().item() total += labels.size(0) return total_loss / total, correct / total @torch.no_grad() def evaluate(model, loader, criterion, device): model.eval() total_loss, correct, total = 0.0, 0, 0 for images, labels in loader: images, labels = images.to(device), labels.to(device) outputs = model(images) loss = criterion(outputs, labels) total_loss += loss.item() * images.size(0) _, preds = torch.max(outputs, 1) correct += (preds == labels).sum().item() total += labels.size(0) return total_loss / total, correct / total

小技巧：@torch.no_grad()装饰器告诉 PyTorch 不需要在验证阶段构建计算图，可以显著减少显存占用和验证时间。新手最容易犯的错误是验证时忘记model.eval()，导致 Dropout 和 BatchNorm 的行为与训练状态不一致，验证精度出现异常波动。

4.4 命令行入口

主函数设计成命令行工具，通过参数控制模型类型、训练轮数、学习率等。这样切换模型不需要改代码，也方便做超参数对比实验。

# 文件路径：train.py（第三部分，主程序） def main(): parser = argparse.ArgumentParser() parser.add_argument( "--model", type=str, default="resnet18", choices=["alexnet", "vgg16", "resnet18", "vit"], ) parser.add_argument("--epochs", type=int, default=20) parser.add_argument("--batch-size", type=int, default=64) parser.add_argument("--lr", type=float, default=1e-3) parser.add_argument("--data-dir", type=str, default="./data") parser.add_argument("--ckpt-dir", type=str, default="./checkpoints") parser.add_argument( "--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", ) args = parser.parse_args() os.makedirs(args.ckpt_dir, exist_ok=True) device = torch.device(args.device) train_loader, val_loader = load_data(args.batch_size, args.data_dir) model = build_model(args.model, num_classes=10).to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.AdamW( model.parameters(), lr=args.lr, weight_decay=5e-4, ) scheduler = optim.lr_scheduler.CosineAnnealingLR( optimizer, T_max=args.epochs, ) best_acc = 0.0 for epoch in range(1, args.epochs + 1): start = time.time() train_loss, train_acc = train_one_epoch( model, train_loader, criterion, optimizer, device, ) val_loss, val_acc = evaluate( model, val_loader, criterion, device, ) scheduler.step() elapsed = time.time() - start print( f"Epoch [{epoch:03d}/{args.epochs}] " f"train_loss={train_loss:.4f} train_acc={train_acc * 100:.2f}% " f"val_loss={val_loss:.4f} val_acc={val_acc * 100:.2f}% " f"time={elapsed:.1f}s" ) if val_acc > best_acc: best_acc = val_acc torch.save( model.state_dict(), os.path.join(args.ckpt_dir, f"best_{args.model}.pth"), ) print(f"Best val_acc: {best_acc * 100:.2f}%") if __name__ == "__main__": main()

这里有几个细节值得解释。优化器选择 AdamW 而不是 Adam，因为 AdamW 将权重衰减从动量项中解耦，是目前 Transformer 类模型的默认选择，同时也能兼容 CNN，不需要为不同模型更换优化器。学习率调度使用 CosineAnnealingLR，让学习率按余弦曲线从初始值下降至接近 0，是一种简单且稳健的策略。保存模型时只保存state_dict而非整个模型对象，这样文件更小，且加载时不依赖模型类的定义位置。

5. 将四个模型接入统一模板

模板写好后，四个模型的接入过程其实已经在模型注册表中完成了。这里再逐个拆解，方便你理解每个模型需要修改哪些部分，以后换自己的网络时也能按同样的思路接入。

5.1 AlexNet 的接入

AlexNet 在 torchvision 中由features卷积段和classifier全连接段组成。我们只替换最后一层classifier[6]，把 4096 维映射到分类数。如果你新增的模型是自研网络，直接在models.py里新增一个@register_model("mynet")装饰的构建函数即可，训练主程序完全不用动。

5.2 VGG 的接入

VGG 和 AlexNet 的分类头结构类似，替换方式相同。值得一提的是 torchvision 的vgg16默认使用 BatchNorm 版本（真正的名称是vgg16_bn），而vgg16是不带 BatchNorm 的原始版本。建议你对比跑一下两个版本，观察 BatchNorm 对收敛速度和最终精度的影响，这是一个很有价值的小实验。

5.3 ResNet 的接入

ResNet 的分类头是fc，单层线性层。替换时使用model.fc.in_features获取输入维度，而不是硬编码 512 或 2048。不同深度的 ResNet 最后的特征维度不同，ResNet18 是 512，ResNet50 是 2048。用in_features自适应获取，代码就不会因为换了模型深度而报错。

5.4 ViT 的接入与 Patch Embedding 原理

ViT 的分类头在 torchvision 新版本中位于model.heads.head。如果你运行时报错找不到该属性，大概率是版本差异，先打印模型结构再替换。

理解 ViT 的关键在于 Patch Embedding。下面这段代码展示了 ViT 如何把图像切成 patch 并生成 token 序列，这是 ViT 和 CNN 最本质的区别：

# 简化版 PatchEmbedding，用于理解 ViT 的输入处理 import torch import torch.nn as nn class PatchEmbedding(nn.Module): def __init__(self, in_channels=3, embed_dim=768, patch_size=16, num_patches=196): super().__init__() # 一个 stride=patch_size 的卷积，等价于切 patch 并映射成向量 self.proj = nn.Conv2d( in_channels, embed_dim, kernel_size=patch_size, stride=patch_size, ) # 分类 token，用来汇总全局信息 self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) # 位置编码，补偿自注意力不感知顺序的问题 self.pos_embed = nn.Parameter( torch.zeros(1, num_patches + 1, embed_dim) ) def forward(self, x): # 输入 x: [B, 3, 224, 224] x = self.proj(x) # 输出 [B, embed_dim, 14, 14] x = x.flatten(2).transpose(1, 2) # 输出 [B, 196, embed_dim] # 拼接 cls_token，序列变为 197 个 token x = torch.cat([self.cls_token.expand(x.size(0), -1, -1), x], dim=1) # 加入位置编码 x = x + self.pos_embed return x

224×224 的图像，patch_size=16，切分后是 14×14=196 个 patch。每个 patch 展平映射成 embed_dim（例如 768）维向量，组成长度为 196 的 token 序列，再加一个分类 token，总共 197 个 token 输入 Transformer Encoder。位置编码是这里最容易被忽略的部分——自注意力本身不包含顺序信息，没有位置编码，模型无法知道 token 之间的空间位置关系。

5.5 进阶：使用预训练权重做迁移学习

上面的模板默认weights=None，也就是随机初始化。这种做法的优点是代码简单、不受下载预训练权重的时间影响，缺点是在小数据集上收敛慢、精度低。实际工程项目中更推荐加载 ImageNet 预训练权重，再做迁移学习。只需把构建函数里的weights=None改成weights=models.ResNet18_Weights.IMAGENET1K_V1即可，其他代码完全不动。迁移学习通常只需要原来十分之一到五分之一的学习率，数据增强可以更加激进。

6. 运行、验证与效果判断

代码写完后，接下来要解决的问题是：怎么运行、怎么判断训练是否正常、效果差应该从哪里开始调。

6.1 训练命令

切换模型只需要修改--model参数：

# 训练 ResNet18 python train.py --model resnet18 --epochs 20 --batch-size 64 # 训练 AlexNet python train.py --model alexnet --epochs 20 --batch-size 64 # 训练 ViT（CPU 上会很慢，建议有 GPU 再运行） python train.py --model vit --epochs 20 --batch-size 32 --lr 5e-4

第一次运行会自动下载 CIFAR-10 数据集，时间取决于网络。之后再次运行会直接读取本地文件，不会重复下载。

6.2 预期输出与日志解读

正常训练时，终端会逐轮输出类似下面的日志：

Epoch [001/020] train_loss=1.8342 train_acc=37.25% val_loss=1.7214 val_acc=46.11% time=12.3s Epoch [002/020] train_loss=1.4217 train_acc=49.83% val_loss=1.5862 val_acc=54.34% time=12.1s Epoch [003/020] train_loss=1.2184 train_acc=57.02% val_loss=1.4517 val_acc=58.79% time=12.2s

不要过多关注具体数值，因为随机初始化训练 CIFAR-10 的精度受多种因素影响。你需要关注的是趋势：train_loss 是否持续下降，train_acc 和 val_acc 是否同步上升。只要符合这个趋势，就说明模型正在正常学习。

6.3 如何判断是否正常收敛

判断标准有三条：

• 训练损失稳定下降，没有出现大幅震荡。
• 验证准确率随训练轮数逐渐上升，而不是长时间在原地徘徊。
• 训练集准确率和验证集准确率的差距没有越拉越大。如果两者差距过大，说明过拟合已经开始，需要增加正则化手段或数据增强。

随机初始化在 CIFAR-10 上训练 20 轮，精度会明显低于 ImageNet 预训练迁移的效果，这是正常现象。要追求更高精度，最有效的做法是加载预训练权重，而不是盲目增加训练轮数。

6.4 训练变慢或精度异常的调整方向

如果训练过程明显偏慢，优先检查是否真的在使用 GPU。在train.py中，--device默认自动选择 CUDA，如果显存不足或 CUDA 不可用，会自动回退到 CPU。你可以手动指定--device cuda确认 GPU 是否参与计算，并通过nvidia-smi查看显存占用。

如果精度长期不提升，按照这个顺序排查：先确认数据预处理是否和模型匹配，例如训练集和验证集 transform 是否一致；再看学习率是否过大或过小，AdamW 默认学习率 1e-3 对大多数 CNN 可用，ViT 通常需要更低的学习率；最后检查损失函数是否正确，单标签多分类统一使用 CrossEntropyLoss，它内部已包含 Softmax，不要在模型输出层再手动加 Softmax，否则梯度计算会出问题。

7. 常见问题与排查方法

下面是这个模板运行过程中最常遇到的问题，均以表格形式整理，方便收藏后对照排查。

这里特别提醒一个容易忽略的点：调试时优先使用小数据集和小模型。先用resnet18跑通流程，再切换成vit，不要一上来就在大模型上报错后同时排查数据和代码，这样效率极低。把“先跑通，再跑好”作为固定习惯，能省下大量排查时间。

8. 从训练到部署的工程建议

训练只是模型生命周期的一部分。真正的生产环境还需要完成导出、验证、部署和监控。这一节给出从 PyTorch 模型导出到 ONNX 的完整流程，以及部署端必须注意的工程细节。

8.1 导出 ONNX 的通用流程

ONNX 是开放神经网络交换格式，可以让 PyTorch、TensorFlow 等多个框架的模型在统一的中间表示上运行，是目前部署最通用的模型格式之一。导出代码只需在训练好的权重上执行一次前向，PyTorch 会记录计算图并转换为 ONNX。

# 文件路径：export_onnx.py import torch from models import build_model model = build_model("resnet18", num_classes=10) model.load_state_dict( torch.load("checkpoints/best_resnet18.pth", map_location="cpu") ) model.eval() dummy_input = torch.randn(1, 3, 224, 224) torch.onnx.export( model, dummy_input, "resnet18.onnx", input_names=["input"], output_names=["output"], dynamic_axes={ "input": {0: "batch"}, "output": {0: "batch"}, }, opset_version=17, ) print("ONNX export done")

dynamic_axes定义了动态维度。上面把 batch 维标记为动态，意味着推理时一次可以输入 1 张图片，也可以输入 32 张图片，模型结构不会变化。如果不设置动态轴，导出的模型会固定 batch 大小为 1，部署灵活性会大大降低。

8.2 部署端注意事项

ONNX 文件导出后，强烈建议先在本地加载并验证输出是否与 PyTorch 原模型一致，再做上线操作。验证方法是：准备同一张输入图片，分别用 PyTorch 和 ONNX Runtime 推理，比较输出结果。推理框架如 ONNX Runtime 和 TensorRT 在算子支持上有差异，个别网络层可能转换失败，务必在实际部署环境完整测试一遍。

部署端另一个高频踩坑点是输入预处理不一致。训练阶段使用 Resize(256) + CenterCrop(224) + Normalize 的统计量，这些参数必须完整复刻到部署代码里。很多线上模型效果偏差，不是模型训练有问题，而是部署端的图片预处理与训练时不一致，导致输入分布漂移。

8.3 工程规范与安全提醒

以下几条是生产环境的基本要求：

• 模型文件纳入版本管理，记录训练参数、数据版本和评估指标，方便回溯。
• 权重文件要备份，保存时建议同时保存state_dict和训练超参数配置文件，便于复现。
• 在测试集上评估后再导出，不要只看验证集指标，防止验证集上过拟合。
• 涉及敏感数据或生产系统时，遵循最小权限原则，模型服务使用独立账号和受限环境运行。
• 使用预训练权重前，检查模型许可证是否符合你的业务场景，尤其是商业用途。

9. 总结与后续学习方向

这份模板解决的核心问题，是把训练流程从“人肉适配每个模型”变成“注册模型 + 统一训练”，让模型转换的成本降到一个命令行参数。四个模型的接入过程也反过来帮助你理解它们的本质差异：AlexNet 确立 CNN 的骨架，VGG 验证小卷积核堆叠的思路，ResNet 用残差连接让深度成为优势，ViT 则用自注意力跳出卷积的局部假设，走向全局建模。

接下来建议你做三件事。第一，用这份模板对自己的数据集跑通一次完整流程，不要停留在复制代码；第二，重点研究 ResNet 的残差块和 ViT 的注意力机制，它们代表了两种完全不同的特征表达范式；第三，把 ONNX 导出加入工作流，在部署环境里完整验证一遍输入输出一致性。建议收藏这份模板备用，后面做分类、迁移学习、模型对比实验都用得上。