Compose of transformations for CacheDataset

[jfulem]

The usage of compose of transformations with map_items = False is omitted

When using the CacheDataset the _load_cache_item method is called, but there the Compose.map_items is not used and therefore all the transformations are applied to all data even though the data is a list or tuple.

    def _load_cache_item(self, idx: int):
        """
        Args:
            idx: the index of the input data sequence.
        """
        item = self.data[idx]
        for _transform in self.transform.transforms:
            # execute all the deterministic transforms
            if isinstance(_transform, RandomizableTrait) or not isinstance(_transform, Transform):
                break
            _xform = deepcopy(_transform) if isinstance(_transform, ThreadUnsafe) else _transform
            item = apply_transform(_xform, item)
        if self.as_contiguous:
            item = convert_to_contiguous(item, memory_format=torch.contiguous_format)
        return item

[lichtenstein-noa]

Hello, I’m a computational biology graduate, hoping to start contributing to MONAI, and this looked like a good small issue to begin with. I tested this against MONAI 1.1.0 and current dev, and the issue appears to be fixed on current dev.
Posting the evidence here in case it's useful for closing this out.

Where the bug was: in v1.1.0, CacheDataset had two call sites that bypassed Compose.call without forwarding map_items: _load_cache_item (the deterministic prefix, built once when the cache is filled) and _transform (the random tail, run at access time). Both walked self.transform.transforms directly and called apply_transform() on each transform without passing map_items, so it fell back to its default (True), regardless of what the user set on their Compose. Plain Dataset._transform calls the Compose object directly and was never affected.

Why it is fixed now: from 1.2.0 on (PR #6224), both call sites were replaced with calls to the Compose object itself - self.transform(item, end=first_random, threading=True) for the cached prefix, self.transform(data, start=first_random) for the random tail - so map_items can no longer be dropped at either site.

Reproduction: I used a minimal pipeline (Split → Probe A → RandNoop → Probe B) to exercise both call paths, and a separate deterministic-only (Split → TagShape) pipeline to inspect CacheDataset._cache directly. Both were run with map_items=False and True, on both monai==1.1.0 and current dev.

Reproduction script:
https://gist.github.com/lichtenstein-noa/0ce137a6c10960946bcf49237c7de8b6

Results:
On monai==1.1.0:
map_items=False Dataset vs CacheDataset: DIFFER <- #6111
map_items=True Dataset vs CacheDataset: agree

On current dev:
map_items=False Dataset vs CacheDataset: agree
map_items=True Dataset vs CacheDataset: agree

A direct read of CacheDataset._cache shows the same pattern: on 1.1.0, the cached content for map_items=False matches the incorrect map_items=True shape; on current dev the two are structurally distinct, as expected.

Note: I used Claude Code to help develop the reproduction. I tried a few different approaches it suggested and combined parts of them into the final version, which I then reviewed, ran, and verified myself against both MONAI versions.

[lichtenstein-noa]

Hello @ericspod just following up on the reproduction above. This looks resolved on current dev, so flagging in case it's useful for closing the issue.