自训练VGGNet模型完整应用教程（基于PyTorch）

VGGNet作为2014年ImageNet图像识别竞赛的亚军模型，是深度卷积神经网络（CNN）发展史上的里程碑之作。它以“小卷积核+深层堆叠”的核心设计，彻底奠定了现代CNN的网络架构逻辑——通过重复使用3×3小卷积核，既提升了特征提取的精细度，又降低了模型参数复杂度，相比AlexNet，VGGNet的特征提取能力更强、泛化性能更优，是新手进阶深度学习、掌握深层CNN训练的绝佳案例。

不同于直接调用预训练VGGNet模型，自训练VGGNet能让我们亲手拆解深层CNN的核心逻辑：从卷积层的堆叠设计、池化层的下采样作用，到全连接层的特征映射，再到正则化手段的优化应用，全程实操落地，既能夯实CNN基础，也能灵活适配各类自定义图像分类场景（如猫狗识别、果蔬分类、场景识别等）。

本教程基于PyTorch框架（新手最易上手的深度学习框架），全程手把手实操，从环境搭建、数据集准备，到模型构建、训练调优，再到模型测试与应用，每一步都附详细代码和注释，精准避开新手常见踩坑点。即使是零基础，也能跟着完成整个自训练流程，最终得到一个能实际用于图像分类的VGGNet模型。

核心亮点：无需复杂理论储备，聚焦实操落地；代码可直接复制运行，关键步骤附原理解析；适配Windows/macOS/Linux三大系统；针对VGGNet深层特性优化训练策略，解决深层模型过拟合、梯度消失等常见问题，提升训练成功率。

一、前期准备：环境搭建与工具储备

自训练VGGNet的环境依赖与AlexNet类似，核心依赖PyTorch框架、图像处理工具和数值计算库，全程用Python实现，步骤简单，新手可直接照搬，无需额外配置复杂依赖。

1.1 必备环境清单（新手直接照配）

确保电脑安装以下工具/库，版本建议与下文一致，避免版本兼容问题（VGGNet对环境版本兼容性要求低于AlexNet，无需过度纠结版本细节）：

Python：3.8~3.10（过高版本可能导致部分库不兼容，推荐3.9，可从官网https://www.python.org/下载）；
PyTorch：1.11.0~2.0.0（本教程用1.12.1，支持CPU/GPU加速，GPU需配置CUDA，训练速度比CPU快5~10倍）；
核心库：torchvision（处理图像数据，核心依赖）、numpy（数值计算）、PIL（图像读取）、tqdm（训练进度显示）、matplotlib（结果可视化）；
开发工具：PyCharm（推荐，新手友好，可直接运行代码、查看报错）或VS Code（需配置Python环境）。

1.2 环境搭建步骤（全程命令行操作）

打开电脑命令行（Windows用CMD，macOS/Linux用终端），依次执行以下命令，快速完成环境搭建，全程无需手动配置其他依赖：

安装Python（已安装可跳过）：官网下载对应版本（https://www.python.org/），勾选“Add Python to PATH”，一路下一步即可完成安装，安装后可通过“python --version”命令验证；
安装PyTorch（关键步骤，新手优先选CPU版本）： - CPU版本（无独立显卡，新手首选，无需额外配置）： pip install torch==1.12.1+cpu torchvision==0.13.1+cpu torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cpu - GPU版本（有独立显卡，训练速度更快）：需先安装对应版本的CUDA（参考PyTorch官网，根据自己的显卡型号选择），再执行对应命令；
安装其他核心库（一次性安装，避免遗漏）： pip install numpy==1.24.3 pillow==9.5.0 tqdm==4.65.0 matplotlib==3.7.1

验证环境：打开Python终端，输入import torch和import torchvision，若无报错，说明环境搭建成功；若出现“ImportError”，重新执行对应库的安装命令即可。

二、数据集准备：自定义数据集（以猫狗分类为例）

VGGNet的核心应用场景是图像分类，自训练需准备“带标签的图像数据集”。本教程以经典的“猫狗分类”为例（新手易上手、数据集易获取），也可替换为自己的数据集（如果蔬、动物、场景分类等），步骤完全通用，仅需修改类别数和数据集路径。

