### 使用 PyTorch 实现猫狗分类的迁移学习 #### 数据准备 为了进行猫狗图像分类，需先准备好数据集并对其进行预处理。这通常涉及下载 Kaggle 上的猫狗分类数据集，并设置合适的数据增强和转换操作。 ```python import torch from torchvision import transforms, datasets 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(root=f'data/{x}', transform=data_transforms[x]) for x in ['train', 'val']} dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=4) for x in ['train', 'val']} dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} class_names = image_datasets['train'].classes[^1] ``` #### 加载预训练模型 利用 PyTorch 提供的功能可以轻松加载已预先训练好的网络结构作为基础架构，在此案例中选择了 VGG16 模型来进行微调。 ```python model_ft = models.vgg16(pretrained=True) for param in model_ft.features.parameters(): param.requires_grad = False num_ftrs = model_ft.classifier[6].in_features features = list(model_ft.classifier.children())[:-1] # Remove last layer features.extend([nn.Linear(num_ftrs, 2)]) # Add our layer with 2 outputs (cat and dog) model_ft.classifier = nn.Sequential(*features) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model_ft = model_ft.to(device)[^3] ``` #### 定义优化器与损失函数 选择合适的优化算法以及定义好用于评估预测误差的标准是至关重要的一步。这里采用了随机梯度下降法(SGD)，并且设置了交叉熵作为衡量标准。 ```python criterion = nn.CrossEntropyLoss() optimizer_ft = optim.SGD(model_ft.classifier.parameters(), lr=0.001, momentum=0.9)[^2] exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) ``` #### 训练过程 完成上述准备工作之后就可以进入正式的训练环节了。通过循环迭代整个数据集来不断调整参数直至达到满意的性能指标为止。 ```python def train_model(model, criterion, optimizer, scheduler, num_epochs=25): best_model_wts = copy.deepcopy(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 # Iterate over data. for inputs, labels in dataloaders[phase]: inputs = inputs.to(device) labels = labels.to(device) # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.set_grad_enabled(phase == 'train'): outputs = model(inputs) _, preds = torch.max(outputs, 1) loss = criterion(outputs, labels) # backward + optimize only if in training phase if phase == 'train': loss.backward() optimizer.step() # statistics running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) if phase == 'train': scheduler.step() 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}') # deep copy the model if phase == 'val' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) print() # load best model weights model.load_state_dict(best_model_wts) return model ```