open-edge-platform
diff --git a/‎docs/source/markdown/guides/how_to/pipelines/index.md‎
Lines changed: 7 additions & 0 deletions b/‎docs/source/markdown/guides/how_to/pipelines/index.md‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md‎
Lines changed: 162 additions & 0 deletions b/‎docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md‎
Lines changed: 162 additions & 0 deletions
diff --git a/‎src/anomalib/data/datamodules/base/image.py‎
Lines changed: 7 additions & 3 deletions b/‎src/anomalib/data/datamodules/base/image.py‎
Lines changed: 7 additions & 3 deletions
diff --git a/‎src/anomalib/pipelines/tiled_ensemble/__init__.py‎
Lines changed: 44 additions & 0 deletions b/‎src/anomalib/pipelines/tiled_ensemble/__init__.py‎
Lines changed: 44 additions & 0 deletions
diff --git a/‎src/anomalib/pipelines/tiled_ensemble/components/__init__.py‎
Lines changed: 51 additions & 0 deletions b/‎src/anomalib/pipelines/tiled_ensemble/components/__init__.py‎
Lines changed: 51 additions & 0 deletions
@@ -6,6 +6,13 @@ This section contains tutorials on how to use different pipelines of Anomalib an
 :margin: 1 1 0 0
 :gutter: 1
 
+:::{grid-item-card} {octicon}`stack` Tiled Ensemble
+:link: ./tiled_ensemble
+:link-type: doc
+
+Learn more about how to use the tiled ensemble pipelines.
+:::
+
 :::{grid-item-card} {octicon}`gear` Custom Pipeline
 :link: ./custom_pipeline
 :link-type: doc
 