2.1 数据集获取与结构整理

1. 数据集获取：可下载Kaggle猫狗数据集（免费、规模适中，适合新手训练），链接：https://www.kaggle.com/c/dogs-vs-cats/data，提取训练集（train文件夹）即可，包含5000张猫图片和5000张狗图片，无需额外标注；

2. 数据集结构：VGGNet要求数据集按“类别分文件夹”存放，这是PyTorch读取数据的标准格式，也是避免训练报错的关键，整理后结构如下（必按此格式，否则无法正常读取数据）：

data/ ├─ train/ # 训练集（占80%数据，用于模型训练） │ ├─ cat/ # 猫类别，存放所有猫图片（约4000张） │ │ ├─ cat001.jpg │ │ ├─ cat002.jpg │ │ └─ ... │ └─ dog/ # 狗类别，存放所有狗图片（约4000张） │ ├─ dog001.jpg │ ├─ dog002.jpg │ └─ ... └─ val/ # 验证集（占20%数据，用于验证模型性能） ├─ cat/ # 猫类别，从训练集中随机抽取20%（约1000张） └─ dog/ # 狗类别，从训练集中随机抽取20%（约1000张）

3. 数据拆分：手动拆分繁琐且易出错，推荐用代码拆分，高效且避免重复，代码如下（直接复制运行，修改路径为自己的数据集路径即可）：

import os import shutil import random # 1. 设置路径（修改为你自己的数据集路径，不要遗漏后缀） origin_path = "E:/data/train" # 原始数据集路径（Kaggle下载的train文件夹） target_path = "E:/data" # 拆分后的数据存放路径 # 2. 创建训练集、验证集文件夹（自动创建，无需手动新建） os.makedirs(os.path.join(target_path, "train", "cat"), exist_ok=True) os.makedirs(os.path.join(target_path, "train", "dog"), exist_ok=True) os.makedirs(os.path.join(target_path, "val", "cat"), exist_ok=True) os.makedirs(os.path.join(target_path, "val", "dog"), exist_ok=True) # 3. 拆分比例（训练集80%，验证集20%，新手无需修改） split_rate = 0.8 # 4. 拆分猫图片（随机打乱，保证数据随机性） cat_files = [f for f in os.listdir(os.path.join(origin_path)) if "cat" in f] random.shuffle(cat_files) # 打乱图片顺序，避免数据分布不均 train_cat = cat_files[:int(len(cat_files)*split_rate)] # 训练集猫图片 val_cat = cat_files[int(len(cat_files)*split_rate):] # 验证集猫图片 # 移动猫图片到对应文件夹 for file in train_cat: shutil.move(os.path.join(origin_path, file), os.path.join(target_path, "train", "cat", file)) for file in val_cat: shutil.move(os.path.join(origin_path, file), os.path.join(target_path, "val", "cat", file)) # 5. 拆分狗图片（与猫图片拆分逻辑一致） dog_files = [f for f in os.listdir(os.path.join(origin_path)) if "dog" in f] random.shuffle(dog_files) train_dog = dog_files[:int(len(dog_files)*split_rate)] val_dog = dog_files[int(len(dog_files)*split_rate):] # 移动狗图片到对应文件夹 for file in train_dog: shutil.move(os.path.join(origin_path, file), os.path.join(target_path, "train", "dog", file)) for file in val_dog: shutil.move(os.path.join(origin_path, file), os.path.join(target_path, "val", "dog", file)) print("数据集拆分完成！训练集8000张，验证集2000张")

2.2 数据预处理（VGGNet必备步骤）

VGGNet对输入图像有明确要求：输入尺寸为224×224×3（RGB彩色图像），这是与AlexNet（227×227）的核心区别之一；同时，由于VGGNet层数更深，更容易出现过拟合，因此需要加强数据增强，提升模型泛化能力。借助torchvision的Transforms工具，可快速完成预处理，代码如下：

