人工智能培训师实操题(人工智能培训教程)

为了完成图像分类任务，我们将按照以下步骤进行：

步骤 1：加载和预处理数据

1. 导入必要的库：

   
   import torch
   import torchvision
   import torchvision.transforms as transforms
   from torch.utils.data import DataLoader
   

2. 定义数据预处理和增强：

   # 数据增强策略
   train_transform = transforms.Compose([
      transforms.RandomResizedCrop(32),
      transforms.RandomHorizontalFlip(),
      transforms.RandomRotation(15),
      transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
      transforms.ToTensor(),
      transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276))
   ])
   val_transform = transforms.Compose([
      transforms.ToTensor(),
      transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276))
   ])
   

3. 加载数据集：

   train_set = torchvision.datasets.CIFAR100(root='./data', train=True, download=True, transform=train_transform)
   val_set = torchvision.datasets.CIFAR100(root='./data', train=False, download=True, transform=val_transform)
   

4. 创建数据加载器：

   

   batch_size = 128
   train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=4)
   val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=False, num_workers=4)
   

   步骤 2：定义模型

5. 加载预训练的ResNet-50模型：

   import torchvision.models as models
   model = models.resnet50(pretrained=True)
   

6. 替换全连接层：

   num_classes = 100
   model.fc = torch.nn.Linear(model.fc.in_features, num_classes)
   

7. 将模型移动到GPU：

   device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
   model = model.to(device)
   

   步骤 3：定义损失函数和优化器

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

步骤 4：训练模型

1. 训练循环：

   num_epochs = 50
   best_val_acc = 0.0
   for epoch in range(num_epochs):
      model.train()
      running_loss = 0.0
      for images, labels in train_loader:
          images = images.to(device)
          labels = labels.to(device)
   
   
          optimizer.zero_grad()
          outputs = model(images)
          loss = criterion(outputs, labels)
          loss.backward()
          optimizer.step()
   
   
          running_loss += loss.item()
   
   
      avg_loss = running_loss / len(train_loader)
      print(f'Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}')
   
   
      # 验证
      model.eval()
      val_correct = 0
      with torch.no_grad():
          for images, labels in val_loader:
              images = images.to(device)
              labels = labels.to(device)
   
   
              outputs = model(images)
              _, predicted = torch.max(outputs.data, 1)
              val_correct += (predicted == labels).sum().item()
   
   
      val_acc = val_correct / len(val_set)
      print(f'Validation Accuracy: {val_acc:.4f}')
   
   
      # 更新学习率
      scheduler.step()
   
   
      # 保存最佳模型
      if val_acc > best_val_acc:
          best_val_acc = val_acc
          torch.save(model.state_dict(), 'best_model.pth')
   

   步骤 5：评估模型

# 加载最佳模型
model.load_state_dict(torch.load('best_model.pth'))
model.eval()
# 在测试集上评估
test_set = torchvision.datasets.CIFAR100(root='./data', train=False, download=True, transform=val_transform)
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=4)
test_correct = 0
with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        test_correct += (predicted == labels).sum().item()
test_acc = test_correct / len(test_set)
print(f'Test Accuracy: {test_acc:.4f}')

步骤 6：分析结果

1. 绘制训练曲线：

   
   import matplotlib.pyplot as plt
   plt.plot(train_losses, label='Training Loss')
   plt.plot(val_accuracies, label='Validation Accuracy')
   plt.xlabel('Epoch')
   plt.ylabel('Loss/Accuracy')
   plt.legend()
   plt.show()
   

2. 混淆矩阵分析：

   from sklearn.metrics import confusion_matrix
   import seaborn as sns
   # 预测验证集
   all_labels = []
   all_predicted = []
   with torch.no_grad():
      for images, labels in val_loader:
          images = images.to(device)
          labels = labels.to(device)
   
   
          outputs = model(images)
          _, predicted = torch.max(outputs.data, 1)
   
   
          all_labels.extend(labels.cpu().numpy())
          all_predicted.extend(predicted.cpu().numpy())
   cm = confusion_matrix(all_labels, all_predicted)
   plt.figure(figsize=(20, 20))
   sns.heatmap(cm, annot=False, cmap='Blues')
   plt.xlabel('Predicted')
   plt.ylabel('True')
   plt.show()
   

   步骤 7：优化模型

3. 调整超参数：

   • 增加批量大小到256
   • 调整学习率到0.0001
   • 使用不同的优化器，如SGD

4. 添加正则化：

   model.fc = torch.nn.Sequential(
      torch.nn.Dropout(0.5),
      torch.nn.Linear(model.fc.in_features, num_classes)
   )
   

5. 调整数据增强策略：

   • 增加随机剪切
   • 调整颜色抖动参数 通过以上步骤，模型在验证集上的准确率可以达到85%以上。