Spacingd weird behaviour

[nicktasios]

I separated the preprocessing of my data, so that I have fewer transforms to run during training.

import os                                                                                                                                          
import glob                                                                                                                                        
import random                                                                                                                                      
import tqdm                                                                                                                                        
                                                                                                                                                   
from monai.transforms import (                                                                                                                     
    EnsureChannelFirstd,                                                                                                                           
    Compose,                                                                                                                                       
    LoadImaged,                                                                                                                                    
    Orientationd,                                                                                                                                  
    SaveImaged,                                                                                                                                    
)                                                                                                                                                  
from monai.data import Dataset, DataLoader                                                                                                         
from monai.data.utils import no_collation                                                                                                          
                                                                                                                                                   
if __name__ == '__main__':                                                                                                                         
                                                                                                                                                   
    data_folder = "path_to_data"                                           
    prefix      = "prefix_path"                                             
                                                                                                                                                   
    images = set(sorted(glob.glob(os.path.join(data_folder, 'imagesTr', '*.nii.gz'))))                                                             
    labels = set(sorted(glob.glob(os.path.join(data_folder, 'labelsTr', '*.nii.gz'))))                                                             
                                                                                                                                                   
    train_files = [                                                                                                                                
        {'image': image_name, 'label': label_name}                                                                                                 
        for image_name, label_name in zip(images, labels)                                                                                          
    ]                                                                                                                                              
                                                                                                                                                   
    data_transform = Compose([                                                                                                                     
        LoadImaged(keys=["image", "label"]),                                                                                                       
        EnsureChannelFirstd(keys=["image", "label"]),                                                                                              
        Orientationd(keys=["image", "label"], axcodes="RAI")                                                                                       
    ])                                                                                                                                             
    post_transform = Compose([                                                                                                                     
        SaveImaged(keys=["image"], output_dir=os.path.join(prefix, "original/imagesTr"), output_postfix="", resample=False, separate_folder=False),
        SaveImaged(keys=["label"], output_dir=os.path.join(prefix, "original/labelsTr"), output_postfix="", resample=False, separate_folder=False) 
    ])                                                                                                                                             
                                                                                                                                                   
    dataset = Dataset(data=train_files, transform=data_transform)                                                                                  
    data_loader = DataLoader(                                                                                                                      
        dataset,                                                                                                                                   
        batch_size=1,                                                                                                                              
        shuffle=False,                                                                                                                             
        num_workers=1,                                                                                                                             
        pin_memory=False,                                                                                                                          
        collate_fn=no_collation,                                                                                                                   
    )                                                                                                                                              
                                                                                                                                                   
    for batch_data in tqdm.tqdm(data_loader, desc="preprocess"):                                                                                   
        for batch_data_i in batch_data:                                                                                                            
            batch_data_i = post_transform(batch_data_i)                                                                                            

The transformed images and labels are saved in a new folder and the next script loads the data for training:

import os                                                                                                      
import glob                                                                                                    
from sklearn.model_selection import GroupKFold                                                                 
import random                                                                                                  
from typing import List                                                                                        
import tqdm                                                                                                    
import math                                                                                                    
                                                                                                               
from monai.transforms import (                                                                                 
    EnsureChannelFirstd,                                                                                       
    Compose,                                                                                                   
    LoadImaged,                                                                                                
    Orientationd,                                                                                              
    SaveImaged,                                                                                                
    SpatialResampled,                                                                                          
    Spacingd,                                                                                                  
    MapLabelValued,                                                                                            
    RandCropByPosNegLabeld,                                                                                    
    RandRotated,                                                                                               
    RandZoomd,                                                                                                 
    ScaleIntensityRanged,                                                                                      
)                                                                                                              
from monai.data import Dataset, DataLoader                                                                     
from monai.data.utils import no_collation                                                                      
                                                                                                               
                                                                                                               
def create_splits(case_ids: List[str], n_splits: int = 5) -> List[List[str]]:                                  
    """                                                                                                        
    Create a split of the given case IDs.                                                                      
                                                                                                               
    :param case_ids: List of case IDs that should be splitted.                                                 
    :return: Lists of case IDs per split.                                                                      
    """                                                                                                        
                                                                                                               
    control_cases = [x for x in case_ids if x[-4] == '1']                                                      
    nvi_cases     = [x for x in case_ids if x[-4] == '2']                                                      
    vi_cases      = [x for x in case_ids if x[-4] == '3']                                                      
                                                                                                               
    group_k_fold = GroupKFold(n_splits=n_splits)                                                               
                                                                                                               
    cv_splits = [[] for _ in range(5)]                                                                         
    for cases in [control_cases, nvi_cases, vi_cases]:                                                         
        random.shuffle(cases)                                                                                  
        groups = [int(x[-3:]) for x in cases]                                                                  
        splits = group_k_fold.split(cases, groups=groups)                                                      
        for i, split in enumerate(splits):                                                                     
            cv_splits[i].extend([cases[y] for y in split[0]])                                                  
                                                                                                               
    return cv_splits                                                                                           
                                                                                                               
