Fix CLI limitation for setting custom image size via model.image_size (#3460)

Fixes issue #3460 by enabling CLI-based configuration of input image size across all models without requiring manual pre-processor reconstruction.

After the pre-processor refactor, the CLI does not provide a simple way to modify image size. Users are forced to either:
1. Recreate the entire preprocessing pipeline via CLI arguments, or
2. Define a full YAML configuration just to change resize dimensions

This significantly reduces usability for a common operation.

This PR introduces `image_size` as a first-class parameter in `AnomalibModule` and propagates it through all model constructors.

The resizing is applied by patching the auto-created pre-processing pipeline using `_apply_image_size`, which:
- Updates the first `Resize` transform if present
- Inserts a `Resize` transform if missing
- Preserves existing transform attributes (e.g., interpolation, antialias)
- Updates `export_transform` for compatibility

Users can now directly set image size via CLI:

anomalib train --model Padim --model.image_size 512 --data MVTecAD --fast_dev_run True

anomalib train --model Padim --model.image_size "[512, 512]" --data MVTecAD --data.category transistor

anomalib train --model Stfpm --model.image_size 384 --data MVTecAD --data.category bottle --fast_dev_run True

jsonargparse exposes CLI arguments based on subclass `__init__` signatures. Therefore, `image_size` is added to each model constructor and forwarded to `AnomalibModule`, following the existing design pattern used for:
- pre_processor
- post_processor
- evaluator
- visualizer

This ensures:
- No CLI-level argument injection
- Consistent API across all models
- Full compatibility with config/CLI system

- Added `image_size` parameter to `AnomalibModule`
- Implemented `_apply_image_size` and `_rebuild_resize`
- Updated all model constructors to accept and forward `image_size`
- Removed the need for CLI or YAML preprocessing overrides

- Supports both int (square) and tuple (H, W)
- Applied only when `pre_processor=True` (default behavior)
- Does not override custom `PreProcessor` instances
- Fully backward compatible (default = None)

- Simplifies CLI usage for a common configuration task
- Eliminates need for verbose preprocessing definitions
- Aligns CLI behavior with Python API capabilities

Signed-off-by: Abhay Kumar Das <dasabhay.jsr@gmail.com>

Author: AbhayKumarDas

src/anomalib/models/components/base/anomalib_module.py

@@ -59,6 +59,7 @@
 from anomalib.metrics.evaluator import Evaluator
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.pre_processing.utils.transform import get_exportable_transform
 from anomalib.utils import deprecate
 from anomalib.visualization import ImageVisualizer, Visualizer
 
@@ -83,6 +84,11 @@ class AnomalibModule(ExportMixin, pl.LightningModule, ABC):
             default. Defaults to ``True``.
         visualizer (Visualizer | bool, optional): Visualizer instance or flag to
             use default. Defaults to ``True``.
+        image_size (tuple[int, int] | int | None, optional): Target image size
+            for resizing in the pre-processor. Only applied when
+            ``pre_processor=True`` (auto-created). Ignored when an explicit
+            ``PreProcessor`` instance is provided. An int value is interpreted
+            as square ``(n, n)``. Defaults to ``None`` (use model default).
 
     Attributes:
         model (nn.Module): PyTorch model to be trained
@@ -126,16 +132,22 @@ def __init__(
         post_processor: nn.Module | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__()
         logger.info("Initializing %s model.", self.__class__.__name__)
 
+        if isinstance(image_size, int):
+            image_size = (image_size, image_size)
+
         self.save_hyperparameters()
         self.model: nn.Module
         self.loss: nn.Module
         self.callbacks: list[Callback]
 
         self.pre_processor = self._resolve_component(pre_processor, nn.Module, self.configure_pre_processor)
+        if image_size is not None and isinstance(pre_processor, bool) and pre_processor:
+            self._apply_image_size(image_size)
         self.post_processor = self._resolve_component(post_processor, nn.Module, self.configure_post_processor)
         self.evaluator = self._resolve_component(evaluator, Evaluator, self.configure_evaluator)
         self.visualizer = self._resolve_component(visualizer, Visualizer, self.configure_visualizer)
@@ -306,6 +318,51 @@ def _resolve_component(
         msg = f"Passed object should be {component_type} or bool, got: {type(component)}"
         raise TypeError(msg)
 
+    def _apply_image_size(self, image_size: tuple[int, int]) -> None:
+        """Patch the auto-created pre-processor's transform to use the given image size.
+
+        Modifies the first ``Resize`` transform found in the pre-processor's
+        transform pipeline. If no ``Resize`` exists, one is prepended.
+        Only called when ``pre_processor=True`` and ``image_size`` is not None.
+
+        Args:
+            image_size (tuple[int, int]): Target ``(height, width)`` for resizing.
+        """
+        if self.pre_processor is None or not isinstance(self.pre_processor, PreProcessor):
+            return
+
+        transform = self.pre_processor.transform
+        if transform is None:
+            logger.warning(
+                "image_size=%s was specified but the model's pre-processor has no transform. "
+                "The image_size setting will be ignored.",
+                image_size,
+            )
+            return
+
+        if isinstance(transform, Compose):
+            for i, t in enumerate(transform.transforms):
+                if isinstance(t, Resize):
+                    transform.transforms[i] = self._rebuild_resize(t, image_size)
+                    break
+            else:
+                transform.transforms.insert(0, Resize(image_size, antialias=True))
+        elif isinstance(transform, Resize):
+            self.pre_processor.transform = self._rebuild_resize(transform, image_size)
+        else:
+            self.pre_processor.transform = Compose([Resize(image_size, antialias=True), transform])
+
+        self.pre_processor.export_transform = get_exportable_transform(self.pre_processor.transform)
+
+    @staticmethod
+    def _rebuild_resize(original: Resize, image_size: tuple[int, int]) -> Resize:
+        """Build a new ``Resize`` with updated size, preserving the original's parameters."""
+        kwargs: dict[str, Any] = {}
+        for attr in ("interpolation", "max_size", "antialias"):
+            if hasattr(original, attr):
+                kwargs[attr] = getattr(original, attr)
+        return Resize(size=image_size, **kwargs)
+
     @staticmethod
     def configure_pre_processor(image_size: tuple[int, int] | None = None) -> PreProcessor:
         """Configure the default pre-processor.

src/anomalib/models/image/anomaly_dino/lightning_model.py

@@ -159,12 +159,14 @@ def __init__(
         post_processor: nn.Module | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
         self.model: AnomalyDINOModel = AnomalyDINOModel(
             num_neighbours=num_neighbours,

src/anomalib/models/image/cfa/lightning_model.py

@@ -101,12 +101,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
         self.model: CfaModel = CfaModel(
             backbone=backbone,

src/anomalib/models/image/cflow/lightning_model.py

@@ -93,12 +93,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
 
         self.model: CflowModel = CflowModel(

src/anomalib/models/image/csflow/lightning_model.py

@@ -80,12 +80,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
         if self.input_size is None:
             msg = "CsFlow needs input size to build torch model."

src/anomalib/models/image/dfkde/lightning_model.py

@@ -96,12 +96,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
 
         self.model: DfkdeModel = DfkdeModel(

src/anomalib/models/image/dfm/lightning_model.py

@@ -96,12 +96,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
 
         self.model: DFMModel = DFMModel(

src/anomalib/models/image/dinomaly/lightning_model.py

@@ -161,12 +161,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
 
         self.model: DinomalyModel = DinomalyModel(

src/anomalib/models/image/draem/lightning_model.py

@@ -92,12 +92,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
         dtd_dir = Path(dtd_dir)
         if not dtd_dir.is_dir():

src/anomalib/models/image/dsr/lightning_model.py

@@ -107,12 +107,14 @@ def __init__(
         post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
+        image_size: tuple[int, int] | int | None = None,
     ) -> None:
         super().__init__(
             pre_processor=pre_processor,
             post_processor=post_processor,
             evaluator=evaluator,
             visualizer=visualizer,
+            image_size=image_size,
         )
 
         self.automatic_optimization = False