import torchvision.transforms as transforms from torchvision.datasets import ImageFolder from torch.utils.data import DataLoader import os # 1. 定义预处理策略（训练集增强，验证集不增强，避免数据泄露） train_transform = transforms.Compose([ transforms.Resize((224, 224)), # 缩放为VGGNet要求的224×224（核心区别） transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转，增强数据多样性 transforms.RandomRotation(15), # 随机旋转15度，提升模型对图像偏移的容忍度 transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), # 颜色抖动，模拟不同光照 transforms.RandomCrop(224, padding=4), # 随机裁剪，进一步增强泛化能力（VGGNet重点优化） transforms.ToTensor(), # 转换为Tensor（PyTorch训练必备格式） transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # 标准化，VGGNet官方参数 ]) val_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]) ]) # 2. 读取数据集（按之前整理的路径，修改为自己的路径） data_dir = "E:/data" # 数据集根路径 train_dataset = ImageFolder(root=os.path.join(data_dir, "train"), transform=train_transform) val_dataset = ImageFolder(root=os.path.join(data_dir, "val"), transform=val_transform) # 3. 创建数据加载器（批量读取数据，提升训练效率，适配VGGNet深层特性） batch_size = 16 # 批次大小：CPU建议设16（避免内存不足），GPU建议设32/64 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=0) # 验证数据集读取是否成功（新手必做，避免后续训练报错） print(f"训练集规模：{len(train_dataset)}张图片，类别：{train_dataset.classes}") # 应输出8000张，类别['cat','dog'] print(f"验证集规模：{len(val_dataset)}张图片") # 应输出2000张

关键说明：1. 输入尺寸必须为224×224，这是VGGNet的标准输入，若改为其他尺寸，会导致模型报错；2. 数据增强仅用于训练集，目的是模拟不同场景下的图像，让模型学习更全面的特征，避免深层模型过拟合；3. 标准化使用VGGNet官方参数，能加快模型收敛，减少训练时间。

三、核心步骤：构建VGGNet模型（还原论文经典结构）

VGGNet的核心特点是“小卷积核+深层堆叠”，论文中提出了VGG11、VGG13、VGG16、VGG19四种架构（数字代表可训练层总数），其中VGG16最常用、性价比最高——既保留了深层模型的特征提取能力，又不会因层数过多导致训练困难，适合新手入门。本教程将构建VGG16模型，还原论文经典结构，同时简化冗余逻辑，适配单GPU/CPU训练。

3.1 VGG16模型结构解析（新手必懂）

VGG16包含16层可训练层（13个卷积层+3个全连接层），外加5个最大池化层，无局部响应归一化层（LRN，与AlexNet的核心区别），整体分为“特征提取部分”和“分类部分”，各层结构及核心作用如下：

特征提取部分（13个卷积层+5个最大池化层）：通过堆叠3×3小卷积核，逐步提取图像的浅层、中层、深层特征，每3~4个卷积层后跟随1个最大池化层，实现下采样（降低特征图尺寸，减少参数）； - 卷积层：均使用3×3卷积核、1步长、1填充，输出通道数从64逐步增加到512（逐步提升特征提取能力）； - 最大池化层：均使用2×2池化核、2步长，非重叠池化，目的是保留关键特征，降低计算量。
分类部分（3个全连接层）：将卷积提取的特征图拉平为一维向量，通过全连接层映射到类别概率，同时加入Dropout正则化，抑制过拟合； - 全连接层1：输入为7×7×512（最后一个池化层输出尺寸），输出4096； - 全连接层2：输入4096，输出4096； - 全连接层3：输入4096，输出类别数（本教程为2类，猫狗分类）； - Dropout：仅应用在2个全连接层，以0.5概率丢弃神经元，解决深层模型过拟合问题。
激活函数：所有卷积层和全连接层后均使用ReLU激活函数，公式f(x)=max(0,x)，解决深层模型的梯度消失问题，加快训练速度。

3.2 用PyTorch构建VGG16模型（完整代码）

代码完全还原VGG16论文结构，加入详细注释，新手可直接复制使用，无需修改核心参数；若需适配多类别分类，仅需修改num_classes参数即可：

