With the use of unet and fcn vgg model, i am unable to get desired accuracy on pascal voc 2012 segmentation dataset, with 10 epoch i am only getting acc. starting from 27% to 45%. I have used the dataset available on PyTorch datasets as
train_set = torchvision.datasets.VOCSegmentation(root='drive/My Drive/VOC',
                                     year='2012',
                                     image_set='train',
                                     download=True,
                                     transform=T.Compose([
                                                          T.Resize(144),
                                                          T.CenterCrop(128),
                                                          T.ToTensor()
                                     ]),
                                     target_transform=T.Compose([
                                                           T.Resize(144),
                                                           T.CenterCrop(128),
                                                           T.ToTensor()
                                     ]),
                                     transforms=None)

and batch of 64 as:
train_loader = data.DataLoader(train_set, batch_size=64, shuffle=True)

and my train.py is:
train_Accuracy = []
train_Loss = []
dictionary = {}
for epoch in range(8):
  total_loss = 0
  total_correct = 0
  total_train = 0
  correct_train = 0
  ts = time.time()

  for batch in train_loader:
    images, labels = batch

    optimizer.zero_grad()

    preds = model(images)
    loss = criterion(preds, labels)

    loss.backward()
    optimizer.step()

    total_loss += loss.item()
    # total_correct += get_num_correct(preds, labels)

    _, predicted = torch.max(preds.data, 1)
    total_train += labels.nelement()
    correct_train += predicted.eq(labels.data).sum().item()
    train_accuracy = 100 * correct_train / total_train

  train_Loss.append(round(loss.item(), 5))
  train_Accuracy.append(round(train_accuracy, 4))

  dictionary = {
      "epoch": epoch + 1,
      "loss": round(loss.item(), 5),
      "accuracy": round(train_accuracy, 4),
      "training time": time.time() - ts,
      "model": model.state_dict()
  }
  torch.save(dictionary, 'data_to_be_saved_{}.pth'.format(epoch+1))
  print('epoch: ', epoch + 1,
        # ' total_correct: ', total_correct,
        # ' loss: ', total_loss/len(data_loader),
        ' loss: ', round(loss.item(), 5),
        ' accuracy: ', round(train_accuracy, 4),
        ' training time: ', time.time() - ts)