### 使用PyTorch和VGG16进行猫狗图像分类 #### 数据准备 为了进行有效的训练，数据集的准备工作至关重要。对于猫狗大战的数据集，共有25000张标记好的猫和狗的图片用于训练，另有12500张未标注的图片作为测试集[^1]。 ```python import os from torchvision import datasets, transforms from torch.utils.data import DataLoader data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } image_datasets = {x: datasets.ImageFolder(os.path.join('path_to_data', x), data_transforms[x]) for x in ['train', 'val']} dataloaders = {x: DataLoader(image_datasets[x], batch_size=32, shuffle=True) for x in ['train', 'val']} dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} class_names = image_datasets['train'].classes ``` 这段代码定义了如何加载和预处理图像数据，确保它们适合喂入到VGG16模型中进行训练[^2]。 #### 加载预训练的VGG16模型 利用PyTorch内置的功能可以轻松获取预训练过的VGG16模型，并对其进行微调以适应特定的任务需求。 ```python import torch.nn as nn import torchvision.models as models model_vgg = models.vgg16(pretrained=True) for param in model_vgg.parameters(): param.requires_grad_(False) num_ftrs = model_vgg.classifier[6].in_features features = list(model_vgg.classifier.children())[:-1] features.extend([nn.Linear(num_ftrs, 2)]) model_vgg.classifier = nn.Sequential(*features) if torch.cuda.is_available(): model_vgg = model_vgg.to('cuda') ``` 上述脚本展示了怎样冻结原始VGG16中的参数，只调整最后一层来匹配当前任务所需的类别数（即两个类：猫和狗），并且将整个模型迁移到GPU上运行以便加速计算过程[^3]。 #### 训练与评估 完成以上设置之后就可以开始正式训练模型了；在此期间还需要定期保存最佳权重以及监控性能指标变化情况。 ```python import torch.optim as optim from torch.autograd import Variable import time criterion = nn.CrossEntropyLoss() optimizer_ft = optim.SGD(model_vgg.classifier.parameters(), lr=0.001, momentum=0.9) def train_model(model, criterion, optimizer, scheduler=None, num_epochs=25): since = time.time() best_model_wts = model.state_dict() best_acc = 0.0 for epoch in range(num_epochs): print(f'Epoch {epoch}/{num_epochs - 1}') print('-' * 10) # Each epoch has a training and validation phase for phase in ['train', 'val']: if phase == 'train': model.train() else: model.eval() running_loss = 0.0 running_corrects = 0 for inputs, labels in dataloaders[phase]: inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) _, preds = torch.max(outputs, 1) loss = criterion(outputs, labels) if phase == 'train': optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / dataset_sizes[phase] epoch_acc = running_corrects.double() / dataset_sizes[phase] print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}') if phase == 'val' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = model.state_dict() print() time_elapsed = time.time() - since print(f'Training complete in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s') print(f'Best val Acc: {best_acc:.4f}') model.load_state_dict(best_model_wts) return model device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model_trained = train_model(model_vgg, criterion, optimizer_ft) ``` 此部分实现了完整的训练循环逻辑，包括损失函数的选择、优化器配置等方面的内容。通过这种方式可以在本地环境中高效地执行端到端的学习流程[^4]。