import torch import torch.nn as nn class VGG16(nn.Module): def __init__(self, num_classes=2): # num_classes=2（猫狗分类），多类别可修改 super(VGG16, self).__init__() # 特征提取部分：13个卷积层 + 5个最大池化层 self.features = nn.Sequential( # 第一组：2个卷积层 + 1个最大池化层（输出通道64） nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1), # 3×3卷积，输入3通道，输出64通道 nn.ReLU(inplace=True), # ReLU激活，inplace=True节省内存 nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # 2×2池化，步长2，下采样 # 第二组：2个卷积层 + 1个最大池化层（输出通道128） nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # 第三组：3个卷积层 + 1个最大池化层（输出通道256） nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # 第四组：3个卷积层 + 1个最大池化层（输出通道512） nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # 第五组：3个卷积层 + 1个最大池化层（输出通道512） nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), ) # 分类部分：3个全连接层 + Dropout self.classifier = nn.Sequential( # 全连接层1：输入7×7×512，输出4096 nn.Linear(512 * 7 * 7, 4096), nn.ReLU(inplace=True), nn.Dropout(p=0.5), # Dropout概率0.5，抑制过拟合 # 全连接层2：输入4096，输出4096 nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(p=0.5), # 全连接层3：输入4096，输出类别数 nn.Linear(4096, num_classes), ) # 前向传播（模型推理/训练的核心逻辑，新手无需修改） def forward(self, x): x = self.features(x) # 特征提取：输入224×224×3，输出512×7×7 x = x.view(x.size(0), 512 * 7 * 7) # 拉平特征图：(batch_size, 512*7*7) x = self.classifier(x) # 分类预测：输出类别概率 return x # 验证模型是否构建成功（新手必做，避免后续训练报错） model = VGG16(num_classes=2) print(model) # 输出模型结构，确认无报错 # 检查输入输出尺寸（输入224×224×3，输出2类概率） x = torch.randn(1, 3, 224, 224) # 模拟1张RGB图像（batch_size=1） output = model(x) print(f"输入尺寸：{x.shape}，输出尺寸：{output.shape}") # 应输出：输出尺寸：torch.Size([1, 2])

关键说明：1. 若需适配多类别分类（如3类果蔬、10类动物），只需修改num_classes参数（如num_classes=3）即可；2. 模型结构已简化双GPU并行逻辑，单GPU/CPU均可正常运行；3. 特征提取部分的输出尺寸为512×7×7，拉平后为512×7×7=25088，与全连接层1的输入一致，不可随意修改卷积层、池化层参数。

四、模型训练：全流程实操（核心步骤）

VGG16层数更深、参数更多（约1.38亿参数，是AlexNet的8倍左右），训练难度略高于AlexNet，因此需优化训练策略：加入早停机制（避免过拟合）、学习率调度（解决梯度消失）、权重衰减（抑制过拟合），新手只需按步骤运行代码，无需手动调整过多参数，全程自动完成训练。

4.1 训练参数配置（新手默认即可）

import torch.optim as optim from tqdm import tqdm import matplotlib.pyplot as plt # 1. 设备选择（优先GPU，无GPU自动用CPU，新手无需修改） device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = model.to(device) # 将模型转移到对应设备（CPU/GPU） # 2. 损失函数（交叉熵损失，适合分类任务，VGGNet通用） criterion = nn.CrossEntropyLoss() # 3. 优化器（SGD+动量+权重衰减，解决VGG16过拟合和梯度消失问题） optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.0005) # 4. 学习率调度器（训练后期降低学习率，加快收敛，避免震荡） lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5) # 每10轮学习率减半 # 5. 训练参数（新手默认即可，可根据电脑性能调整） epochs = 30 # 训练轮次：CPU建议30轮，GPU建议50轮（提升准确率） best_val_acc = 0.0 # 记录最佳验证准确率（用于早停和模型保存） early_stopping_patience = 5 # 早停机制：连续5轮验证准确率不提升则停止训练 no_improve_count = 0 # 记录验证准确率未提升的轮次 # 6. 记录训练过程（用于后续可视化，查看训练效果） train_loss_history = [] val_loss_history = [] train_acc_history = [] val_acc_history = []

4.2 训练核心代码（全程自动运行）

代码包含训练、验证、早停、模型保存等逻辑，直接复制运行即可，训练过程中会用tqdm显示实时进度、损失值和准确率，新手可直观查看训练状态：

