第四次作业：猫狗大战挑战赛

猫狗大战VGG模型

• 数据处理

  normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  
  vgg_format = transforms.Compose([
                  transforms.CenterCrop(224),
                  transforms.ToTensor(),
                  normalize,
              ])
  
  data_dir = './dogscats'
  
  dsets = {x: datasets.ImageFolder(os.path.join(data_dir, x), vgg_format)
           for x in ['train', 'valid']}
  
  dset_sizes = {x: len(dsets[x]) for x in ['train', 'valid']}
  dset_classes = dsets['train'].classes
  

  使用 ToTensor() 和 Normalize() 对数据进行归一化

• 创建VGG模型

  !wget https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json
  
  
  model_vgg = models.vgg16(pretrained=True)
  
  with open('./imagenet_class_index.json') as f:
      class_dict = json.load(f)
  dic_imagenet = [class_dict[str(i)][1] for i in range(len(class_dict))]
  
  inputs_try , labels_try = inputs_try.to(device), labels_try.to(device)
  model_vgg = model_vgg.to(device)
  
  outputs_try = model_vgg(inputs_try)
  
  print(outputs_try)
  print(outputs_try.shape)
  
  

  

• 冻结前面层的参数

  深度学习网络的参数是通过计算梯度，在反向传播进行更新。有时需要固定某些层的参数不参与反向传播。

  print(model_vgg)
  
  model_vgg_new = model_vgg;
  
  for param in model_vgg_new.parameters():
      param.requires_grad = False
  model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
  model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)
  
  model_vgg_new = model_vgg_new.to(device)
  
  print(model_vgg_new.classifier)
  

  在训练中冻结前面层的参数，需要设置 required_grad=False。

• 训练并测试全连接层

  创建损失函数和优化器

  criterion = nn.NLLLoss()
  
  # 学习率
  lr = 0.001
  
  # 随机梯度下降
  optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)
  

  训练模型

  def train_model(model,dataloader,size,epochs=1,optimizer=None):
      model.train()
      
      for epoch in range(epochs):
          running_loss = 0.0
          running_corrects = 0
          count = 0
          for inputs,classes in dataloader:
              inputs = inputs.to(device)
              classes = classes.to(device)
              outputs = model(inputs)
              loss = criterion(outputs,classes)           
              optimizer = optimizer
              optimizer.zero_grad()
              loss.backward()
              optimizer.step()
              _,preds = torch.max(outputs.data,1)
              # statistics
              running_loss += loss.data.item()
              running_corrects += torch.sum(preds == classes.data)
              count += len(inputs)
              print('Training: No. ', count, ' process ... total: ', size)
          epoch_loss = running_loss / size
          epoch_acc = running_corrects.data.item() / size
          print('Loss: {:.4f} Acc: {:.4f}'.format(
                       epoch_loss, epoch_acc))
          
          
  # 模型训练
  train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1, 
              optimizer=optimizer_vgg)
  

• 可视化模型预测结果

  # 单次可视化显示的图片个数
  n_view = 8
  correct = np.where(predictions==all_classes)[0]
  from numpy.random import random, permutation
  idx = permutation(correct)[:n_view]
  print('random correct idx: ', idx)
  loader_correct = torch.utils.data.DataLoader([dsets['valid'][x] for x in idx],
                    batch_size = n_view,shuffle=True)
  for data in loader_correct:
      inputs_cor,labels_cor = data
  # Make a grid from batch
  out = torchvision.utils.make_grid(inputs_cor)
  imshow(out, title=[l.item() for l in labels_cor])
  

  

• 心得感悟

猫狗大战挑战赛

提交结果

优化方式：增加一个线性层；增加训练次数，改变epoch的值。