@@ -0,0 +1,162 @@
+# Tiled ensemble
+
+This guide will show you how to use **The Tiled Ensemble** method for anomaly detection. For more details, refer to the official [Paper](https://openaccess.thecvf.com/content/CVPR2024W/VAND/html/Rolih_Divide_and_Conquer_High-Resolution_Industrial_Anomaly_Detection_via_Memory_Efficient_CVPRW_2024_paper.html).
+
+The tiled ensemble approach reduces memory consumption by dividing input images into a grid of tiles and training a dedicated model for each tile location.
+It is compatible with any existing image anomaly detection model without the need for any modification of the underlying architecture.
+
+![Tiled ensemble flow](../../../../images/tiled_ensemble/ensemble_flow.png)
+
+```{note}
+This feature is experimental and may not work as expected.
+For any problems refer to [Issues](https://github.com/open-edge-platform/anomalib/issues) and feel free to ask any question in [Discussions](https://github.com/open-edge-platform/anomalib/discussions).
+```
+
+## Training
+
+You can train a tiled ensemble using the training script located inside `tools/tiled_ensemble` directory:
+
+```{code-block} bash
+
+python tools/tiled_ensemble/train_ensemble.py \
+    --config tools/tiled_ensemble/ens_config.yaml
+```
+
+By default, the Padim model is trained on **MVTec AD bottle** category using image size of 256x256, divided into non-overlapping 128x128 tiles.
+You can modify these parameters in the [config file](#ensemble-configuration).
+
+## Evaluation
+
+After training, you can evaluate the tiled ensemble on test data using:
+
+```{code-block} bash
+
+python tools/tiled_ensemble/eval.py \
+    --config tools/tiled_ensemble/ens_config.yaml \
+    --root path_to_results_dir
+
+```
+
+Ensure that `root` points to the directory containing the training results, typically `results/padim/mvtec/bottle/runX`.
+
+## Ensemble configuration
+
+Tiled ensemble is configured using `ens_config.yaml` file in the `tools/tiled_ensemble` directory.
+It contains general settings and tiled ensemble specific settings.
+
+### General
+
+General settings at the top of the config file are used to set up the random `seed`, `accelerator` (device) and the path to where results will be saved `default_root_dir`.
+
+```{code-block} yaml
+seed: 42
+accelerator: "cuda"
+default_root_dir: "results"
+```
+
+### Tiling
+
+This section contains the following settings, used for image tiling:
+
+```{code-block} yaml
+
+tiling:
+  image_size: [256, 256]
+  tile_size: [128, 128]
+  stride: 128
+```
+
+These settings determine the whole original image size, tile size, and tile stride.
+
+Input image is resized to `image_size` and split into tiles, where each tile is of shape set by `tile_size` and tiles are taken with step set by `stride`.
+For example: having image_size: 512, tile_size: 256, and stride: 256, results in 4 non-overlapping tile locations.
+
+### Normalization and thresholding
+
+Next up are the normalization and thresholding settings:
+
+```{code-block} yaml
+normalization_stage: image
+thresholding_stage: image
+```
+
+- **Normalization**: Can be applied per each tile location separately (`tile` option), after combining predictions (`image` option), or skipped (`none` option).
+
+- **Thresholding**: Can also be applied at different stages, but it is limited to `tile` and `image`.
+
+### Data
+
+The `data` section is used to configure the parameters for the dataset used.
+
+```{code-block} yaml
+data:
+  class_path: anomalib.data.MVTecAD
+  init_args:
+    root: ./datasets/MVTecAD
+    category: bottle
+    train_batch_size: 32
+    eval_batch_size: 32
+    num_workers: 8
+    train_augmentations: null
+    val_augmentations: null
+    test_augmentations: null
+    augmentations: null
+    test_split_mode: from_dir
+    test_split_ratio: 0.2
+    val_split_mode: same_as_test
+    val_split_ratio: 0.5
+```
+
+Refer to [Data](../../reference/data/index.md) for more details.
+
+### SeamSmoothing
+
+This section contains settings for `SeamSmoothing` block of pipeline:
+
+```{code-block} yaml
+SeamSmoothing:
+  apply: True
+  sigma: 2
+  width: 0.1
+
+```
+
+SeamSmoothing job is responsible for smoothing of regions where tiles meet - called tile seams.
+
+- **apply**: If True, smoothing will be applied.
+- **sigma**: Controls the sigma of Gaussian filter used for smoothing.
+- **width**: Sets the percentage of the region around the seam to be smoothed.
+
+### TrainModels
+
+The last section `TrainModels` contains the setup for model training:
+
+```{code-block} yaml
+TrainModels:
+  model:
+    class_path: Fastflow
+
+  trainer:
+    max_epochs: 500
+    callbacks:
+      - class_path: lightning.pytorch.callbacks.EarlyStopping
+        init_args:
+          patience: 42
+          monitor: pixel_AUROC
+          mode: max
+```
+
+- **Model**: Specifies the model used. Refer to [Models](../../reference/models/image/index.md) for more details on the model parameters.
+- **Trainer**: _optional_ parameters, used to control the training process. Refer to [Engine](../../reference/engine/index.md) for more details.
+
+### Citation
+
+```BibTeX
+@inproceedings{rolih2024divide,
+  title={Divide and Conquer: High-Resolution Industrial Anomaly Detection via Memory Efficient Tiled Ensemble},
+  author={Rolih, Bla{\v{z}} and Ameln, Dick and Vaidya, Ashwin and Akcay, Samet},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={3866--3875},
+  year={2024}
+}
+```
@@ -45,6 +45,8 @@
 from anomalib.utils.attrs import get_nested_attr
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from pandas import DataFrame
 
 
@@ -126,6 +128,8 @@ def __init__(
 
         self._is_setup = False  # flag to track if setup has been called
 
+        self.external_collate_fn: Callable | None = None
+
     @property
     def name(self) -> str:
         """Name of the datamodule.
@@ -362,7 +366,7 @@ def train_dataloader(self) -> TRAIN_DATALOADERS:
             shuffle=True,
             batch_size=self.train_batch_size,
             num_workers=self.num_workers,
-            collate_fn=self.train_data.collate_fn,
+            collate_fn=self.external_collate_fn or self.train_data.collate_fn,
         )
 
     def val_dataloader(self) -> EVAL_DATALOADERS:
@@ -376,7 +380,7 @@ def val_dataloader(self) -> EVAL_DATALOADERS:
             shuffle=False,
             batch_size=self.eval_batch_size,
             num_workers=self.num_workers,
-            collate_fn=self.val_data.collate_fn,
+            collate_fn=self.external_collate_fn or self.val_data.collate_fn,
         )
 
     def test_dataloader(self) -> EVAL_DATALOADERS:
@@ -390,7 +394,7 @@ def test_dataloader(self) -> EVAL_DATALOADERS:
             shuffle=False,
             batch_size=self.eval_batch_size,
             num_workers=self.num_workers,
-            collate_fn=self.test_data.collate_fn,
+            collate_fn=self.external_collate_fn or self.test_data.collate_fn,
         )
 
     def predict_dataloader(self) -> EVAL_DATALOADERS:
 
@@ -0,0 +1,44 @@
+"""Tiled Ensemble Pipeline for High-Resolution Anomaly Detection.
+
+This module implements a memory-efficient tiled ensemble approach for
+anomaly detection, enabling high-resolution image processing without exceeding GPU memory constraints.
+The pipeline divides input images into a grid of tiles, training a dedicated model for each tile location.
+By introducing overlapping tiles, it leverages the benefits of traditional
+stacking ensembles, enhancing anomaly detection capabilities beyond high resolution alone.
+
+Configuration:
+    The pipeline is configured via the `ens_config.yaml` file, which
+    includes settings for:
+        - Tile size and stride
+        - Normalization and thresholding stages
+        - Data parameters
+        - Seam smoothing parameters
+        - Training parameters (e.g., model type, trainer settings)
+
+Usage:
+    Training:
+        python tools/tiled_ensemble/train_ensemble.py \
+            --config tools/tiled_ensemble/ens_config.yaml
+
+    Evaluation:
+        python tools/tiled_ensemble/eval.py \
+            --config tools/tiled_ensemble/ens_config.yaml \
+            --root path_to_results_dir (e.g. results/Padim/MVTec/bottle/v0)
+
+Reference:
+    Blaž Rolih, Dick Ameln, Ashwin Vaidya, Samet Akçay:
+    "Divide and Conquer: High-Resolution Industrial Anomaly Detection via
+    Memory Efficient Tiled Ensemble." Proceedings of the IEEE/CVF Conference
+    on Computer Vision and Pattern Recognition Workshops (VAND 2.0). 2024.
+"""
+
+# Copyright (C) 2024-2025 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .test_pipeline import EvalTiledEnsemble
+from .train_pipeline import TrainTiledEnsemble
+
+__all__ = [
+    "TrainTiledEnsemble",
+    "EvalTiledEnsemble",
+]
@@ -0,0 +1,51 @@
+"""Core Components for the Tiled Ensemble Pipeline.
+
+This module aggregates the essential components utilized in the Tiled Ensemble.
+Each component is designed to handle specific stages of the pipeline.
+
+Included Components:
+    - `merging`: Job to merge predictions from individual tiles into a whole output.
+    - `metrics_calculation`: Job to compute evaluation metrics at image levels.
+    - `model_training`: Job for training models on individual tiles.
+    - `normalization`: Job to normalize predictions.
+    - `prediction`: Job to generate predictions for each tile.
+    - `smoothing`: Job to smooth seams between tiles for seamless reconstruction.
+    - `stats_calculation`: Job to compute statistics required by normalisation and thresholding.
+    - `thresholding`: Job to apply thresholds to predictions.
+    - `visualization`: Job to visualize predictions and anomalies.
+
+Reference:
+    Blaž Rolih, Dick Ameln, Ashwin Vaidya, Samet Akçay:
+    "Divide and Conquer: High-Resolution Industrial Anomaly Detection via
+    Memory Efficient Tiled Ensemble." Proceedings of the IEEE/CVF Conference
+    on Computer Vision and Pattern Recognition Workshops (VAND 2.0). 2024.
+"""
+
+# Copyright (C) 2024-2025 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .merging import MergeJobGenerator
+from .metrics_calculation import MetricsCalculationJobGenerator
+from .model_training import TrainModelJobGenerator
+from .normalization import NormalizationJobGenerator
+from .prediction import PredictJobGenerator
+from .smoothing import SmoothingJobGenerator
+from .stats_calculation import StatisticsJobGenerator
+from .thresholding import ThresholdingJobGenerator
+from .utils import NormalizationStage, PredictData, ThresholdingStage
+from .visualization import VisualizationJobGenerator
+
+__all__ = [
+    "NormalizationStage",
+    "ThresholdingStage",
+    "PredictData",
+    "TrainModelJobGenerator",
+    "PredictJobGenerator",
+    "MergeJobGenerator",
+    "SmoothingJobGenerator",
+    "StatisticsJobGenerator",
+    "NormalizationJobGenerator",
+    "ThresholdingJobGenerator",
+    "VisualizationJobGenerator",
+    "MetricsCalculationJobGenerator",
+]