for epoch in range(epochs): # ---------------------- 训练阶段 ---------------------- model.train() # 切换为训练模式（启用Dropout，更新参数） train_loss = 0.0 train_correct = 0 total_train = 0 # 用tqdm显示训练进度（直观查看每一步训练状态） train_bar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs} (Train)") for images, labels in train_bar: # 将数据转移到对应设备（CPU/GPU，避免数据与模型设备不匹配） images, labels = images.to(device), labels.to(device) # 前向传播：计算模型输出（预测类别概率） outputs = model(images) # 计算损失（预测值与真实标签的差距） loss = criterion(outputs, labels) # 反向传播+参数更新（核心步骤，模型学习的关键） optimizer.zero_grad() # 清空梯度（避免梯度累积，导致参数更新异常） loss.backward() # 反向传播，计算梯度 optimizer.step() # 更新模型参数 # 统计训练损失和准确率（用于后续可视化） train_loss += loss.item() * images.size(0) _, predicted = torch.max(outputs.data, 1) # 取预测概率最大的类别 total_train += labels.size(0) train_correct += (predicted == labels).sum().item() # 更新进度条显示（实时查看当前损失和准确率） train_bar.set_postfix({"loss": loss.item(), "acc": train_correct/total_train}) # 计算本轮训练的平均损失和准确率 train_avg_loss = train_loss / len(train_loader.dataset) train_acc = train_correct / total_train train_loss_history.append(train_avg_loss) train_acc_history.append(train_acc) # ---------------------- 验证阶段 ---------------------- model.eval() # 切换为验证模式（禁用Dropout，固定参数，不更新） val_loss = 0.0 val_correct = 0 total_val = 0 with torch.no_grad(): # 禁用梯度计算，节省内存和时间（验证阶段无需更新参数） val_bar = tqdm(val_loader, desc=f"Epoch {epoch+1}/{epochs} (Val)") for images, labels in val_bar: images, labels = images.to(device), labels.to(device) outputs = model(images) loss = criterion(outputs, labels) # 统计验证损失和准确率 val_loss += loss.item() * images.size(0) _, predicted = torch.max(outputs.data, 1) total_val += labels.size(0) val_correct += (predicted == labels).sum().item() # 更新进度条显示 val_bar.set_postfix({"loss": loss.item(), "acc": val_correct/total_val}) # 计算本轮验证的平均损失和准确率 val_avg_loss = val_loss / len(val_loader.dataset) val_acc = val_correct / total_val val_loss_history.append(val_avg_loss) val_acc_history.append(val_acc) # 学习率调度（每10轮降低一次学习率，加快收敛） lr_scheduler.step() # ---------------------- 早停机制（避免过拟合） ---------------------- if val_acc > best_val_acc: best_val_acc = val_acc no_improve_count = 0 # 保存最佳模型（避免训练完成后找不到最优模型，后续应用直接加载） torch.save(model.state_dict(), "vgg16_best.pth") print(f"Epoch {epoch+1}: 验证准确率提升至 {best_val_acc:.4f}，保存最佳模型！") else: no_improve_count += 1 print(f"Epoch {epoch+1}: 验证准确率未提升，当前最佳准确率：{best_val_acc:.4f}") if no_improve_count >= early_stopping_patience: print(f"连续{early_stopping_patience}轮验证准确率未提升，触发早停！") break # 停止训练，避免过拟合 # 打印本轮训练/验证结果（直观查看训练效果） print(f"Epoch {epoch+1} | 训练损失：{train_avg_loss:.4f}，训练准确率：{train_acc:.4f}") print(f"Epoch {epoch+1} | 验证损失：{val_avg_loss:.4f}，验证准确率：{val_acc:.4f}\n") print("训练完成！最佳模型已保存为vgg16_best.pth")

4.3 训练关键说明（新手必看，避坑重点）

训练时间：VGG16参数更多，训练时间比AlexNet长——CPU（普通电脑）每轮约10~15分钟，30轮约5~8小时；GPU（独立显卡）每轮约2~3分钟，30轮约1~2小时；
内存占用：CPU训练时，若出现“内存不足”报错，将batch_size改为8；GPU训练时，若出现“CUDA out of memory”报错，将batch_size改为16；
过拟合判断：若训练准确率持续上升，而验证准确率下降，说明出现过拟合，可增加数据增强手段、提高Dropout概率（改为0.6），或提前早停；
模型保存：训练完成后，最佳模型会保存为“vgg16_best.pth”，后续应用直接加载该模型即可，无需重新训练；
参数调整：若训练准确率过低（如低于75%），可增加训练轮次（改为50轮）、调整学习率（改为0.0005），或增加数据集规模。