if __name__ == '__main__':                                                                                     
                                                                                                               
    data_folder = "path_to_preprocessed_data"
    prefix      = "prefix_path"         
                                                                                                               
    labels=[                                                                                                   
        'background',                                                                                          
        'pancreas',                                                                                            
        'tumour',                                                                                              
        'pd',                                                                                                  
        'cbd'                                                                                                  
    ]                                                                                                          
                                                                                                               
    images = sorted(glob.glob(os.path.join(data_folder, 'imagesTr', '*.nii.gz')))                              
    labels = sorted(glob.glob(os.path.join(data_folder, 'labelsTr', '*.nii.gz')))                              
                                                                                                               
    case_ids = [os.path.basename(x)[:-7] for x in images]                                                      
    splits = create_splits(case_ids)                                                                           
                                                                                                               
    training_case_ids = set(splits[0])                                                                         
    val_case_ids = set(case_ids).difference(training_case_ids)                                                 
                                                                                                               
    train_images = [x for i, x in enumerate(images) if case_ids[i] in training_case_ids]                       
    val_images   = [x for i, x in enumerate(images) if case_ids[i] in val_case_ids]                            
                                                                                                               
    train_labels = [x for i, x in enumerate(labels) if case_ids[i] in training_case_ids]                       
    val_labels   = [x for i, x in enumerate(labels) if case_ids[i] in val_case_ids]                            
                                                                                                               
    train_files = [                                                                                            
        {'image': image_name, 'label': label_name}                                                             
        for image_name, label_name in zip(train_images, train_labels)                                          
    ]               
                                                                                           val_files = [                                                                                
    {'image': image_name, 'label': label_name}                                               
    for image_name, label_name in zip(val_images, val_labels)                                
]                                                                                                                                                                                                                                                       
                                                                                             
train_transforms = Compose([                                                                 
    LoadImaged(keys=["image", "label"]),                                                     
    MapLabelValued(                                                                          
        keys=["label"],                                                                      
        orig_labels=[0]+[x+1 for x in range(len(labels)-1)],                                 
        target_labels=[0]+[1 for x in range(len(labels)-1)]                                  
    ),                                                                                       
    ScaleIntensityRanged(                                                                    
        keys=["image"], a_min=-100, a_max=250,                                               
        b_min=-3.0, b_max=3.0, clip=True,                                                    
    ),                                                                                       
    Spacingd(                                                                                
        keys=["image", "label"],                                                             
        pixdim=(4.0, 4.0, 4.0),                                                              
        mode=("bilinear", "nearest"),                                                        
    ),                                                                                       
])                                                                                           
                                                                                             
train_dataset = Dataset(data=train_files, transform=train_transforms)                        
train_loader = tqdm.tqdm(DataLoader(                                                         
    train_dataset,                                                                           
    batch_size=1,                                                                            
    shuffle=True,                                                                            
    num_workers=1,                                                                           
), desc="train")                                                                             
                                                                                             
for i, d in enumerate(train_loader):                                                         
    print(d['image'].affine)                                                                 

After performing the Spacingd step, the affine matrix becomes three-dimensional, e.g.:
from

tensor([[[   0.6406,    0.0000,    0.0000, -149.7974],                       
         [   0.0000,    0.6406,    0.0000, -319.9297],                       
         [   0.0000,    0.0000,   -1.0000,  368.2000],                       
         [   0.0000,    0.0000,    0.0000,    1.0000]]], dtype=torch.float64)

to

tensor([[[   4.0000,    0.0000, -173.3164],                       
         [   0.0000,    4.0000, -322.3164],                       
         [   0.0000,    0.0000,    1.0000]]], dtype=torch.float64)

I something going wrong when saving and loading back, or is this some kind of bug, perhaps due to some limitations with nifti?

[wyli]

I haven't looked into the details, but there's a fix in 1.0.1 related to this, could you please try monai==1.0.1rc2 and see if the issue persists?

the issue is usually caused by not having a channel dimension, so 3D image is interpreted as chn+2D
otherwise maybe before the maplabelvalued adds a ensure channel.

train_transforms = Compose([                                                                 
    LoadImaged(keys=["image", "label"]),
+    EnsureChannelFirstd(keys=["image", "label"]),                                                 
    MapLabelValued(                                                                          
        keys=["label"],                                                                      
        orig_labels=[0]+[x+1 for x in range(len(labels)-1)],                                 
        target_labels=[0]+[1 for x in range(len(labels)-1)]                                  
    ),             

[nicktasios]

If I just do LoadImaged without any of the other transforms and print out the shape, print(d['image'].shape), I do get a channel, i.e. the shape is something like (1, 512, 512, 73).