I’m currently working on a multi-label classification problem using a dataset containing images of Ocular Disease. I’ve written a custom PyTorch Dataset implementation to create a loader that will, for every patient ID, return the left and the right image, as well as the associated 8D multi-hot target vector.
The following is my Dataset class code:
class CustomDataset(torch.utils.data.Dataset):
    def __init__(self, IDs, data_dir, annotations, transforms=None):
        
        self.transforms = transforms
        self.annotations = annotations
        self.data_dir = data_dir
        
        # read the excel file.
        mapper = pd.read_excel(self.annotations, sheet_name=0)
        mapper.ID = mapper.ID.astype(str)
        
        # 'ID' is the primary key.
        self.subset_df = mapper.loc[mapper['ID'].isin(IDs), :]
        
        print("Found {} entries.".format(self.subset_df.shape[0]))
        
        self.subset_df.reset_index(drop=True, inplace=True)
        
        self.ix2id = {
            ix:id for ix, id in zip(list(self.subset_df.index), list(self.subset_df.ID))
        }


    def __len__(self):
        return len(self.ix2id)


    def __getitem__(self, index):
        
        # Sample from IDs
        sampled_id = self.ix2id[index]
        
        row = self.subset_df.loc[self.subset_df.ID == sampled_id, :]
        
        left_im_name = row['Left-Fundus'].values[0]
        right_im_name = row['Right-Fundus'].values[0]
        
        left_im = Image.open(self.data_dir + left_im_name, "r")
        right_im = Image.open(self.data_dir + right_im_name, "r")
        
        if self.transforms is not None:
            left_im = self.transforms(left_im)
            right_im = self.transforms(right_im)
        
        y = row[['N','D','G','C','A','H','M','O']].values.flatten()
        
        return (left_im, right_im), y

The class is instantiated with a list of IDs (split separately). The following is the instantiation:

train_transforms = transforms.Compose([
    transforms.RandomRotation(60),
    transforms.Resize((IM_HEIGHT, IM_WIDTH)),
    transforms.ToTensor(),
    transforms.Normalize(mean=mean, std=std)
])

val_transforms = transforms.Compose([
    transforms.Resize((IM_HEIGHT, IM_WIDTH)),
    transforms.ToTensor(),
    transforms.Normalize(mean=mean, std=std)
])

train = CustomDataset(train_split, data_dir='path_to_im', annotations='somepath', transforms=train_transforms)

test = CustomDataset(test_split, data_dir='path_to_im', annotations='somepath', transforms=val_transforms)

train_dataloader = torch.utils.data.DataLoader(train, batch_size=BATCH_SIZE, shuffle=True, num_workers=5)

test_dataloader = torch.utils.data.DataLoader(test, batch_size=BATCH_SIZE, shuffle=True, num_workers=5)


The model training is without a hitch. The evaluation, however, is where the model returns nans. The following is the eval() code:

def eval(epoch_num):
    
    model.eval()
    
    epoch_loss = 0.
    
    y_true = []
    y_pred = []
    
    for ix, ((left_im, right_im), target) in enumerate(test_dataloader):
        
        y_true.append(target)
        
        # Push on GPU.
        left_im = left_im.to(device)
        right_im = right_im.to(device)
        target = target.to(device).float()
        
        with torch.no_grad():
            left_im, right_im, target = Variable(left_im), Variable(right_im), Variable(target)
        
        # Pass both image batches through.
        preds = model(left_im, right_im)
        
        # !!! Preds is a (B, 8) tensor full of nans !!!

        loss = criterion(preds, target)
        
        epoch_loss += loss.item()
        
        pred_cpu = preds.detach().cpu().numpy()
        y_pred.append(pred_cpu)
    
    y_true = np.concatenate(y_true, axis=0)
    y_pred = np.concatenate(y_pred, axis=0)
    
    print("Eval loss: {}".format(epoch_loss/len(test_dataloader)))
    
    metrics = custom_Metrics(gt_data=y_true, pr_data=y_pred)
    
    print("Eval metrics: {}".format(metrics))
    
    metrics['loss'] = epoch_loss
    
    return metrics


What seems to be wrong here?
The model is a simple CNN that passes both images through a ‘backbone’ (for shared parameters), concatenates the latent vectors, and passes it through a couple of Linear layers. I’m using the BCEWithLogitsLoss criterion and an Adam optimizer and an initial learning rate of 5e-4.