五、训练结果可视化与模型测试

训练完成后，通过可视化训练/验证损失、准确率，可直观判断模型训练效果（是否过拟合、是否收敛）；同时加载最佳模型，对新图像进行测试，验证模型的实际应用能力，确保模型能正常用于分类任务。

5.1 训练结果可视化（代码自动生成图表）

运行以下代码，自动生成损失曲线和准确率曲线，直观查看训练效果，新手无需修改代码，直接复制运行即可：

# 绘制损失曲线和准确率曲线（尺寸适配，便于查看） plt.figure(figsize=(12, 4)) # 1. 损失曲线（查看模型是否收敛） plt.subplot(1, 2, 1) plt.plot(range(len(train_loss_history)), train_loss_history, label="Train Loss", color="red") plt.plot(range(len(val_loss_history)), val_loss_history, label="Val Loss", color="blue") plt.xlabel("Epoch") plt.ylabel("Loss") plt.title("Training vs Validation Loss (VGG16)") plt.legend() # 显示图例 # 2. 准确率曲线（查看模型分类能力） plt.subplot(1, 2, 2) plt.plot(range(len(train_acc_history)), train_acc_history, label="Train Acc", color="red") plt.plot(range(len(val_acc_history)), val_acc_history, label="Val Acc", color="blue") plt.xlabel("Epoch") plt.ylabel("Accuracy") plt.title("Training vs Validation Accuracy (VGG16)") plt.legend() # 保存图表（可在当前文件夹查看，便于后续分析） plt.savefig("vgg16_training_result.png", dpi=300, bbox_inches="tight") plt.show() # 打印最佳训练结果（直观查看模型性能） print(f"最佳验证准确率：{best_val_acc:.4f}")

正常效果：训练损失和验证损失逐步下降，最终趋于平稳；训练准确率和验证准确率逐步上升，差距不大（若差距过大，说明过拟合，需调整参数）。对于猫狗分类任务，VGG16的验证准确率通常能达到85%以上，优于AlexNet。

5.2 模型测试（用新图像验证，实际应用）

加载保存的最佳模型，对任意一张猫/狗图片进行预测，验证模型的实际分类能力，代码如下（修改测试图片路径即可，新手可直接复制运行）：

from PIL import Image import torchvision.transforms as transforms # 1. 加载最佳模型（新手无需修改核心代码，仅修改num_classes） model = VGG16(num_classes=2) model.load_state_dict(torch.load("vgg16_best.pth")) # 加载保存的模型参数 model.to(device) model.eval() # 切换为验证模式（禁用Dropout，确保预测稳定） # 2. 定义图像预处理（与验证集一致，避免数据格式不匹配） 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]) ]) # 3. 测试单张图片（修改为你自己的测试图片路径，猫/狗均可） test_image_path = "E:/test_dog.jpg" # 测试图片路径（示例） image = Image.open(test_image_path).convert("RGB") # 读取图片并转换为RGB（避免灰度图报错） image_tensor = test_transform(image).unsqueeze(0) # 增加batch维度（模型要求输入为4维） image_tensor = image_tensor.to(device) # 4. 模型预测（禁用梯度计算，节省内存） with torch.no_grad(): output = model(image_tensor) _, predicted = torch.max(output.data, 1) # 取预测概率最大的类别 # 5. 输出预测结果（直观查看分类效果） classes = ["cat", "dog"] # 与数据集类别顺序一致，不可修改 predicted_class = classes[predicted.item()] print(f"测试图片预测结果：{predicted_class}") # 可选：显示测试图片和预测结果（直观查看，新手可运行） plt.imshow(image) plt.title(f"Predicted: {predicted_class}") plt.axis("off") # 隐藏坐标轴 plt.show()

测试说明：1. 测试图片需为JPG/PNG格式，若出现“PIL.UnidentifiedImageError”，删除损坏图片或转换格式；2. 若预测结果与图片实际类别一致，说明模型训练成功；若预测错误，可检查图片是否清晰、是否属于数据集涵盖的类别，或调整模型参数重新训练。

