Yes, i am currently looping through a dict where flair, t1 and the mask are transformed. I plottef the transformed image vs the original and it looked fine. This confuses me alot. Heres the code for transformation:
import numpy as np
import torch.nn.functional as nn_F
import torchvision.transforms.functional as F
import torchvision.transforms as transform
import torch
import nibabel as nib
import matplotlib.pyplot as plt
import math
from collections.abc import Sequence

class Random_Rotation(object):
    def __init__(self, angle, interpolation_method = transform.InterpolationMode.BILINEAR):
        if not isinstance(angle, (float, int)):
            raise TypeError(f"Please provide a valid angle type (int/float), provided {type(self.angle)}")
        self.angle = angle
        self.interpolation_method = interpolation_method
        
    
    def __call__(self, image_sample):
        current_angle = np.random.uniform(-self.angle, self.angle)

        if isinstance(image_sample, list):
            unpacked = enumerate(image_sample)
        elif isinstance(image_sample, dict):
            unpacked = image_sample.items()
            
        else:
            raise TypeError(f"Please provide a list or dict of images, given type {type(image_sample)}")
        

        for idx,samples in unpacked:

            if not isinstance(samples, torch.Tensor):
                samples = torch.from_numpy(samples)
            
            image_sample[idx] = F.rotate(samples, current_angle, interpolation = self.interpolation_method)
        
        return image_sample


class Random_Horizontal_Flip(object):
    def __init__(self, flip_probability = 0.5):
        if not isinstance(flip_probability, (int,float)):
            raise TypeError(f"Please provide a valid value for the flip probability, you typed: {flip_probability}")
        else:
            pass 
        
        if flip_probability > 1.0 or flip_probability < 0:
            raise ValueError(f"The probability has to be in the interval[0,1], you typed {flip_probability}")
        else:
            pass
        
        self.pvalue = flip_probability
    
    def __call__(self,image_sample):

        if isinstance(image_sample, list):
            unpacked = enumerate(image_sample)
        elif isinstance(image_sample, dict):
            unpacked = image_sample.items()
        else:
            raise TypeError(f"Please provide a list or dict of images, given type {type(image_sample)}")

        if torch.rand(1) < self.pvalue:
            for idx,samples in unpacked:
                
                if not isinstance(samples, torch.Tensor):
                    samples = torch.from_numpy(samples)
                
                image_sample[idx] = F.hflip(samples)
                

        
class Random_Scale(object):
    def __init__(self, scale_factor, interpolation_method = transform.InterpolationMode.BILINEAR):
        if not isinstance(scale_factor, (int,float)):
            raise TypeError(f"Please provide a valid value for the scaling factor, you typed: {scale_factor}")
        else:
            pass

        self.scale_factor = scale_factor
        self.interpolation_method = interpolation_method

    def __call__(self, image_sample):
        
        current_scale = np.random.uniform(1 - self.scale_factor, 1 + self.scale_factor)
        
        
        if isinstance(image_sample, list):
            unpacked = enumerate(image_sample)
            height, width = (image_sample[0]).shape[1:]

        
        elif isinstance(image_sample, dict):
            unpacked = image_sample.items()
            key = list(image_sample.keys())[0]

            height, width = (image_sample[key]).shape[1:]
            
            
        else:
            raise TypeError(f"Please provide a list or dict of images, given type {type(image_sample)}")
        #else:
        #    image_sample = list(image_sample)
        
        if not (height - width) < 1e-6:
            raise ValueError("It seems that the height and the width are not equal")
        else:
            pass

        original_img_size = (height, width)
        height = int(round(height*current_scale))
        width = int(round(width*current_scale))
        new_size = (height,width)
       
        for idx,samples in unpacked:
            
            if not isinstance(samples, torch.Tensor):
                samples = torch.from_numpy(samples)
            
            else:
                pass
            
            image_sample[idx] = F.resize(samples, new_size, self.interpolation_method)

            if current_scale < 1.0:
                diff = (original_img_size[0] - new_size[0])
                left = diff//2
                right = left + diff%2
            
                padding_ = (int(left), int(right),)*2
                
                image_sample[idx] = nn_F.pad(image_sample[idx], padding_,"constant",0)
                

            else:
                x_min = (new_size[0]- original_img_size[0]) // 2
                x_max = x_min + original_img_size[0]
            
                image_sample[idx]= (image_sample[idx])[... , x_min : x_max, x_min : x_max]
               
        return image_sample