### PyTorch深度学习图片分类实战教程 #### 1. 准备工作 为了构建一个基于PyTorch的图像分类模型，准备工作至关重要。这包括安装必要的库以及准备数据集。对于本实例而言，选择了咖啡豆作为目标对象来进行分类训练[^1]。 ```bash pip install torch torchvision matplotlib numpy pandas scikit-image opencv-python ``` #### 2. 数据预处理 在开始之前，需要加载并清理用于训练的数据集。这里采用的是`torchvision.datasets.ImageFolder`来读取文件夹中的图片，并通过自定义变换函数调整大小、裁剪等方式使输入标准化。 ```python from torchvision import datasets, transforms 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 ``` #### 3. 构建模型架构 此部分展示了如何利用迁移学习的思想创建高效的卷积神经网络(CNN)，特别是使用了VGG16作为基础特征提取器，并在其顶部添加了一个全连接层完成最终预测任务。值得注意的是，在某些情况下还可以尝试其他预训练好的骨干网如ResNet等。 ```python import torch.nn as nn model_conv = torchvision.models.vgg16(pretrained=True) for param in model_conv.parameters(): param.requires_grad_(False) num_ftrs = model_conv.classifier[6].in_features features = list(model_conv.classifier.children())[:-1] features.extend([nn.Linear(num_ftrs, len(class_names))]) model_conv.classifier = nn.Sequential(*features) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model_conv = model_conv.to(device) ``` #### 4. 训练过程 设置损失函数与优化算法后即可进入迭代循环阶段；每一轮次都会计算当前批次上的误差值并通过反向传播更新权重参数直至收敛为止。此外还加入了验证环节以便监控泛化性能变化趋势。 ```python criterion = nn.CrossEntropyLoss() optimizer_ft = optim.SGD(model_conv.classifier.parameters(), lr=0.001, momentum=0.9) exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) def train_model(model, criterion, optimizer, scheduler, num_epochs=25): since = time.time() 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 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() 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}') # load best model weights model.load_state_dict(best_model_wts) return model model_conv = train_model(model_conv, criterion, optimizer_ft, exp_lr_scheduler, num_epochs=25) ```