六、常见问题排查（新手避坑指南）

自训练VGG16的过程中，新手容易遇到各种报错，以下是最常见的问题及解决方案，快速帮你解决困扰，避免耽误训练进度：

6.1 环境类问题

报错“ImportError: No module named 'torch'”：未安装PyTorch，重新执行环境搭建步骤中的PyTorch安装命令，确保命令输入正确；
报错“CUDA out of memory”：GPU显存不足，降低batch_size（改为16或8），或切换为CPU训练；
报错“PIL.UnidentifiedImageError”：图片损坏或格式不支持，删除损坏图片，确保所有图片为JPG/PNG格式，避免灰度图、模糊图。

6.2 训练类问题

训练损失不下降、准确率一直很低（低于50%）：检查数据集路径是否正确、类别文件夹是否命名为“cat”和“dog”；检查模型输入尺寸是否为224×224；
过拟合（训练准确率高，验证准确率低）：增加数据增强手段（如随机裁剪、随机翻转）、提高Dropout概率（改为0.6）、提前早停，或增加数据集规模；
训练过程中报错“RuntimeError: expected scalar type Float but found Double”：确保图像已通过ToTensor()转换为Float类型，无需额外转换；
训练速度极慢：确认是否使用GPU训练，若使用CPU，可降低batch_size（改为8），或减少训练轮次。

6.3 测试类问题

加载模型报错“KeyError: 'module.conv1.weight'”：模型保存和加载时的类别数不一致，确保加载模型时的num_classes与训练时一致；
预测结果一直为同一类别：模型未训练充分，增加训练轮次；或数据集类别分布不均衡，调整数据集比例（确保两类图片数量相近）；
报错“RuntimeError: input size mismatch”：测试图片预处理尺寸与训练时不一致，确保test_transform中的Resize参数为(224, 224)。

七、总结与扩展：自训练VGGNet的应用场景与进阶方向

本教程完成了自训练VGG16模型的全流程实操，从环境搭建到模型测试，全程贴合新手需求，通过猫狗分类案例，让大家掌握了VGGNet的核心原理和实操技巧。VGGNet作为深层CNN的经典模型，其“小卷积核+深层堆叠”的设计思想，为后续学习ResNet、Inception等更复杂的深度学习模型奠定了基础，是新手进阶深度学习的必经之路。

1. 应用场景扩展

自训练的VGG16模型可灵活适配各类图像分类场景，只需修改数据集和类别数即可，实用性极强：

果蔬分类：数据集替换为苹果、香蕉、橙子等果蔬图片，num_classes设为对应类别数（如3类、5类）；
场景分类：数据集替换为室内、室外、城市、乡村等场景图片，实现场景自动识别；
工业缺陷检测：数据集替换为产品缺陷、正常产品图片，实现工业产品缺陷自动识别；
人脸分类：数据集替换为人脸图片，实现人脸身份识别（需增加数据集规模）。

2. 进阶方向（提升模型性能）

若想进一步提升VGG16的准确率，或学习更高级的训练技巧，可尝试以下优化方向：

优化数据增强：增加随机透视变换、随机翻转、高斯模糊等手段，提升模型泛化能力；
调整优化器：将SGD改为Adam优化器，收敛速度更快，适合小数据集，减少训练时间；
迁移学习：基于预训练VGG16模型进行微调，减少训练数据量，提升准确率（尤其适合小数据集场景）；
特征图可视化：查看模型各层提取的特征，分析模型学习效果，针对性调整参数；
批量归一化（BN）：在卷积层后加入BN层，解决深层模型梯度消失问题，加快训练收敛。

自训练VGGNet的核心价值，不仅是得到一个可用的模型，更是通过亲手实操，理解深层CNN的核心逻辑——如何通过卷积层堆叠提取特征、如何通过正则化手段抑制过拟合、如何通过优化器加快收敛。跟着本教程一步步操作，相信你能快速掌握深层CNN的训练技巧，为后续学习更复杂的深度学习模型打下坚实基础。如果在实操过程中遇到问题，可对照常见问题排查，或留言交流，祝你训练顺利！