Determine Ran Augmentations

[danieltudosiu]

I need to be able to tell which augmentations have been ran on the data for later logic.

I am aware that this can be done for ones that inherit from InvertibleTransform due to the fact that they use the push_transform() method, but for others, I have not found a way to determine which of them have run or with what parameters.

What can I do?

[Nic-Ma]

Hi @danieltudosiu ,

Thanks for your interest and feedback here.
I think you can leverage the TraceableTransform features:
https://github.com/Project-MONAI/MONAI/blob/dev/monai/transforms/inverse.py#L22

Thanks.

[danieltudosiu]

Hi @Nic-Ma,

Thank you for the fast answer.

Sadly is not what I am looking for. What I am looking for is how to (without any additional code) have a trace of the augmentations that have been run and with what parameters on each sample. This is achieved for the augmentations that inherit from TraceableTransform but I feel it need to be done to all transformations. This would be useful for debugging as well as some anomaly detection works where the autoregressive models are conditioned on the augmentations ran on each sample.

[danieltudosiu]

Feel free to use this quick and dirty solution that I wrote:

from typing import Collection, Dict, Hashable, Mapping, Union

import numpy as np
from monai.config import KeysCollection
from monai.transforms.compose import Compose
from monai.transforms.transform import MapTransform, RandomizableTransform
from monai.utils.misc import ensure_tuple


class TraceTransformsd(MapTransform):
    def __init__(
        self,
        keys: KeysCollection,
        composed_transforms: Union[Collection[Compose], Compose],
        trace_key_postfix: str = "trace_dict",
        allow_missing_keys: bool = False,
    ):
        super().__init__(keys, allow_missing_keys)
        self.composed_transforms = ensure_tuple(composed_transforms)
        self.trace_key_postfix = trace_key_postfix

        assert len(self.keys) == len(self.composed_transforms), (
            f"The keys and composed_transforms must have the same length but got keys of length {len(self.keys)} and "
            f"composed_transforms of length {len(self.composed_transforms)}"
        )

    def __call__(
        self, data: Mapping[Hashable, np.ndarray]
    ) -> Dict[Hashable, np.ndarray]:

        d = dict(data)

        for k, ct in zip(self.keys, self.composed_transforms):
            trace = {
                str(transform.__class__).split(".")[-1]: transform._do_transform
                if isinstance(transform, RandomizableTransform)
                else True
                for transform in ct.transforms
            }

            d[f"{k}_{self.trace_key_postfix}"] = trace

        return d

[Nic-Ma]

Hi @danieltudosiu ,

Thanks very much for your suggestion.
Actually, I think that's the same reason that we add the TraceableTransform feature.
We will try to track the status for all the transforms in the future.
CC @wyli @ericspod @rijobro

Thanks.

[rijobro]

Hi @danieltudosiu,

It is certainly desirable to record all applied transforms and their parameters. We need to gradually upgrade all MapTransform so that they also inherit from TraceableTransform. From here, we just need to make sure that each key of the map transform calls the push_transform method with any additional information. For example, CropForeground:

    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, NdarrayOrTensor]:
        ...
        for key, m in self.key_iterator(d, self.mode):
            self.push_transform(d, key, extra_info={"box_start": box_start, "box_end": box_end})
            d[key] = self.cropper.crop_pad(img=d[key], box_start=box_start, box_end=box_end, mode=m)
        return d

If you wanted to do these for some of the transforms that you commonly use, that would be much appreciated!